How to use the jsprim.deepCopy function in jsprim

'async': [],
	    'deposed': [],
	    'initWal': '0/0000001e'
	},
	'zkpeers': [ 'node1', 'node3' ],
	'pg': {
	    'online': true,
	    'config': {
	        'role': 'primary',
		'upstream': null,
		'downstream': node3url
	    }
	}
};

primState4 = mod_jsprim.deepCopy(primState3);
primState4.zkpeers.push('node2');
primState4.zkstate.async.push('node2');

deposedState = {
	'role': 'deposed',
	'zkstate': {
	    'generation': 5,
	    'primary': 'node3',
	    'sync': 'node2',
	    'async': [],
	    'deposed': [ 'node1' ],
	    'initWal': '0/00000028'
	},
	'zkpeers': [ 'node1', 'node3', 'node2' ],
	'pg': {
	    'online': false,

mod_assertplus.arrayOfObject(args.metrics, 'args.metrics');
	mod_assertplus.string(args.filename, 'args.filename');
	mod_assertplus.optionalObject(args.streamOptions, 'args.streamOptions');
	mod_assertplus.optionalObject(args.config, 'args.config');

	streamoptions = mod_streamutil.streamOptions(
	    args.streamOptions, { 'objectMode': true },
	    { 'highWaterMark': 512 });
	mod_stream.Transform.call(this, streamoptions);
	mod_vstream.wrapTransform(this);

	this.is_log = args.log;
	this.is_metrics = args.metrics;
	this.is_dbtmpfilename = dbfilename = args.filename + '.' + process.pid;
	this.is_dbfilename = args.filename;
	this.is_config = mod_jsprim.deepCopy(args.config || {});

	this.is_db = null;
	this.is_insert = null;
	this.is_ready = false;
	this.is_buffered = [];
	this.is_flushcb = null;

	dirname = mod_path.dirname(dbfilename);
	mod_mkdirp(dirname, function (err) {
		if (err) {
			err = new VError(err, 'failed to create "%s"', dirname);
			self.is_log.error(err, 'initialization error');
			self.emit('error', err);
			return;
		}

function validateAndCopy(schema, obj)
{
	var error;
	error = mod_jsprim.validateJsonObject(schema, obj);
	if (error !== null)
		return (error);
	return (mod_jsprim.deepCopy(obj));
}

function createPredicate(pred, types)
{
	krillPrimValidateSyntax(pred);

	if (arguments.length >= 2 && types !== null) {
		mod_jsprim.forEachKey(types, function (k, v) {
			if (v !== 'string' && v !== 'number' && v !== 'boolean')
				throw (new VError(
				    'field "%s": unknown type "%s"', k, v));
		});

		krillPrimValidateTypes(types, pred);
	}

	return (new Predicate(mod_jsprim.deepCopy(pred), types));
}

DragnetConfig.prototype.clone = function ()
{
	var rv;
	rv = new DragnetConfig();
	rv.dc_datasources = mod_jsprim.deepCopy(this.dc_datasources);
	rv.dc_metrics = mod_jsprim.deepCopy(this.dc_metrics);
	return (rv);
};

Predicate.prototype.replaceFields = function (xlate)
{
	var newpred = mod_jsprim.deepCopy(this.p_pred);
	krillPrimWalk(function (subpred, key) {
		var field = subpred[key][0];
		var value = mod_jsprim.pluck(xlate, field);
		if (value === undefined)
			throw (new VError('subpredicate "%j": ' +
			    'no translation for field "%s"',
			    subpred, field));
		subpred[key][0] = value;
	}, newpred);
	return (new Predicate(newpred, this.p_types));
};

Simulator.prototype.simpleZkState = function (zkstate, raw)
{
	if (zkstate === null)
		return (null);

	if (raw)
		return (zkstate);

	var rv = mod_jsprim.deepCopy(zkstate);
	rv.primary = rv.primary.id;
	if (rv.sync !== null)
		rv.sync = rv.sync.id;
	rv.async = rv.async.map(function (p) { return (p.id); });
	rv.deposed = rv.deposed.map(function (p) { return (p.id); });
	return (rv);
};

function createVolapiClient(config) {
    assert.object(config, 'config');

    var volapiConfig = jsprim.deepCopy(config.volapi);

    volapiConfig.version = '^1';
    volapiConfig.userAgent = 'sdc-docker';

    return new VOLAPI(volapiConfig);
}