return new ZooKeeperConnectionManager(_zkHostname + ":" + _zkPort,

                                          _sessionTimeoutInMs,

                                          _basePath,

                                          _announcer);

  }

  public ZooKeeperConnectionManager build()

  {

    _announcer.setWeight(1d);

                                          _sessionTimeoutInMs,

                                          _basePath,

                                          new ZKUriStoreFactory(),

                                          _announcer);

  }

    // all the configuration here are permanent, no need to re-write as long as ZooKeeper still has the data

    // therefore in real case, do this "discovery" step separately

    final HttpServer server = RestLiExampleBasicServer.createServer();

    startServer(server, zkConn);

    System.out.println("Example server with D2 is running with URL " + RestLiExampleBasicServer.getServerUrl() + ". Press any key to stop server.");

    System.in.read();

    SimpleLoadBalancerState state = new SimpleLoadBalancerState(

            executorService, uriBus, clusterBus, serviceBus, _clientFactories, _loadBalancerStrategyFactories,

            _sslContext, _sslParameters, _isSSLEnabled, _clientServicesConfig);

    TogglingLoadBalancer togLB = _factory.createBalancer(balancer, state, clusterToggle, serviceToggle, uriToggle);

    togLB.start(new Callback<None>() {

      @Override

                                                                             fsServiceStore,

                                                                             serviceBus);

    TogglingPublisher<UriProperties> uriToggle = _factory.createUriToggle(zkUriRegistry, fsUriStore, uriBus);

            executorService, uriBus, clusterBus, serviceBus, _clientFactories, _loadBalancerStrategyFactories,

            _sslContext, _sslParameters, _isSSLEnabled, _clientServicesConfig);

    SimpleLoadBalancer balancer = new SimpleLoadBalancer(state, _lbTimeout, _lbTimeoutUnit);

    TogglingLoadBalancer togLB = _factory.createBalancer(balancer, state, clusterToggle, serviceToggle, uriToggle);

  private FileOutputStream                                                         _messageLog;

  public static void main(String[] args) throws Exception

  {

    System.err.println(2);

    System.err.println(3);

    System.err.println(4);

    System.err.println(5);

    System.err.println(6);

    System.err.println(7);

    System.err.println(8);

    new SimpleLoadBalancerSimulation(new DegraderLoadBalancerStrategyFactoryV3()).simulateMultithreaded(50,

                                                                                                                                                     1000000,

                                                                                                                                                     999999999);

  }

  {

    List<SchemeStrategyPair> orderedStrategies = new ArrayList<SchemeStrategyPair>(prioritizedSchemes.size());

    for (String scheme : prioritizedSchemes)

    {

      if (strategy != null)

      {

        orderedStrategies.add(new SchemeStrategyPair(

                                scheme,

                                getStrategy(serviceName, scheme))

                                                            null,

                                                            schemes,

                                                            null));

    assertNotNull(strategy);

    assertTrue(strategy instanceof RandomLoadBalancerStrategy);

  }

                                                            null));

    assertNotNull(_state.getStrategy("service-1", "http"));

    assertNotNull(strategy);

    assertTrue(strategy instanceof RandomLoadBalancerStrategy);

    // check that we're getting the exact same strategy (by pointer) every time

    assertTrue(strategy == _state.getStrategy("service-1", "http"));

    assertTrue(strategy == _state.getStrategy("service-1", "http"));

    // now make sure adding a cluster property won't change the strategy

    _clusterRegistry.put("cluster-1", new ClusterProperties("cluster-1"));

    // we should still have the same strategy now

    assertNotNull(newStrategy);

    assertTrue(strategy == newStrategy);

    assertTrue(newStrategy instanceof RandomLoadBalancerStrategy);

    strategy = newStrategy;

                                                            null));

    _clusterRegistry.put("cluster-1", new ClusterProperties("cluster-1"));

    assertNotNull(strategy);

    assertTrue(strategy instanceof RandomLoadBalancerStrategy);

    // now add the degraderV3 strategy into the Strategy list