How to use

WriteServerConfig

in

com.netflix.eureka2.server.config

public WriteCommandLineParser(String... args) {
  super(WriteServerConfig.writeBuilder(), false, args);
}

  @Inject
  public TcpRegistrationServer(WriteServerConfig config,
                 @Named("registration") MetricEventsListenerFactory servoEventsListenerFactory,
                 Provider<TcpRegistrationHandler> tcpRegistrationHandler) {
    super(servoEventsListenerFactory, config, config.getRegistrationPort(),
        EurekaTransports.registrationPipeline(config.getCodec()), tcpRegistrationHandler);
  }
}

  @Inject
  public TcpReplicationServer(WriteServerConfig config,
                Provider<TcpReplicationHandler> tcpReplicationHandler,
                @Named("replication") MetricEventsListenerFactory servoEventsListenerFactory) {
    super(servoEventsListenerFactory, config, config.getReplicationPort(), EurekaTransports.replicationPipeline(config.getCodec()), tcpReplicationHandler);
  }
}

@Inject
public ReplicationService(WriteServerConfig config,
             EurekaServerRegistry eurekaRegistry,
             SelfRegistrationService selfRegistrationService,
             ReplicationPeerAddressesProvider peerAddressesProvider,
             WriteServerMetricFactory metricFactory) {
  this.eurekaRegistry = eurekaRegistry;
  this.selfRegistrationService = selfRegistrationService;
  this.peerAddressesProvider = peerAddressesProvider;
  this.metricFactory = metricFactory;
  this.codec = config.getCodec();
  this.reconnectDelayMillis = config.getReplicationReconnectDelayMillis();
}

@Override
public WriteServerReport serverReport() {
  return new WriteServerReport(
      config.getRegistrationPort(),
      config.getDiscoveryPort(),
      config.getReplicationPort(),
      formatAdminURI(),
      getEurekaServerRegistry().size()
  );
}

@Inject
public BackupClusterResolverProvider(WriteServerConfig config) {
  if (config.getBootstrapServerList() != null) {
    resolver = EurekaClusterResolvers.readClusterResolverFromConfiguration(
        config.getBootstrapResolverType(),
        Arrays.asList(config.getBootstrapServerList()),
        Schedulers.computation()
    );
  } else {
    resolver = EurekaClusterResolvers.writeClusterResolverFromConfiguration(
        config.getServerResolverType(),
        Arrays.asList(config.getServerList()),
        Schedulers.computation()
    );
  }
}

  @Override
  public WriteServerConfig build() {
    return new WriteServerConfig(
        resolverType,
        serverList,
        codec,
        appName,
        vipAddress,
        dataCenterType,
        shutDownPort,
        webAdminPort,
        registrationPort,
        replicationPort,
        discoveryPort,
        replicationReconnectDelayMillis,
        evictionTimeoutMs,
        evictionStrategyType,
        evictionStrategyValue
    );
  }
}

@Override
protected void loadInstanceProperties(Properties props) {
  super.loadInstanceProperties(props);
  props.setProperty("eureka.client.discovery-endpoint.port", Integer.toString(config.getDiscoveryPort()));
}

@Override
public WriteServerConfig build() {
  return new WriteServerConfig(
      resolverType,
      serverList,

public WriteCommandLineParser(String... args) {
  super(WriteServerConfig.writeBuilder(), false, args);
}

@PostConstruct
public void start() {
  server = RxNetty.newTcpServerBuilder(
      config.getReplicationPort(),
      new TcpReplicationHandler(selfRegistrationService, eurekaRegistry, evictionQueue, metricFactory))
      .pipelineConfigurator(EurekaTransports.replicationPipeline(config.getCodec()))
      .withMetricEventsListenerFactory(servoEventsListenerFactory)
      .build()
      .start();
  logger.info("Starting TCP replication server on port {} with {} encoding...", server.getServerPort(), config.getCodec());
}

  @PostConstruct
  public void start() {
    server = RxNetty.newTcpServerBuilder(
        config.getRegistrationPort(),
        new TcpRegistrationHandler(eurekaRegistry, evictionQueue, metricFactory))
        .pipelineConfigurator(EurekaTransports.registrationPipeline(config.getCodec()))
        .withMetricEventsListenerFactory(servoEventsListenerFactory)
        .build()
        .start();

    logger.info("Starting TCP registration server on port {} with {} encoding...", server.getServerPort(), config.getCodec());
  }
}

@Override
protected void before() throws Throwable {
  WriteServerConfig config = WriteServerConfig.writeBuilder()
      .withAppName(name)
      .withVipAddress(name)
      .withDataCenterType(DataCenterType.Basic)
      .withRegistrationPort(0)
      .withDiscoveryPort(0)
      .withReplicationPort(0)
      .withCodec(Codec.Avro)
      .withShutDownPort(0)
      .withWebAdminPort(0)
      .withReplicationRetryMillis(1000)
      .build();
  server = new EmbeddedWriteServer(config, Observable.<ChangeNotification<InetSocketAddress>>never(), false, false);
  server.start();
}

@Override
protected void before() throws Throwable {
  WriteServerConfig config = WriteServerConfig.writeBuilder()
      .withAppName(name)
      .withVipAddress(name)
      .withReadClusterVipAddress(readClusterName)
      .withDataCenterType(DataCenterType.Basic)
      .withHttpPort(0)
      .withRegistrationPort(0)
      .withDiscoveryPort(0)
      .withReplicationPort(0)
      .withCodec(codec)
      .withShutDownPort(0)
      .withWebAdminPort(0)
      .withReplicationRetryMillis(1000)
      .build();
  Observable<ChangeNotification<Server>> noPeers = Observable.never();
  server = new EmbeddedWriteServer(config, noPeers, noPeers, false, false);
  server.start();
}

@Override
public int scaleUpByOne() {
  WriteServerAddress writeServerAddress = new WriteServerAddress("localhost", nextAvailablePort, nextAvailablePort + 1, nextAvailablePort + 2);
  WriteServerConfig config = WriteServerConfig.writeBuilder()
      .withAppName(WRITE_SERVER_NAME)
      .withVipAddress(WRITE_SERVER_NAME)
      .withDataCenterType(DataCenterType.Basic)
      .withRegistrationPort(writeServerAddress.getRegistrationPort())
      .withDiscoveryPort(writeServerAddress.getDiscoveryPort())
      .withReplicationPort(writeServerAddress.getReplicationPort())
      .withCodec(Codec.Avro)
      .withShutDownPort(nextAvailablePort + 3)
      .withWebAdminPort(nextAvailablePort + 4)
      .withReplicationRetryMillis(1000)
      .build();
  EmbeddedWriteServer newServer = newServer(config);
  newServer.start();
  nextAvailablePort += 10;
  return scaleUpByOne(newServer, writeServerAddress);
}

int adminPort = ephemeralPorts ? 0 : nextAvailablePort + 4;
WriteServerConfig config = WriteServerConfig.writeBuilder()
    .withAppName(WRITE_SERVER_NAME)
    .withVipAddress(WRITE_SERVER_NAME)