@Inject public TcpDiscoveryServer(EurekaServerConfig config, @Named("discovery") MetricEventsListenerFactory servoEventsListenerFactory, Provider<TcpDiscoveryHandler> tcpDiscoveryHandler) { super(servoEventsListenerFactory, config, config.getDiscoveryPort(), EurekaTransports.interestPipeline(config.getCodec()), tcpDiscoveryHandler); } }
public ReadCommandLineParser(String... args) { super(EurekaServerConfig.baseBuilder(), true, args); }
@Override public EurekaServerConfig build() { return new EurekaServerConfig( resolverType, serverList, codec, appName, vipAddress, dataCenterType, shutDownPort, webAdminPort, discoveryPort ); } }
private ServerResolver createWriteServerResolver(Func1<ServerBootstrap, Integer> getPortFunc) { EurekaCommonConfig.ResolverType resolverType = config.getServerResolverType(); if (resolverType == null) { throw new IllegalArgumentException("Write cluster resolver type not defined"); } ServerResolver resolver; ServerBootstrap[] bootstraps = ServerBootstrap.from(config.getServerList()); if (resolverType == ResolverType.dns) { resolver = forDNS(bootstraps, getPortFunc); } else { resolver = forFixed(bootstraps, getPortFunc); } return resolver; }
@PostConstruct public void start() { server = RxNetty.newTcpServerBuilder(serverPort, tcpHandlerProvider.get()) .pipelineConfigurator(pipelineConfigurator) .withMetricEventsListenerFactory(servoEventsListenerFactory) .build() // .withErrorHandler() TODO use a custom handler (?) as the default emits extraneous error logs .start(); logger.info("Starting {} on port {} with {} encoding...", getClass().getSimpleName(), server.getServerPort(), config.getCodec()); }
public int getInteralReadServerPort() { return config.getDiscoveryPort(); }
@Override public InstanceInfo.Builder call(DataCenterInfo dataCenterInfo) { final String instanceId = config.getAppName() + '#' + UUID.randomUUID().toString(); String address = AddressSelector.selectBy().publicIp(true).or().any().returnNameOrIp(dataCenterInfo.getAddresses()); HashSet<String> healthCheckUrls = new HashSet<String>(); healthCheckUrls.add("http://" + address + ':' + config.getWebAdminPort() + "/healthcheck"); return new InstanceInfo.Builder() .withId(instanceId) .withApp(config.getAppName()) .withVipAddress(config.getVipAddress()) .withHealthCheckUrls(healthCheckUrls) .withDataCenterInfo(dataCenterInfo) .withStatus(InstanceInfo.Status.UP); // for now just register with UP } });
/** * Unique name assigned to read or write cluster. */ public String getEurekaClusterName() { return config.getAppName(); }
@PostConstruct public void createResolver() { if (config != null) { // always postConstruct resolve if config exist EurekaCommonConfig.ResolverType resolverType = config.getServerResolverType(); if (resolverType == null) { throw new IllegalArgumentException("Write cluster resolver type not defined"); } EurekaCommonConfig.ServerBootstrap[] bootstraps = EurekaCommonConfig.ServerBootstrap.from(config.getServerList()); switch (resolverType) { case dns: addressStream = fromDns(bootstraps); break; case fixed: addressStream = fromList(bootstraps); } } }
@Override public void start() { final EurekaClient eurekaClient = Eureka.newClientBuilder(discoveryResolver, registrationResolver) .withCodec(config.getCodec()).build(); Module[] modules = { new EurekaReadServerModule(config, eurekaClient) }; setup(modules); }
@Override protected void loadInstanceProperties(Properties props) { super.loadInstanceProperties(props); props.setProperty("eureka.client.discovery-endpoint.port", Integer.toString(config.getDiscoveryPort())); }
/** * Unique name assigned to read or write cluster. */ public String getEurekaClusterName() { return config.getAppName(); }
@PostConstruct public void start() { server = RxNetty.newTcpServerBuilder( config.getDiscoveryPort(), new TcpDiscoveryHandler(eurekaRegistry, metricFactory)) .pipelineConfigurator(EurekaTransports.discoveryPipeline(config.getCodec())) .withMetricEventsListenerFactory(servoEventsListenerFactory) .build() .start(); logger.info("Starting TCP discovery server on port {} with {} encoding...", server.getServerPort(), config.getCodec()); } }
private static Observable<ChangeNotification<Server>> addressStreamFromConfig(EurekaServerConfig config, final ServiceType serviceType) { Observable<ChangeNotification<Server>> addressStream;ResolverType resolverType = config.getServerResolverType(); if (resolverType == null) { throw new IllegalArgumentException("Write cluster resolver type not defined"); } addressStream = EurekaClusterResolvers.writeClusterResolverFromConfiguration( resolverType, Arrays.asList(config.getServerList()), Schedulers.computation() ).clusterTopologyChanges().map(new Func1<ChangeNotification<ClusterAddress>, ChangeNotification<Server>>() { @Override public ChangeNotification<Server> call(ChangeNotification<ClusterAddress> notification) { if (notification.getKind() == Kind.BufferSentinel) { return ChangeNotification.bufferSentinel(); } Server server = new Server( notification.getData().getHostName(), notification.getData().getPortFor(serviceType) ); return new ChangeNotification<Server>(notification.getKind(), server); } }); return addressStream; } }
@Override public EurekaClient get() { ServerResolver discoveryResolver = createWriteServerResolver( new Func1<ServerBootstrap, Integer>() { @Override public Integer call(ServerBootstrap server) { return server.getDiscoveryPort(); } }); ServerResolver registrationResolver = createWriteServerResolver( new Func1<ServerBootstrap, Integer>() { @Override public Integer call(ServerBootstrap server) { return server.getRegistrationPort(); } } ); return Eureka.newClientBuilder(discoveryResolver, registrationResolver) .withCodec(config.getCodec()) .withMetricFactory(metricFactory) .build(); }
@Override public ReadServerReport serverReport() { return new ReadServerReport( config.getDiscoveryPort(), formatAdminURI() ); }
@Override protected void before() throws Throwable { EurekaServerConfig config = EurekaServerConfig.baseBuilder() .withAppName(name) .withVipAddress(name) .withDataCenterType(DataCenterType.Basic) .withDiscoveryPort(0) .withShutDownPort(0) .withWebAdminPort(0) .withCodec(Codec.Avro) .build(); ServerResolver registrationResolver = ServerResolvers.just("localhost", writeServerResource.getRegistrationPort()); ServerResolver discoveryResolver = ServerResolvers.just("localhost", writeServerResource.getDiscoveryPort()); server = new EmbeddedReadServer(config, registrationResolver, discoveryResolver, false, false); server.start(); // Find ephemeral port numbers discoveryPort = server.getInjector().getInstance(TcpDiscoveryServer.class).serverPort(); }
@Override public EurekaServerConfig build() { return new EurekaServerConfig( resolverType, serverList, appName, vipAddress, readClusterVipAddress, dataCenterType, dataCenterResolveIntervalSec, httpPort, shutDownPort, webAdminPort, discoveryPort, heartbeatIntervalMs, connectionAutoTimeoutMs, codec, evictionTimeoutMs, evictionStrategyType, evictionStrategyValue ); } }
@Override public int scaleUpByOne() { int discoveryPort = nextAvailablePort; EurekaServerConfig config = EurekaServerConfig.baseBuilder() .withAppName(READ_SERVER_NAME) .withVipAddress(READ_SERVER_NAME) .withDataCenterType(DataCenterType.Basic) .withDiscoveryPort(discoveryPort) .withShutDownPort(nextAvailablePort + 1) .withWebAdminPort(nextAvailablePort + 2) .withCodec(Codec.Avro) .build(); EmbeddedReadServer newServer = newServer(config); newServer.start(); nextAvailablePort += 10; return scaleUpByOne(newServer, new Server("localhost", discoveryPort)); }
@Override protected void before() throws Throwable { EurekaServerConfig config = EurekaServerConfig.baseBuilder() .withAppName(name) .withVipAddress(name) .withDataCenterType(DataCenterType.Basic) .withHttpPort(0) .withDiscoveryPort(0) .withShutDownPort(0) .withWebAdminPort(0) .withCodec(codec) .build(); ServerResolver registrationResolver = ServerResolvers.fromHostname("localhost").withPort(writeServerResource.getRegistrationPort()); ServerResolver discoveryResolver = ServerResolvers.fromHostname("localhost").withPort(writeServerResource.getDiscoveryPort()); server = new EmbeddedReadServer(EMBEDDED_READ_CLIENT_ID, config, registrationResolver, discoveryResolver, false, false); server.start(); // Find ephemeral port numbers discoveryPort = server.getInjector().getInstance(TcpDiscoveryServer.class).serverPort(); }