start gossiper with options

@param	{object}	oOptions
@private
773453
function _gossiperStartWithOptions( oOptions )
{
	//
	//	create Gossiper instance
	//
	_oGossiper	= new Gossiper( oOptions );

	//
	//	listen ...
	//
	_oGossiper.on( 'peer_update', ( sPeerUrl, sKey, vValue ) =>
	{
		// console.log( `GOSSIPER ))) EVENT [peer_update] (${ GossiperUtils.isReservedKey( sKey ) ? "Reserved" : "Customized" }):: `, sPeerUrl, sKey, vValue );

		//
		//	callback while we received a update from remote peers
		//
		if ( ! GossiperUtils.isReservedKey( sKey ) )
		{
			_oGossiperOptions.pfnPeerUpdate( sPeerUrl, sKey, vValue );
		}
	});
	_oGossiper.on( 'peer_alive', ( sPeerUrl ) =>
	{
		// console.log( `GOSSIPER ))) EVENT [peer_alive] :: `, sPeerUrl );
	});
	_oGossiper.on( 'peer_failed', ( sPeerUrl ) =>
	{
		console.error( `GOSSIPER ))) EVENT [peer_failed] :: `, sPeerUrl );
	});
	_oGossiper.on( 'new_peer', ( sPeerUrl ) =>
	{
		// console.log( `GOSSIPER ))) EVENT [new_peer] :: `, sPeerUrl );
		if ( sPeerUrl !== _oGossiperOptions.url &&
			! _oGossiper.m_oRouter.getSocket( sPeerUrl ) )
		{
			//
			//	try to connect to the new peer
			//
			_oGossiperOptions.pfnConnectToPeer( sPeerUrl, ( err, oNewWs ) =>
			{
				if ( err )
				{
					return console.error( `GOSSIPER ))) failed to connectToPeer: ${ sPeerUrl }.` );
				}
				if ( ! oNewWs )
				{
					return console.error( `GOSSIPER ))) connectToPeer returns an invalid oNewWs: ${ JSON.stringify( oNewWs ) }.` );
				}

				//
				//	update the remote socket
				//
				if ( ! DeUtilsCore.isPlainObjectWithKeys( oNewWs, 'url' ) ||
					! GossiperUtils.isValidPeerUrl( oNewWs.url ) )
				{
					oNewWs.url	= sPeerUrl;
				}

				//
				//	update router
				//
				_oGossiper.updatePeerList({
					[ sPeerUrl ] : oNewWs
				});
			});
		}
	});
	_oGossiper.on( 'log', ( sType, vData ) =>
	{
		// console.log( `GOSSIPER ))) EVENT [log/${ sType }] :: `, vData );
	});


	//
	//	start gossiper
	//
	_oGossiper.start( {} );
}
688721
function(options) {
    options = options ? extend({}, options) : {};
    if (options.parse === void 0){
      options.parse = true;
    }
    var collection = this;
    var listener = {};
    var listenerKey;

    options.cb = options.callback;
    options.callback = function (err, response){
      callback(err, collection, response, options);
    };

    options.respCallback = function cb(data, cbServer){
      var method = options.reset ? 'reset' : 'set';
      collection.removeListeners([collection.events.onFetch]);
      if(cbServer){
        cbServer();
      }
      if(data.err){
        return callback(data.err, collection, data, options);
      }
      collection[method](data.response, options);
      callback(data.err, collection, data, options);
    };

    listenerKey = this.events.onFetch;
    listener[listenerKey] = {fn: options.respCallback, active: true};
    this.addListeners(listener);
    this.emit(this.events.fetch, this, options);
    return collection;
  }
1093857
function updateConnectedPeer( oSockets )
{
	if ( ! oSockets )
	{
		console.error( `GOSSIPER ))) call updateConnectedPeer with null oSockets.` );
		return 0;
	}
	if ( ! DeUtilsCore.isPlainObject( oSockets ) )
	{
		console.error( `GOSSIPER ))) call updateConnectedPeer with invalid oSockets.` );
		return 0;
	}
	if ( ! DeUtilsCore.isPlainObjectWithKeys( oSockets, 'url' ) )
	{
		console.error( `GOSSIPER ))) call updateConnectedPeer with invalid oSockets, no url property.` );
		return 0;
	}
	if ( ! GossiperUtils.isValidPeerUrl( oSockets.url ) )
	{
		console.error( `GOSSIPER ))) call updateConnectedPeer with invalid oSockets.url: ${ JSON.stringify( oSockets.url ) }.` );
		return 0;
	}


	//
	//	copy the socket to pending memory cache
	//
	_oPendingUpdatePeerSockets[ oSockets.url ] = oSockets;

	if ( _oGossiper )
	{
		//
		//	try to update them
		//
		_oGossiper.updatePeerList( Object.assign( {}, _oPendingUpdatePeerSockets ) );
		_oPendingUpdatePeerSockets = {};
	}
	else
	{
		//
		//	Ops, our gossiper service is not ready yet!
		//	we have added the socket to associated memory cache, they will be safely updated in the future.
		//
	}
}
444521
function(opts){
  //setup options
  this.opts = new ObjectManage({
    username: '',
    password: '',
    domain: 'cdn.oose.io',
    prism: {
      host: null,
      port: 5971
    }
  })
  this.opts.$load(opts)
  //set properties
  this.api = {}
  this.authenticated = false
  this.connected = false
  this.session = {}
}
830512
function loglet(opt, _done) {
  var done = (typeof _done === 'function' ? _done : noop);
  if (typeof opt !== 'object' || !opt) {
    console.warn('loglet: missing options. Usage: loglet({key, secret})');
    return done(new Error('Invalid loglet.io configuration'));
  }
  if(typeof opt.key !== 'string') {
    console.warn('loglet: missing key. Usage: loglet({key, secret})');
    return done(new Error('Invalid loglet.io configuration'));
  }
  if (clientObj) {
    console.warn('loglet: already initialized.');
    return done();
  }
  opt = ObjectAssign({}, DEFAULT_OPTIONS, opt);
  clientObj = createConnection(this, opt, done, emit);
  loglet.on('connect', flushEvents);
  return loglet;
}
830028
function (options) {
                var self = this;

                self._requestQueue = []

                self._socketOptions = angular.extend({}, _socketDefaults, options);

                self._socket = new TmpSocket();

                if (self._socketOptions.autoConnect) self.connect();
            }
114187
function WebsocketBroker(options) {
  // Superclass Constructor
  EventEmitter.call(this);

  options = options || {};
  this.clientsPath = [];
  this.host = options.host || 'localhost';
  this.port = options.port || 8000;
  this.endpoints = options.endpoints || [];
  this.websocketEndpoints = {};

  this.wsServer = null;
  this.httpServer = null;
}
1226915
function(options) {
        options = options || {};
        options.handlerOptions = options.handlerOptions || this.defaultHandlerOptions;
        OpenLayers.Control.prototype.initialize.apply(this, [options]);
        this.resetHandler();
    }
819531
public void run() {
        while(running.get()) {
            try {
                Thread.sleep(gossipInterval);
            } catch(InterruptedException e) {
                Thread.currentThread().interrupt();
            }
            Node node = selectPeer();
            adminClient.setAdminClientCluster(metadataStore.getCluster());

            if(logger.isDebugEnabled())
                logger.debug("Starting gossip with " + node);

            for(String key: MetadataStore.GOSSIP_KEYS) {
                try {
                    gossipKey(node, key);
                } catch(VoldemortException e) {
                    logger.warn("Unable to Gossip key " + key + " with " + node, e);
                }
            }
        }
    }
787116
function startServer() {
    this._flo = flo(
      // The path to watch (see `setOptions(…)`).
      this.config.publicPath,
      // The config-provided fb-flo options + a generic watch glob
      // (all JS/CSS, at any depth) inside the watched path.
      extend(
        pick(this.config, FB_FLO_OPTIONS),
        { glob: ['**/*.js', '**/*.css'] }
      ),
      // Our resolver method (it was properly bound upon construction).
      this.resolver
    );
  }
460351
@Override
    public synchronized void gossiperStarting()
    {
        gossiperInitialized = true;
        StorageService.instance.gossipSnitchInfo();
        Gossiper.instance.register(new ReconnectableSnitchHelper(this, localNodeData.datacenter, true));
    }
575417
function(options) {
  stream.Duplex.call(this, { objectMode: true });

  this.options = extend(true, Pipeline.DEFAULTS, options || {});
  this.readyState = 0; // 0: closed, 1: open

  this._pipeline = [];

  this.setMaxListeners(0); // unlimited listeners allowed

  this.options.ipc.subscribe(
    this.options.ipc.namespace,
    this._proxy.bind(this)
  );
}
118857
function(options) {
        OpenLayers.Strategy.prototype.initialize.apply(this, [options]);
        this.events = new OpenLayers.Events(this);
    }
1114947
function WSMux(urlOrWs, options) {
  EventEmitter.call(this);
  this.options = util._extend({mask: true}, options);
  this.closed = false;
  this.channels = {};
  this.pending = [];
  this._openWebsocket(urlOrWs);
}
743607
function(options) {
      inputEx.UneditableField.superclass.setOptions.call(this,options);
      this.options.visu = options.visu;
   }
853911
public void start(U options) throws IOException {
    List<T> servers = new ArrayList<>();
    for (T server : getServers()) {
      try {
        server.start(options);
        servers.add(server);
      } catch (IOException e) {
        for (T started : servers) {
          started.stop();
        }
        throw e;
      }
    }
  }
1221103
function runPrompts (opts) {
  if (opts.questionnaire && this.init.configure) {
    this.sprout.emit('msg', 'running questionnaire function')
    const unansweredConfig = lodash.filter(this.init.configure, (q) => {
      return !lodash.includes(lodash.keys(this.config), q.name)
    })
    return opts.questionnaire(unansweredConfig)
      .then((answers) => { return lodash.assign(this.config, answers) })
  }
}