1 class AcceptorRunner implements Runnable {
  2     @Override
  3     public void run() {
  4         long scheduleTime = 0;
  5         while (!isShutdown.get()) {
  6             try {
  7                 // 排出輸入隊列的任務：將 reprocessQueue、acceptorQueue 隊列的任務轉移到 pendingTasks
  8                 drainInputQueues();
  9 
 10                 // 待處理的數量
 11                 int totalItems = processingOrder.size();
 12 
 13                 long now = System.currentTimeMillis();
 14                 if (scheduleTime < now) {
 15                     // 時間補償，正常情況下 transmissionDelay() 返回 0
 16                     scheduleTime = now + trafficShaper.transmissionDelay();
 17                 }
 18                 if (scheduleTime <= now) {
 19                     // 分配批量工作任務：將 pendingTasks 的任務分一批到（最多250個） batchWorkQueue 隊列中
 20                     assignBatchWork();
 21                     // 分配單項工作任務：pendingTasks 如果還有剩餘任務，將沒有過期的轉移到 singleItemWorkQueue 隊列中
 22                     assignSingleItemWork();
 23                 }
 24 
 25                 // If no worker is requesting data or there is a delay injected by the traffic shaper,
 26                 // sleep for some time to avoid tight loop.
 27                 if (totalItems == processingOrder.size()) {
 28                     Thread.sleep(10);
 29                 }
 30             } catch (InterruptedException ex) {
 31                 // Ignore
 32             } catch (Throwable e) {
 33                 // Safe-guard, so we never exit this loop in an uncontrolled way.
 34                 logger.warn("Discovery AcceptorThread error", e);
 35             }
 36         }
 37     }
 38 
 39     private boolean isFull() {
 40         // 待處理的任務 >= 10000，也就是說 pendingTasks 最多放 10000 個任務
 41         return pendingTasks.size() >= maxBufferSize;
 42     }
 43 
 44     private void drainInputQueues() throws InterruptedException {
 45         do {
 46             // 排出 reprocessQueue，將 reprocessQueue 隊列的任務轉移到 pendingTasks
 47             drainReprocessQueue();
 48             // 排出 acceptorQueue，將 acceptorQueue 隊列的任務轉移到 pendingTasks
 49             drainAcceptorQueue();
 50 
 51             if (isShutdown.get()) {
 52                 break;
 53             }
 54             // If all queues are empty, block for a while on the acceptor queue
 55             if (reprocessQueue.isEmpty() && acceptorQueue.isEmpty() && pendingTasks.isEmpty()) {
 56                 // 等待任務放入 acceptorQueue，等待 10 毫秒
 57                 TaskHolder<ID, T> taskHolder = acceptorQueue.poll(10, TimeUnit.MILLISECONDS);
 58                 if (taskHolder != null) {
 59                     // 放入之後 acceptorQueue、pendingTasks 就不為空了
 60                     appendTaskHolder(taskHolder);
 61                 }
 62             }
 63             // pendingTasks 為空、acceptorQueue 不為空、reprocessQueue不為空時，就會一直循環
 64             // 如果所有任務都處理完了，reprocessQueue、acceptorQueue、pendingTasks 都是空的，
 65             // 這時就會循環等待任務進入 acceptorQueue，每次等待 10 毫秒
 66         } while (!reprocessQueue.isEmpty() || !acceptorQueue.isEmpty() || pendingTasks.isEmpty());
 67     }
 68 
 69     private void drainAcceptorQueue() {
 70         while (!acceptorQueue.isEmpty()) {
 71             // 將 acceptorQueue 的任務轉移到 pendingTasks
 72             appendTaskHolder(acceptorQueue.poll());
 73         }
 74     }
 75 
 76     private void drainReprocessQueue() {
 77         long now = System.currentTimeMillis();
 78         while (!reprocessQueue.isEmpty() && !isFull()) {
 79             // 從 reprocessQueue 隊尾取出任務
 80             TaskHolder<ID, T> taskHolder = reprocessQueue.pollLast();
 81             ID id = taskHolder.getId();
 82             if (taskHolder.getExpiryTime() <= now) {
 83                 // 任務過期
 84                 expiredTasks++;
 85             } else if (pendingTasks.containsKey(id)) {
 86                 // pendingTasks 已存在
 87                 overriddenTasks++;
 88             } else {
 89                 // 將 reprocessQueue 隊列的任務放到 pendingTasks
 90                 pendingTasks.put(id, taskHolder);
 91                 // 添加到 processingOrder 隊列的頭部，reprocessQueue 是失敗重試的隊列，所以優先順序高一些
 92                 processingOrder.addFirst(id);
 93             }
 94         }
 95         if (isFull()) {
 96             queueOverflows += reprocessQueue.size();
 97             // pendingTasks 滿了，就清空 reprocessQueue
 98             reprocessQueue.clear();
 99         }
100     }
101 
102     private void appendTaskHolder(TaskHolder<ID, T> taskHolder) {
103         if (isFull()) {
104             // pendingTasks 滿了就移除一個元素
105             pendingTasks.remove(processingOrder.poll());
106             queueOverflows++;
107         }
108         // 將 acceptorQueue 里的任務放到 pendingTasks
109         TaskHolder<ID, T> previousTask = pendingTasks.put(taskHolder.getId(), taskHolder);
110         if (previousTask == null) {
111             // 原本不存在，將任務ID添加到 processingOrder 隊列的最後
112             processingOrder.add(taskHolder.getId());
113         } else {
114             // 已經存在了，就是覆蓋
115             overriddenTasks++;
116         }
117     }
118 
119     void assignSingleItemWork() {
120         if (!processingOrder.isEmpty()) {
121             if (singleItemWorkRequests.tryAcquire(1)) {
122                 long now = System.currentTimeMillis();
123                 while (!processingOrder.isEmpty()) {
124                     ID id = processingOrder.poll();
125                     TaskHolder<ID, T> holder = pendingTasks.remove(id);
126                     if (holder.getExpiryTime() > now) {
127                         // 將 pendingTasks 的任務移到 singleItemWorkQueue
128                         singleItemWorkQueue.add(holder);
129                         return;
130                     }
131                     expiredTasks++;
132                 }
133                 singleItemWorkRequests.release();
134             }
135         }
136     }
137 
138     void assignBatchWork() {
139         // 有足夠的任務做一個批處理
140         if (hasEnoughTasksForNextBatch()) {
141             if (batchWorkRequests.tryAcquire(1)) {
142                 long now = System.currentTimeMillis();
143                 // 一批任務最多 250 個
144                 int len = Math.min(maxBatchingSize, processingOrder.size());
145                 List<TaskHolder<ID, T>> holders = new ArrayList<>(len);
146                 // 將 pendingTasks 中的任務移動一批到 holders 中
147                 // 也就是說，如果隊列中有500個任務，這一批任務最多也是250個
148                 while (holders.size() < len && !processingOrder.isEmpty()) {
149                     ID id = processingOrder.poll();
150                     TaskHolder<ID, T> holder = pendingTasks.remove(id);
151                     if (holder.getExpiryTime() > now) {
152                         holders.add(holder);
153                     } else {
154                         expiredTasks++;
155                     }
156                 }
157                 if (holders.isEmpty()) {
158                     batchWorkRequests.release();
159                 } else {
160                     batchSizeMetric.record(holders.size(), TimeUnit.MILLISECONDS);
161                     // 添加到批量隊列中
162                     batchWorkQueue.add(holders);
163                 }
164             }
165         }
166     }
167 
168     // 是否有足夠的任務做一個批處理
169     private boolean hasEnoughTasksForNextBatch() {
170         if (processingOrder.isEmpty()) {
171             return false;
172         }
173         if (pendingTasks.size() >= maxBufferSize) {
174             return true;
175         }
176 
177         // 從 processingOrder 隊首取一個任務ID，然後從 pendingTasks 讀取這個任務。注意 peek() 只是取出元素，並不會移除隊首的元素
178         TaskHolder<ID, T> nextHolder = pendingTasks.get(processingOrder.peek());
179         // 判斷任務提交到現在的時間差是否超過最大批任務延遲時間（500毫秒）
180         long delay = System.currentTimeMillis() - nextHolder.getSubmitTimestamp();
181         return delay >= maxBatchingDelay;
182     }
183 }

  1 @Path("/{version}/peerreplication")
  2 @Produces({"application/xml", "application/json"})
  3 public class PeerReplicationResource {
  4 
  5     private static final Logger logger = LoggerFactory.getLogger(PeerReplicationResource.class);
  6 
  7     private static final String REPLICATION = "true";
  8 
  9     private final EurekaServerConfig serverConfig;
 10     private final PeerAwareInstanceRegistry registry;
 11 
 12     @Inject
 13     PeerReplicationResource(EurekaServerContext server) {
 14         this.serverConfig = server.getServerConfig();
 15         this.registry = server.getRegistry();
 16     }
 17 
 18     public PeerReplicationResource() {
 19         this(EurekaServerContextHolder.getInstance().getServerContext());
 20     }
 21 
 22     @Path("batch")
 23     @POST
 24     public Response batchReplication(ReplicationList replicationList) {
 25         try {
 26             ReplicationListResponse batchResponse = new ReplicationListResponse();
 27             for (ReplicationInstance instanceInfo : replicationList.getReplicationList()) {
 28                 try {
 29                     // dispatch 分發任務
 30                     batchResponse.addResponse(dispatch(instanceInfo));
 31                 } catch (Exception e) {
 32                     batchResponse.addResponse(new ReplicationInstanceResponse(Status.INTERNAL_SERVER_ERROR.getStatusCode(), null));
 33                     logger.error("{} request processing failed for batch item {}/{}",
 34                             instanceInfo.getAction(), instanceInfo.getAppName(), instanceInfo.getId(), e);
 35                 }
 36             }
 37             return Response.ok(batchResponse).build();
 38         } catch (Throwable e) {
 39             logger.error("Cannot execute batch Request", e);
 40             return Response.status(Status.INTERNAL_SERVER_ERROR).build();
 41         }
 42     }
 43 
 44     private ReplicationInstanceResponse dispatch(ReplicationInstance instanceInfo) {
 45         ApplicationResource applicationResource = createApplicationResource(instanceInfo);
 46         InstanceResource resource = createInstanceResource(instanceInfo, applicationResource);
 47 
 48         String lastDirtyTimestamp = toString(instanceInfo.getLastDirtyTimestamp());
 49         String overriddenStatus = toString(instanceInfo.getOverriddenStatus());
 50         String instanceStatus = toString(instanceInfo.getStatus());
 51 
 52         Builder singleResponseBuilder = new Builder();
 53         // 根據不同的類型分別處理
 54         switch (instanceInfo.getAction()) {
 55             case Register:
 56                 singleResponseBuilder = handleRegister(instanceInfo, applicationResource);
 57                 break;
 58             case Heartbeat:
 59                 singleResponseBuilder = handleHeartbeat(serverConfig, resource, lastDirtyTimestamp, overriddenStatus, instanceStatus);
 60                 break;
 61             case Cancel:
 62                 singleResponseBuilder = handleCancel(resource);
 63                 break;
 64             case StatusUpdate:
 65                 singleResponseBuilder = handleStatusUpdate(instanceInfo, resource);
 66                 break;
 67             case DeleteStatusOverride:
 68                 singleResponseBuilder = handleDeleteStatusOverride(instanceInfo, resource);
 69                 break;
 70         }
 71         return singleResponseBuilder.build();
 72     }
 73 
 74     /* Visible for testing */ ApplicationResource createApplicationResource(ReplicationInstance instanceInfo) {
 75         return new ApplicationResource(instanceInfo.getAppName(), serverConfig, registry);
 76     }
 77 
 78     /* Visible for testing */ InstanceResource createInstanceResource(ReplicationInstance instanceInfo,
 79                                                                       ApplicationResource applicationResource) {
 80         return new InstanceResource(applicationResource, instanceInfo.getId(), serverConfig, registry);
 81     }
 82 
 83     private static Builder handleRegister(ReplicationInstance instanceInfo, ApplicationResource applicationResource) {
 84         // addInstance
 85         applicationResource.addInstance(instanceInfo.getInstanceInfo(), REPLICATION);
 86         return new Builder().setStatusCode(Status.OK.getStatusCode());
 87     }
 88 
 89     private static Builder handleCancel(InstanceResource resource) {
 90         // cancelLease
 91         Response response = resource.cancelLease(REPLICATION);
 92         return new Builder().setStatusCode(response.getStatus());
 93     }
 94 
 95     private static Builder handleHeartbeat(EurekaServerConfig config, InstanceResource resource, String lastDirtyTimestamp, String overriddenStatus, String instanceStatus) {
 96         Response response = resource.renewLease(REPLICATION, overriddenStatus, instanceStatus, lastDirtyTimestamp);
 97         int responseStatus = response.getStatus();
 98         Builder responseBuilder = new Builder().setStatusCode(responseStatus);
 99 
100         if ("false".equals(config.getExperimental("bugfix.934"))) {
101             if (responseStatus == Status.OK.getStatusCode() && response.getEntity() != null) {
102                 responseBuilder.setResponseEntity((InstanceInfo) response.getEntity());
103             }
104         } else {
105             if ((responseStatus == Status.OK.getStatusCode() || responseStatus == Status.CONFLICT.getStatusCode())
106                     && response.getEntity() != null) {
107                 responseBuilder.setResponseEntity((InstanceInfo) response.getEntity());
108             }
109         }
110         return responseBuilder;
111     }
112 
113     private static Builder handleStatusUpdate(ReplicationInstance instanceInfo, InstanceResource resource) {
114         Response response = resource.statusUpdate(instanceInfo.getStatus(), REPLICATION, toString(instanceInfo.getLastDirtyTimestamp()));
115         return new Builder().setStatusCode(response.getStatus());
116     }
117 
118     private static Builder handleDeleteStatusOverride(ReplicationInstance instanceInfo, InstanceResource resource) {
119         Response response = resource.deleteStatusUpdate(REPLICATION, instanceInfo.getStatus(),
120                 instanceInfo.getLastDirtyTimestamp().toString());
121         return new Builder().setStatusCode(response.getStatus());
122     }
123 
124     private static <T> String toString(T value) {
125         if (value == null) {
126             return null;
127         }
128         return value.toString();
129     }
130 }

  1 @Configuration(proxyBeanMethods = false)
  2 @Import(EurekaServerInitializerConfiguration.class)
  3 @ConditionalOnBean(EurekaServerMarkerConfiguration.Marker.class)
  4 @EnableConfigurationProperties({ EurekaDashboardProperties.class,
  5         InstanceRegistryProperties.class })
  6 @PropertySource("classpath:/eureka/server.properties")
  7 public class EurekaServerAutoConfiguration implements WebMvcConfigurer {
  8 
  9     /**
 10      * List of packages containing Jersey resources required by the Eureka server.
 11      */
 12     private static final String[] EUREKA_PACKAGES = new String[] {
 13             "com.netflix.discovery", "com.netflix.eureka" };
 14 
 15     @Autowired
 16     private ApplicationInfoManager applicationInfoManager;
 17 
 18     @Autowired
 19     private EurekaServerConfig eurekaServerConfig;
 20 
 21     @Autowired
 22     private EurekaClientConfig eurekaClientConfig;
 23 
 24     @Autowired
 25     private EurekaClient eurekaClient;
 26 
 27     @Autowired
 28     private InstanceRegistryProperties instanceRegistryProperties;
 29 
 30     /**
 31      * A {@link CloudJacksonJson} instance.
 32      */
 33     public static final CloudJacksonJson JACKSON_JSON = new CloudJacksonJson();
 34 
 35     @Bean
 36     public HasFeatures eurekaServerFeature() {
 37         return HasFeatures.namedFeature("Eureka Server",
 38                 EurekaServerAutoConfiguration.class);
 39     }
 40 
 41     @Bean
 42     @ConditionalOnProperty(prefix = "eureka.dashboard", name = "enabled",
 43             matchIfMissing = true)
 44     public EurekaController eurekaController() {
 45         return new EurekaController(this.applicationInfoManager);
 46     }
 47 
 48     static {
 49         CodecWrappers.registerWrapper(JACKSON_JSON);
 50         EurekaJacksonCodec.setInstance(JACKSON_JSON.getCodec());
 51     }
 52 
 53     @Bean
 54     public ServerCodecs serverCodecs() {
 55         return new CloudServerCodecs(this.eurekaServerConfig);
 56     }
 57 
 58     private static CodecWrapper getFullJson(EurekaServerConfig serverConfig) {
 59         CodecWrapper codec = CodecWrappers.getCodec(serverConfig.getJsonCodecName());
 60         return codec == null ? CodecWrappers.getCodec(JACKSON_JSON.codecName()) : codec;
 61     }
 62 
 63     private static CodecWrapper getFullXml(EurekaServerConfig serverConfig) {
 64         CodecWrapper codec = CodecWrappers.getCodec(serverConfig.getXmlCodecName());
 65         return codec == null ? CodecWrappers.getCodec(CodecWrappers.XStreamXml.class)
 66                 : codec;
 67     }
 68 
 69     @Bean
 70     @ConditionalOnMissingBean
 71     public ReplicationClientAdditionalFilters replicationClientAdditionalFilters() {
 72         return new ReplicationClientAdditionalFilters(Collections.emptySet());
 73     }
 74 
 75     @Bean
 76     public PeerAwareInstanceRegistry peerAwareInstanceRegistry(
 77             ServerCodecs serverCodecs) {
 78         this.eurekaClient.getApplications(); // force initialization
 79         return new InstanceRegistry(this.eurekaServerConfig, this.eurekaClientConfig,
 80                 serverCodecs, this.eurekaClient,
 81                 this.instanceRegistryProperties.getExpectedNumberOfClientsSendingRenews(),
 82                 this.instanceRegistryProperties.getDefaultOpenForTrafficCount());
 83     }
 84 
 85     @Bean
 86     @ConditionalOnMissingBean
 87     public PeerEurekaNodes peerEurekaNodes(PeerAwareInstanceRegistry registry,
 88             ServerCodecs serverCodecs,
 89             ReplicationClientAdditionalFilters replicationClientAdditionalFilters) {
 90         return new RefreshablePeerEurekaNodes(registry, this.eurekaServerConfig,
 91                 this.eurekaClientConfig, serverCodecs, this.applicationInfoManager,
 92                 replicationClientAdditionalFilters);
 93     }
 94 
 95     @Bean
 96     @ConditionalOnMissingBean
 97     public EurekaServerContext eurekaServerContext(ServerCodecs serverCodecs,
 98             PeerAwareInstanceRegistry registry, PeerEurekaNodes peerEurekaNodes) {
 99         return new DefaultEurekaServerContext(this.eurekaServerConfig, serverCodecs,
100                 registry, peerEurekaNodes, this.applicationInfoManager);
101     }
102 
103     @Bean
104     public EurekaServerBootstrap eurekaServerBootstrap(PeerAwareInstanceRegistry registry,
105             EurekaServerContext serverContext) {
106         return new EurekaServerBootstrap(this.applicationInfoManager,
107                 this.eurekaClientConfig, this.eurekaServerConfig, registry,
108                 serverContext);
109     }
110 
111     /**
112      * Register the Jersey filter.
113      * @param eurekaJerseyApp an {@link Application} for the filter to be registered
114      * @return a jersey {@link FilterRegistrationBean}
115      */
116     @Bean
117     public FilterRegistrationBean<?> jerseyFilterRegistration(
118             javax.ws.rs.core.Application eurekaJerseyApp) {
119         FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<Filter>();
120         bean.setFilter(new ServletContainer(eurekaJerseyApp));
121         bean.setOrder(Ordered.LOWEST_PRECEDENCE);
122         bean.setUrlPatterns(
123                 Collections.singletonList(EurekaConstants.DEFAULT_PREFIX + "/*"));
124 
125         return bean;
126     }
127 
128     /**
129      * Construct a Jersey {@link javax.ws.rs.core.Application} with all the resources
130      * required by the Eureka server.
131      * @param environment an {@link Environment} instance to retrieve classpath resources
132      * @param resourceLoader a {@link ResourceLoader} instance to get classloader from
133      * @return created {@link Application} object
134      */
135     @Bean
136     public javax.ws.rs.core.Application jerseyApplication(Environment environment,
137             ResourceLoader resourceLoader) {
138 
139         ClassPathScanningCandidateComponentProvider provider = new ClassPathScanningCandidateComponentProvider(
140                 false, environment);
141 
142         // Filter to include only classes that have a particular annotation.
143         //
144         provider.addIncludeFilter(new AnnotationTypeFilter(Path.class));
145         provider.addIncludeFilter(new AnnotationTypeFilter(Provider.class));
146 
147         // Find classes in Eureka packages (or subpackages)
148         //
149         Set<Class<?>> classes = new HashSet<>();
150         for (String basePackage : EUREKA_PACKAGES) {
151             Set<BeanDefinition> beans = provider.findCandidateComponents(basePackage);
152             for (BeanDefinition bd : beans) {
153                 Class<?> cls = ClassUtils.resolveClassName(bd.getBeanClassName(),
154                         resourceLoader.getClassLoader());
155                 classes.add(cls);
156             }
157         }
158 
159         // Construct the Jersey ResourceConfig
160         Map<String, Object> propsAndFeatures = new HashMap<>();
161         propsAndFeatures.put(
162                 // Skip static content used by the webapp
163                 ServletContainer.PROPERTY_WEB_PAGE_CONTENT_REGEX,
164                 EurekaConstants.DEFAULT_PREFIX + "/(fonts|images|css|js)/.*");
165 
166         DefaultResourceConfig rc = new DefaultResourceConfig(classes);
167         rc.setPropertiesAndFeatures(propsAndFeatures);
168 
169         return rc;
170     }
171 
172     @Bean
173     @ConditionalOnBean(name = "httpTraceFilter")
174     public FilterRegistrationBean<?> traceFilterRegistration(
175             @Qualifier("httpTraceFilter") Filter filter) {
176         FilterRegistrationBean<Filter> bean = new FilterRegistrationBean<Filter>();
177         bean.setFilter(filter);
178         bean.setOrder(Ordered.LOWEST_PRECEDENCE - 10);
179         return bean;
180     }
181 
182     @Configuration(proxyBeanMethods = false)
183     protected static class EurekaServerConfigBeanConfiguration {
184 
185         @Bean
186         @ConditionalOnMissingBean
187         public EurekaServerConfig eurekaServerConfig(EurekaClientConfig clientConfig) {
188             EurekaServerConfigBean server = new EurekaServerConfigBean();
189             if (clientConfig.shouldRegisterWithEureka()) {
190                 // Set a sensible default if we are supposed to replicate
191                 server.setRegistrySyncRetries(5);
192             }
193             return server;
194         }
195 
196     }
197 
198     /**
199      * {@link PeerEurekaNodes} which updates peers when /refresh is invoked. Peers are
200      * updated only if <code>eureka.client.use-dns-for-fetching-service-urls</code> is
201      * <code>false</code> and one of following properties have changed.
202      * <p>
203      * </p>
204      * <ul>
205      * <li><code>eureka.client.availability-zones</code></li>
206      * <li><code>eureka.client.region</code></li>
207      * <li><code>eureka.client.service-url.&lt;zone&gt;</code></li>
208      * </ul>
209      */
210     static class RefreshablePeerEurekaNodes extends PeerEurekaNodes
211             implements ApplicationListener<EnvironmentChangeEvent> {
212 
213         private ReplicationClientAdditionalFilters replicationClientAdditionalFilters;
214 
215         RefreshablePeerEurekaNodes(final PeerAwareInstanceRegistry registry,
216                 final EurekaServerConfig serverConfig,
217                 final EurekaClientConfig clientConfig, final ServerCodecs serverCodecs,
218                 final ApplicationInfoManager applicationInfoManager,
219                 final ReplicationClientAdditionalFilters replicationClientAdditionalFilters) {
220             super(registry, serverConfig, clientConfig, serverCodecs,
221                     applicationInfoManager);
222             this.replicationClientAdditionalFilters = replicationClientAdditionalFilters;
223         }
224 
225         @Override
226         protected PeerEurekaNode createPeerEurekaNode(String peerEurekaNodeUrl) {
227             JerseyReplicationClient replicationClient = JerseyReplicationClient
228                     .createReplicationClient(serverConfig, serverCodecs,
229                             peerEurekaNodeUrl);
230 
231             this.replicationClientAdditionalFilters.getFilters()
232                     .forEach(replicationClient::addReplicationClientFilter);
233 
234             String targetHost = hostFromUrl(peerEurekaNodeUrl);
235             if (targetHost == null) {
236                 targetHost = "host";
237             }
238             return new PeerEurekaNode(registry, targetHost, peerEurekaNodeUrl,
239                     replicationClient, serverConfig);
240         }
241 
242         @Override
243         public void onApplicationEvent(final EnvironmentChangeEvent event) {
244             if (shouldUpdate(event.getKeys())) {
245                 updatePeerEurekaNodes(resolvePeerUrls());
246             }
247         }
248 
249         /*
250          * Check whether specific properties have changed.
251          */
252         protected boolean shouldUpdate(final Set<String> changedKeys) {
253             assert changedKeys != null;
254 
255             // if eureka.client.use-dns-for-fetching-service-urls is true, then
256             // service-url will not be fetched from environment.
257             if (this.clientConfig.shouldUseDnsForFetchingServiceUrls()) {
258                 return false;
259             }
260 
261             if (changedKeys.contains("eureka.client.region")) {
262                 return true;
263             }
264 
265             for (final String key : changedKeys) {
266                 // property keys are not expected to be null.
267                 if (key.startsWith("eureka.client.service-url.")
268                         || key.startsWith("eureka.client.availability-zones.")) {
269                     return true;
270                 }
271             }
272             return false;
273         }
274 
275     }
276 
277     class CloudServerCodecs extends DefaultServerCodecs {
278 
279         CloudServerCodecs(EurekaServerConfig serverConfig) {
280             super(getFullJson(serverConfig),
281                     CodecWrappers.getCodec(CodecWrappers.JacksonJsonMini.class),
282                     getFullXml(serverConfig),
283                     CodecWrappers.getCodec(CodecWrappers.JacksonXmlMini.class));
284         }
285 
286     }
287 
288 }

   1 @ConfigurationProperties(EurekaServerConfigBean.PREFIX)
   2 public class EurekaServerConfigBean implements EurekaServerConfig {
   3 
   4     /**
   5      * Eureka server configuration properties prefix.
   6      */
   7     public static final String PREFIX = "eureka.server";
   8 
   9     private static final int MINUTES = 60 * 1000;
  10 
  11     @Autowired(required = false)
  12     PropertyResolver propertyResolver;
  13 
  14     private String aWSAccessId;
  15 
  16     private String aWSSecretKey;
  17 
  18     private int eIPBindRebindRetries = 3;
  19 
  20     private int eIPBindingRetryIntervalMs = 5 * MINUTES;
  21 
  22     private int eIPBindingRetryIntervalMsWhenUnbound = 1 * MINUTES;
  23 
  24     private boolean enableSelfPreservation = true;
  25 
  26     private double renewalPercentThreshold = 0.85;
  27 
  28     private int renewalThresholdUpdateIntervalMs = 15 * MINUTES;
  29 
  30     private int peerEurekaNodesUpdateIntervalMs = 10 * MINUTES;
  31 
  32     private int numberOfReplicationRetries = 5;
  33 
  34     private int peerEurekaStatusRefreshTimeIntervalMs = 30 * 1000;
  35 
  36     private int waitTimeInMsWhenSyncEmpty = 5 * MINUTES;
  37 
  38     private int peerNodeConnectTimeoutMs = 200;
  39 
  40     private int peerNodeReadTimeoutMs = 200;
  41 
  42     private int peerNodeTotalConnections = 1000;
  43 
  44     private int peerNodeTotalConnectionsPerHost = 500;
  45 
  46     private int peerNodeConnectionIdleTimeoutSeconds = 30;
  47 
  48     private long retentionTimeInMSInDeltaQueue = 3 * MINUTES;
  49 
  50     private long deltaRetentionTimerIntervalInMs = 30 * 1000;
  51 
  52     private long evictionIntervalTimerInMs = 60 * 1000;
  53 
  54     private int aSGQueryTimeoutMs = 300;
  55 
  56     private long aSGUpdateIntervalMs = 5 * MINUTES;
  57 
  58     private long aSGCacheExpiryTimeoutMs = 10 * MINUTES; // defaults to longer than the
  59 
  60     // asg update interval
  61 
  62     private long responseCacheAutoExpirationInSeconds = 180;
  63 
  64     private long responseCacheUpdateIntervalMs = 30 * 1000;
  65 
  66     private boolean useReadOnlyResponseCache = true;
  67 
  68     private boolean disableDelta;
  69 
  70     private long maxIdleThreadInMinutesAgeForStatusReplication = 10;
  71 
  72     private int minThreadsForStatusReplication = 1;
  73 
  74     private int maxThreadsForStatusReplication = 1;
  75 
  76     private int maxElementsInStatusReplicationPool = 10000;
  77 
  78     private boolean syncWhenTimestampDiffers = true;
  79 
  80     private int registrySyncRetries = 0;
  81 
  82     private long registrySyncRetryWaitMs = 30 * 1000;
  83 
  84     private int maxElementsInPeerReplicationPool = 10000;
  85 
  86     private long maxIdleThreadAgeInMinutesForPeerReplication = 15;
  87 
  88     private int minThreadsForPeerReplication = 5;
  89 
  90     private int maxThreadsForPeerReplication = 20;
  91 
  92     private int maxTimeForReplication = 30000;
  93 
  94     private boolean primeAwsReplicaConnections = true;
  95 
  96     private boolean disableDeltaForRemoteRegions;
  97 
  98     private int remoteRegionConnectTimeoutMs = 1000;
  99 
 100     private int remoteRegionReadTimeoutMs = 1000;
 101 
 102     private int remoteRegionTotalConnections = 1000;
 103 
 104     private int remoteRegionTotalConnectionsPerHost = 500;
 105 
 106     private int remoteRegionConnectionIdleTimeoutSeconds = 30;
 107 
 108     private boolean gZipContentFromRemoteRegion = true;
 109 
 110     private Map<String, String> remoteRegionUrlsWithName = new HashMap<>();
 111 
 112     private String[] remoteRegionUrls;
 113 
 114     private Map<String, Set<String>> remoteRegionAppWhitelist = new HashMap<>();
 115 
 116     private int remoteRegionRegistryFetchInterval = 30;
 117 
 118     private int remoteRegionFetchThreadPoolSize = 20;
 119 
 120     private String remoteRegionTrustStore = "";
 121 
 122     private String remoteRegionTrustStorePassword = "changeit";
 123 
 124     private boolean disableTransparentFallbackToOtherRegion;
 125 
 126     private boolean batchReplication;
 127 
 128     private boolean rateLimiterEnabled = false;
 129 
 130     private boolean rateLimiterThrottleStandardClients = false;
 131 
 132     private Set<String> rateLimiterPrivilegedClients = Collections.emptySet();
 133 
 134     private int rateLimiterBurstSize = 10;
 135 
 136     private int rateLimiterRegistryFetchAverageRate = 500;
 137 
 138     private int rateLimiterFullFetchAverageRate = 100;
 139 
 140     private boolean logIdentityHeaders = true;
 141 
 142     private String listAutoScalingGroupsRoleName = "ListAutoScalingGroups";
 143 
 144     private boolean enableReplicatedRequestCompression = false;
 145 
 146     private String jsonCodecName;
 147 
 148     private String xmlCodecName;
 149 
 150     private int route53BindRebindRetries = 3;
 151 
 152     private int route53BindingRetryIntervalMs = 5 * MINUTES;
 153 
 154     private long route53DomainTTL = 30;
 155 
 156     private AwsBindingStrategy bindingStrategy = AwsBindingStrategy.EIP;
 157 
 158     private int minAvailableInstancesForPeerReplication = -1;
 159 
 160     private int initialCapacityOfResponseCache = 1000;
 161 
 162     private int expectedClientRenewalIntervalSeconds = 30;
 163 
 164     private boolean useAwsAsgApi = true;
 165 
 166     private String myUrl;
 167 
 168     @Override
 169     public boolean shouldEnableSelfPreservation() {
 170         return this.enableSelfPreservation;
 171     }
 172 
 173     @Override
 174     public boolean shouldDisableDelta() {
 175         return this.disableDelta;
 176     }
 177 
 178     @Override
 179     public boolean shouldSyncWhenTimestampDiffers() {
 180         return this.syncWhenTimestampDiffers;
 181     }
 182 
 183     @Override
 184     public boolean shouldPrimeAwsReplicaConnections() {
 185         return this.primeAwsReplicaConnections;
 186     }
 187 
 188     @Override
 189     public boolean shouldDisableDeltaForRemoteRegions() {
 190         return this.disableDeltaForRemoteRegions;
 191     }
 192 
 193     @Override
 194     public boolean shouldGZipContentFromRemoteRegion() {
 195         return this.gZipContentFromRemoteRegion;
 196     }
 197 
 198     @Override
 199     public Set<String> getRemoteRegionAppWhitelist(String regionName) {
 200         return this.remoteRegionAppWhitelist
 201                 .get(regionName == null ? "global" : regionName.trim().toLowerCase());
 202     }
 203 
 204     @Override
 205     public boolean disableTransparentFallbackToOtherRegion() {
 206         return this.disableTransparentFallbackToOtherRegion;
 207     }
 208 
 209     @Override
 210     public boolean shouldBatchReplication() {
 211         return this.batchReplication;
 212     }
 213 
 214     @Override
 215     public String getMyUrl() {
 216         return this.myUrl;
 217     }
 218 
 219     public void setMyUrl(String myUrl) {
 220         this.myUrl = myUrl;
 221     }
 222 
 223     @Override
 224     public boolean shouldLogIdentityHeaders() {
 225         return this.logIdentityHeaders;
 226     }
 227 
 228     @Override
 229     public String getJsonCodecName() {
 230         return this.jsonCodecName;
 231     }
 232 
 233     @Override
 234     public String getXmlCodecName() {
 235         return this.xmlCodecName;
 236     }
 237 
 238     @Override
 239     public boolean shouldUseReadOnlyResponseCache() {
 240         return this.useReadOnlyResponseCache;
 241     }
 242 
 243     @Override
 244     public boolean shouldEnableReplicatedRequestCompression() {
 245         return this.enableReplicatedRequestCompression;
 246     }
 247 
 248     @Override
 249     public String getExperimental(String name) {
 250         if (this.propertyResolver != null) {
 251             return this.propertyResolver.getProperty(PREFIX + ".experimental." + name,
 252                     String.class, null);
 253         }
 254         return null;
 255     }
 256 
 257     @Override
 258     public int getInitialCapacityOfResponseCache() {
 259         return this.initialCapacityOfResponseCache;
 260     }
 261 
 262     public void setInitialCapacityOfResponseCache(int initialCapacityOfResponseCache) {
 263         this.initialCapacityOfResponseCache = initialCapacityOfResponseCache;
 264     }
 265 
 266     @Override
 267     public int getHealthStatusMinNumberOfAvailablePeers() {
 268         return this.minAvailableInstancesForPeerReplication;
 269     }
 270 
 271     public PropertyResolver getPropertyResolver() {
 272         return propertyResolver;
 273     }
 274 
 275     public void setPropertyResolver(PropertyResolver propertyResolver) {
 276         this.propertyResolver = propertyResolver;
 277     }
 278 
 279     public String getAWSAccessId() {
 280         return aWSAccessId;
 281     }
 282 
 283     public void setAWSAccessId(String aWSAccessId) {
 284         this.aWSAccessId = aWSAccessId;
 285     }
 286 
 287     public String getAWSSecretKey() {
 288         return aWSSecretKey;
 289     }
 290 
 291     public void setAWSSecretKey(String aWSSecretKey) {
 292         this.aWSSecretKey = aWSSecretKey;
 293     }
 294 
 295     public int getEIPBindRebindRetries() {
 296         return eIPBindRebindRetries;
 297     }
 298 
 299     public void setEIPBindRebindRetries(int eIPBindRebindRetries) {
 300         this.eIPBindRebindRetries = eIPBindRebindRetries;
 301     }
 302 
 303     public int getEIPBindingRetryIntervalMs() {
 304         return eIPBindingRetryIntervalMs;
 305     }
 306 
 307     public void setEIPBindingRetryIntervalMs(int eIPBindingRetryIntervalMs) {
 308         this.eIPBindingRetryIntervalMs = eIPBindingRetryIntervalMs;
 309     }
 310 
 311     public int getEIPBindingRetryIntervalMsWhenUnbound() {
 312         return eIPBindingRetryIntervalMsWhenUnbound;
 313     }
 314 
 315     public void setEIPBindingRetryIntervalMsWhenUnbound(
 316             int eIPBindingRetryIntervalMsWhenUnbound) {
 317         this.eIPBindingRetryIntervalMsWhenUnbound = eIPBindingRetryIntervalMsWhenUnbound;
 318     }
 319 
 320     public boolean isEnableSelfPreservation() {
 321         return enableSelfPreservation;
 322     }
 323 
 324     public void setEnableSelfPreservation(boolean enableSelfPreservation) {
 325         this.enableSelfPreservation = enableSelfPreservation;
 326     }
 327 
 328     @Override
 329     public double getRenewalPercentThreshold() {
 330         return renewalPercentThreshold;
 331     }
 332 
 333     public void setRenewalPercentThreshold(double renewalPercentThreshold) {
 334         this.renewalPercentThreshold = renewalPercentThreshold;
 335     }
 336 
 337     @Override
 338     public int getRenewalThresholdUpdateIntervalMs() {
 339         return renewalThresholdUpdateIntervalMs;
 340     }
 341 
 342     @Override
 343     public int getExpectedClientRenewalIntervalSeconds() {
 344         return this.expectedClientRenewalIntervalSeconds;
 345     }
 346 
 347     public void setExpectedClientRenewalIntervalSeconds(
 348             int expectedClientRenewalIntervalSeconds) {
 349         this.expectedClientRenewalIntervalSeconds = expectedClientRenewalIntervalSeconds;
 350     }
 351 
 352     public void setRenewalThresholdUpdateIntervalMs(
 353             int renewalThresholdUpdateIntervalMs) {
 354         this.renewalThresholdUpdateIntervalMs = renewalThresholdUpdateIntervalMs;
 355     }
 356 
 357     @Override
 358     public int getPeerEurekaNodesUpdateIntervalMs() {
 359         return peerEurekaNodesUpdateIntervalMs;
 360     }
 361 
 362     public void setPeerEurekaNodesUpdateIntervalMs(int peerEurekaNodesUpdateIntervalMs) {
 363         this.peerEurekaNodesUpdateIntervalMs = peerEurekaNodesUpdateIntervalMs;
 364     }
 365 
 366     @Override
 367     public int getNumberOfReplicationRetries() {
 368         return numberOfReplicationRetries;
 369     }
 370 
 371     public void setNumberOfReplicationRetries(int numberOfReplicationRetries) {
 372         this.numberOfReplicationRetries = numberOfReplicationRetries;
 373     }
 374 
 375     @Override
 376     public int getPeerEurekaStatusRefreshTimeIntervalMs() {
 377         return peerEurekaStatusRefreshTimeIntervalMs;
 378     }
 379 
 380     public void setPeerEurekaStatusRefreshTimeIntervalMs(
 381             int peerEurekaStatusRefreshTimeIntervalMs) {
 382         this.peerEurekaStatusRefreshTimeIntervalMs = peerEurekaStatusRefreshTimeIntervalMs;
 383     }
 384 
 385     @Override
 386     public int getWaitTimeInMsWhenSyncEmpty() {
 387         return waitTimeInMsWhenSyncEmpty;
 388     }
 389 
 390     public void setWaitTimeInMsWhenSyncEmpty(int waitTimeInMsWhenSyncEmpty) {
 391         this.waitTimeInMsWhenSyncEmpty = waitTimeInMsWhenSyncEmpty;
 392     }
 393 
 394     @Override
 395     public int getPeerNodeConnectTimeoutMs() {
 396         return peerNodeConnectTimeoutMs;
 397     }
 398 
 399     public void setPeerNodeConnectTimeoutMs(int peerNodeConnectTimeoutMs) {
 400         this.peerNodeConnectTimeoutMs = peerNodeConnectTimeoutMs;
 401     }
 402 
 403     @Override
 404     public int getPeerNodeReadTimeoutMs() {
 405         return peerNodeReadTimeoutMs;
 406     }
 407 
 408     public void setPeerNodeReadTimeoutMs(int peerNodeReadTimeoutMs) {
 409         this.peerNodeReadTimeoutMs = peerNodeReadTimeoutMs;
 410     }
 411 
 412     @Override
 413     public int getPeerNodeTotalConnections() {
 414         return peerNodeTotalConnections;
 415     }
 416 
 417     public void setPeerNodeTotalConnections(int peerNodeTotalConnections) {
 418         this.peerNodeTotalConnections = peerNodeTotalConnections;
 419     }
 420 
 421     @Override
 422     public int getPeerNodeTotalConnectionsPerHost() {
 423         return peerNodeTotalConnectionsPerHost;
 424     }
 425 
 426     public void setPeerNodeTotalConnectionsPerHost(int peerNodeTotalConnectionsPerHost) {
 427         this.peerNodeTotalConnectionsPerHost = peerNodeTotalConnectionsPerHost;
 428     }
 429 
 430     @Override
 431     public int getPeerNodeConnectionIdleTimeoutSeconds() {
 432         return peerNodeConnectionIdleTimeoutSeconds;
 433     }
 434 
 435     public void setPeerNodeConnectionIdleTimeoutSeconds(
 436             int peerNodeConnectionIdleTimeoutSeconds) {
 437         this.peerNodeConnectionIdleTimeoutSeconds = peerNodeConnectionIdleTimeoutSeconds;
 438     }
 439 
 440     @Override
 441     public long getRetentionTimeInMSInDeltaQueue() {
 442         return retentionTimeInMSInDeltaQueue;
 443     }
 444 
 445     public void setRetentionTimeInMSInDeltaQueue(long retentionTimeInMSInDeltaQueue) {
 446         this.retentionTimeInMSInDeltaQueue = retentionTimeInMSInDeltaQueue;
 447     }
 448 
 449     @Override
 450     public long getDeltaRetentionTimerIntervalInMs() {
 451         return deltaRetentionTimerIntervalInMs;
 452     }
 453 
 454     public void setDeltaRetentionTimerIntervalInMs(long deltaRetentionTimerIntervalInMs) {
 455         this.deltaRetentionTimerIntervalInMs = deltaRetentionTimerIntervalInMs;
 456     }
 457 
 458     @Override
 459     public long getEvictionIntervalTimerInMs() {
 460         return evictionIntervalTimerInMs;
 461     }
 462 
 463     @Override
 464     public boolean shouldUseAwsAsgApi() {
 465         return this.useAwsAsgApi;
 466     }
 467 
 468     public void setUseAwsAsgApi(boolean useAwsAsgApi) {
 469         this.useAwsAsgApi = useAwsAsgApi;
 470     }
 471 
 472     public void setEvictionIntervalTimerInMs(long evictionIntervalTimerInMs) {
 473         this.evictionIntervalTimerInMs = evictionIntervalTimerInMs;
 474     }
 475 
 476     public int getASGQueryTimeoutMs() {
 477         return aSGQueryTimeoutMs;
 478     }
 479 
 480     public void setASGQueryTimeoutMs(int aSGQueryTimeoutMs) {
 481         this.aSGQueryTimeoutMs = aSGQueryTimeoutMs;
 482     }
 483 
 484     public long getASGUpdateIntervalMs() {
 485         return aSGUpdateIntervalMs;
 486     }
 487 
 488     public void setASGUpdateIntervalMs(long aSGUpdateIntervalMs) {
 489         this.aSGUpdateIntervalMs = aSGUpdateIntervalMs;
 490     }
 491 
 492     public long getASGCacheExpiryTimeoutMs() {
 493         return aSGCacheExpiryTimeoutMs;
 494     }
 495 
 496     public void setASGCacheExpiryTimeoutMs(long aSGCacheExpiryTimeoutMs) {
 497         this.aSGCacheExpiryTimeoutMs = aSGCacheExpiryTimeoutMs;
 498     }
 499 
 500     @Override
 501     public long getResponseCacheAutoExpirationInSeconds() {
 502         return responseCacheAutoExpirationInSeconds;
 503     }
 504 
 505     public void setResponseCacheAutoExpirationInSeconds(
 506             long responseCacheAutoExpirationInSeconds) {
 507         this.responseCacheAutoExpirationInSeconds = responseCacheAutoExpirationInSeconds;
 508     }
 509 
 510     @Override
 511     public long getResponseCacheUpdateIntervalMs() {
 512         return responseCacheUpdateIntervalMs;
 513     }
 514 
 515     public void setResponseCacheUpdateIntervalMs(long responseCacheUpdateIntervalMs) {
 516         this.responseCacheUpdateIntervalMs = responseCacheUpdateIntervalMs;
 517     }
 518 
 519     public boolean isUseReadOnlyResponseCache() {
 520         return useReadOnlyResponseCache;
 521     }
 522 
 523     public void setUseReadOnlyResponseCache(boolean useReadOnlyResponseCache) {
 524         this.useReadOnlyResponseCache = useReadOnlyResponseCache;
 525     }
 526 
 527     public boolean isDisableDelta() {
 528         return disableDelta;
 529     }
 530 
 531     public void setDisableDelta(boolean disableDelta) {
 532         this.disableDelta = disableDelta;
 533     }
 534 
 535     @Override
 536     public long getMaxIdleThreadInMinutesAgeForStatusReplication() {
 537         return maxIdleThreadInMinutesAgeForStatusReplication;
 538     }
 539 
 540     public void setMaxIdleThreadInMinutesAgeForStatusReplication(
 541             long maxIdleThreadInMinutesAgeForStatusReplication) {
 542         this.maxIdleThreadInMinutesAgeForStatusReplication = maxIdleThreadInMinutesAgeForStatusReplication;
 543     }
 544 
 545     @Override
 546     public int getMinThreadsForStatusReplication() {
 547         return minThreadsForStatusReplication;
 548     }
 549 
 550     public void setMinThreadsForStatusReplication(int minThreadsForStatusReplication) {
 551         this.minThreadsForStatusReplication = minThreadsForStatusReplication;
 552     }
 553 
 554     @Override
 555     public int getMaxThreadsForStatusReplication() {
 556         return maxThreadsForStatusReplication;
 557     }
 558 
 559     public void setMaxThreadsForStatusReplication(int maxThreadsForStatusReplication) {
 560         this.maxThreadsForStatusReplication = maxThreadsForStatusReplication;
 561     }
 562 
 563     @Override
 564     public int getMaxElementsInStatusReplicationPool() {
 565         return maxElementsInStatusReplicationPool;
 566     }
 567 
 568     public void setMaxElementsInStatusReplicationPool(
 569             int maxElementsInStatusReplicationPool) {
 570         this.maxElementsInStatusReplicationPool = maxElementsInStatusReplicationPool;
 571     }
 572 
 573     public boolean isSyncWhenTimestampDiffers() {
 574         return syncWhenTimestampDiffers;
 575     }
 576 
 577     public void setSyncWhenTimestampDiffers(boolean syncWhenTimestampDiffers) {
 578         this.syncWhenTimestampDiffers = syncWhenTimestampDiffers;
 579     }
 580 
 581     @Override
 582     public int getRegistrySyncRetries() {
 583         return registrySyncRetries;
 584     }
 585 
 586     public void setRegistrySyncRetries(int registrySyncRetries) {
 587         this.registrySyncRetries = registrySyncRetries;
 588     }
 589 
 590     @Override
 591     public long getRegistrySyncRetryWaitMs() {
 592         return registrySyncRetryWaitMs;
 593     }
 594 
 595     public void setRegistrySyncRetryWaitMs(long registrySyncRetryWaitMs) {
 596         this.registrySyncRetryWaitMs = registrySyncRetryWaitMs;
 597     }
 598 
 599     @Override
 600     public int getMaxElementsInPeerReplicationPool() {
 601         return maxElementsInPeerReplicationPool;
 602     }
 603 
 604     public void setMaxElementsInPeerReplicationPool(
 605             int maxElementsInPeerReplicationPool) {
 606         this.maxElementsInPeerReplicationPool = maxElementsInPeerReplicationPool;
 607     }
 608 
 609     @Override
 610     public long getMaxIdleThreadAgeInMinutesForPeerReplication() {
 611         return maxIdleThreadAgeInMinutesForPeerReplication;
 612     }
 613 
 614     public void setMaxIdleThreadAgeInMinutesForPeerReplication(
 615             long maxIdleThreadAgeInMinutesForPeerReplication) {
 616         this.maxIdleThreadAgeInMinutesForPeerReplication = maxIdleThreadAgeInMinutesForPeerReplication;
 617     }
 618 
 619     @Override
 620     public int getMinThreadsForPeerReplication() {
 621         return minThreadsForPeerReplication;
 622     }
 623 
 624     public void setMinThreadsForPeerReplication(int minThreadsForPeerReplication) {
 625         this.minThreadsForPeerReplication = minThreadsForPeerReplication;
 626     }
 627 
 628     @Override
 629     public int getMaxThreadsForPeerReplication() {
 630         return maxThreadsForPeerReplication;
 631     }
 632 
 633     public void setMaxThreadsForPeerReplication(int maxThreadsForPeerReplication) {
 634         this.maxThreadsForPeerReplication = maxThreadsForPeerReplication;
 635     }
 636 
 637     @Override
 638     public int getMaxTimeForReplication() {
 639         return maxTimeForReplication;
 640     }
 641 
 642     public void setMaxTimeForReplication(int maxTimeForReplication) {
 643         this.maxTimeForReplication = maxTimeForReplication;
 644     }
 645 
 646     public boolean isPrimeAwsReplicaConnections() {
 647         return primeAwsReplicaConnections;
 648     }
 649 
 650     public void setPrimeAwsReplicaConnections(boolean primeAwsReplicaConnections) {
 651         this.primeAwsReplicaConnections = primeAwsReplicaConnections;
 652     }
 653 
 654     public boolean isDisableDeltaForRemoteRegions() {
 655         return disableDeltaForRemoteRegions;
 656     }
 657 
 658     public void setDisableDeltaForRemoteRegions(boolean disableDeltaForRemoteRegions) {
 659         this.disableDeltaForRemoteRegions = disableDeltaForRemoteRegions;
 660     }
 661 
 662     @Override
 663     public int getRemoteRegionConnectTimeoutMs() {
 664         return remoteRegionConnectTimeoutMs;
 665     }
 666 
 667     public void setRemoteRegionConnectTimeoutMs(int remoteRegionConnectTimeoutMs) {
 668         this.remoteRegionConnectTimeoutMs = remoteRegionConnectTimeoutMs;
 669     }
 670 
 671     @Override
 672     public int getRemoteRegionReadTimeoutMs() {
 673         return remoteRegionReadTimeoutMs;
 674     }
 675 
 676     public void setRemoteRegionReadTimeoutMs(int remoteRegionReadTimeoutMs) {
 677         this.remoteRegionReadTimeoutMs = remoteRegionReadTimeoutMs;
 678     }
 679 
 680     @Override
 681     public int getRemoteRegionTotalConnections() {
 682         return remoteRegionTotalConnections;
 683     }
 684 
 685     public void setRemoteRegionTotalConnections(int remoteRegionTotalConnections) {
 686         this.remoteRegionTotalConnections = remoteRegionTotalConnections;
 687     }
 688 
 689     @Override
 690     public int getRemoteRegionTotalConnectionsPerHost() {
 691         return remoteRegionTotalConnectionsPerHost;
 692     }
 693 
 694     public void setRemoteRegionTotalConnectionsPerHost(
 695             int remoteRegionTotalConnectionsPerHost) {
 696         this.remoteRegionTotalConnectionsPerHost = remoteRegionTotalConnectionsPerHost;
 697     }
 698 
 699     @Override
 700     public int getRemoteRegionConnectionIdleTimeoutSeconds() {
 701         return remoteRegionConnectionIdleTimeoutSeconds;
 702     }
 703 
 704     public void setRemoteRegionConnectionIdleTimeoutSeconds(
 705             int remoteRegionConnectionIdleTimeoutSeconds) {
 706         this.remoteRegionConnectionIdleTimeoutSeconds = remoteRegionConnectionIdleTimeoutSeconds;
 707     }
 708 
 709     public boolean isgZipContentFromRemoteRegion() {
 710         return gZipContentFromRemoteRegion;
 711     }
 712 
 713     public void setgZipContentFromRemoteRegion(boolean gZipContentFromRemoteRegion) {
 714         this.gZipContentFromRemoteRegion = gZipContentFromRemoteRegion;
 715     }
 716 
 717     @Override
 718     public Map<String, String> getRemoteRegionUrlsWithName() {
 719         return remoteRegionUrlsWithName;
 720     }
 721 
 722     public void setRemoteRegionUrlsWithName(
 723             Map<String, String> remoteRegionUrlsWithName) {
 724         this.remoteRegionUrlsWithName = remoteRegionUrlsWithName;
 725     }
 726 
 727     @Override
 728     public String[] getRemoteRegionUrls() {
 729         return remoteRegionUrls;
 730     }
 731 
 732     public void setRemoteRegionUrls(String[] remoteRegionUrls) {
 733         this.remoteRegionUrls = remoteRegionUrls;
 734     }
 735 
 736     public Map<String, Set<String>> getRemoteRegionAppWhitelist() {
 737         return remoteRegionAppWhitelist;
 738     }
 739 
 740     public void setRemoteRegionAppWhitelist(
 741             Map<String, Set<String>> remoteRegionAppWhitelist) {
 742         this.remoteRegionAppWhitelist = remoteRegionAppWhitelist;
 743     }
 744 
 745     @Override
 746     public int getRemoteRegionRegistryFetchInterval() {
 747         return remoteRegionRegistryFetchInterval;
 748     }
 749 
 750     public void setRemoteRegionRegistryFetchInterval(
 751             int remoteRegionRegistryFetchInterval) {
 752         this.remoteRegionRegistryFetchInterval = remoteRegionRegistryFetchInterval;
 753     }
 754 
 755     @Override
 756     public int getRemoteRegionFetchThreadPoolSize() {
 757         return remoteRegionFetchThreadPoolSize;
 758     }
 759 
 760     public void setRemoteRegionFetchThreadPoolSize(int remoteRegionFetchThreadPoolSize) {
 761         this.remoteRegionFetchThreadPoolSize = remoteRegionFetchThreadPoolSize;
 762     }
 763 
 764     @Override
 765     public String getRemoteRegionTrustStore() {
 766         return remoteRegionTrustStore;
 767     }
 768 
 769     public void setRemoteRegionTrustStore(String remoteRegionTrustStore) {
 770         this.remoteRegionTrustStore = remoteRegionTrustStore;
 771     }
 772 
 773     @Override
 774     public String getRemoteRegionTrustStorePassword() {
 775         return remoteRegionTrustStorePassword;
 776     }
 777 
 778     public void setRemoteRegionTrustStorePassword(String remoteRegionTrustStorePassword) {
 779         this.remoteRegionTrustStorePassword = remoteRegionTrustStorePassword;
 780     }
 781 
 782     public boolean isDisableTransparentFallbackToOtherRegion() {
 783         return disableTransparentFallbackToOtherRegion;
 784     }
 785 
 786     public void setDisableTransparentFallbackToOtherRegion(
 787             boolean disableTransparentFallbackToOtherRegion) {
 788         this.disableTransparentFallbackToOtherRegion = disableTransparentFallbackToOtherRegion;
 789     }
 790 
 791     public boolean isBatchReplication() {
 792         return batchReplication;
 793     }
 794 
 795     public void setBatchReplication(boolean batchReplication) {
 796         this.batchReplication = batchReplication;
 797     }
 798 
 799     @Override
 800     public boolean isRateLimiterEnabled() {
 801         return rateLimiterEnabled;
 802     }
 803 
 804     public void setRateLimiterEnabled(boolean rateLimiterEnabled) {
 805         this.rateLimiterEnabled = rateLimiterEnabled;
 806     }
 807 
 808     @Override
 809     public boolean isRateLimiterThrottleStandardClients() {
 810         return rateLimiterThrottleStandardClients;
 811     }
 812 
 813     public void setRateLimiterThrottleStandardClients(
 814             boolean rateLimiterThrottleStandardClients) {
 815         this.rateLimiterThrottleStandardClients = rateLimiterThrottleStandardClients;
 816     }
 817 
 818     @Override
 819     public Set<String> getRateLimiterPrivilegedClients() {
 820         return rateLimiterPrivilegedClients;
 821     }
 822 
 823     public void setRateLimiterPrivilegedClients(
 824             Set<String> rateLimiterPrivilegedClients) {
 825         this.rateLimiterPrivilegedClients = rateLimiterPrivilegedClients;
 826     }
 827 
 828     @Override
 829     public int getRateLimiterBurstSize() {
 830         return rateLimiterBurstSize;
 831     }
 832 
 833     public void setRateLimiterBurstSize(int rateLimiterBurstSize) {
 834         this.rateLimiterBurstSize = rateLimiterBurstSize;
 835     }
 836 
 837     @Override
 838     public int getRateLimiterRegistryFetchAverageRate() {
 839         return rateLimiterRegistryFetchAverageRate;
 840     }
 841 
 842     public void setRateLimiterRegistryFetchAverageRate(
 843             int rateLimiterRegistryFetchAverageRate) {
 844         this.rateLimiterRegistryFetchAverageRate = rateLimiterRegistryFetchAverageRate;
 845     }
 846 
 847     @Override
 848     public int getRateLimiterFullFetchAverageRate() {
 849         return rateLimiterFullFetchAverageRate;
 850     }
 851 
 852     public void setRateLimiterFullFetchAverageRate(int rateLimiterFullFetchAverageRate) {
 853         this.rateLimiterFullFetchAverageRate = rateLimiterFullFetchAverageRate;
 854     }
 855 
 856     public boolean isLogIdentityHeaders() {
 857         return logIdentityHeaders;
 858     }
 859 
 860     public void setLogIdentityHeaders(boolean logIdentityHeaders) {
 861         this.logIdentityHeaders = logIdentityHeaders;
 862     }
 863 
 864     @Override
 865     public String getListAutoScalingGroupsRoleName() {
 866         return listAutoScalingGroupsRoleName;
 867     }
 868 
 869     public void setListAutoScalingGroupsRoleName(String listAutoScalingGroupsRoleName) {
 870         this.listAutoScalingGroupsRoleName = listAutoScalingGroupsRoleName;
 871     }
 872 
 873     public boolean isEnableReplicatedRequestCompression() {
 874         return enableReplicatedRequestCompression;
 875     }
 876 
 877     public void setEnableReplicatedRequestCompression(
 878             boolean enableReplicatedRequestCompression) {
 879         this.enableReplicatedRequestCompression = enableReplicatedRequestCompression;
 880     }
 881 
 882     public void setJsonCodecName(String jsonCodecName) {
 883         this.jsonCodecName = jsonCodecName;
 884     }
 885 
 886     public void setXmlCodecName(String xmlCodecName) {
 887         this.xmlCodecName = xmlCodecName;
 888     }
 889 
 890     @Override
 891     public int getRoute53BindRebindRetries() {
 892         return route53BindRebindRetries;
 893     }
 894 
 895     public void setRoute53BindRebindRetries(int route53BindRebindRetries) {
 896         this.route53BindRebindRetries = route53BindRebindRetries;
 897     }
 898 
 899     @Override
 900     public int getRoute53BindingRetryIntervalMs() {
 901         return route53BindingRetryIntervalMs;
 902     }
 903 
 904     public void setRoute53BindingRetryIntervalMs(int route53BindingRetryIntervalMs) {
 905         this.route53BindingRetryIntervalMs = route53BindingRetryIntervalMs;
 906     }
 907 
 908     @Override
 909     public long getRoute53DomainTTL() {
 910         return route53DomainTTL;
 911     }
 912 
 913     public void setRoute53DomainTTL(long route53DomainTTL) {
 914         this.route53DomainTTL = route53DomainTTL;
 915     }
 916 
 917     @Override
 918     public AwsBindingStrategy getBindingStrategy() {
 919         return bindingStrategy;
 920     }
 921 
 922     public void setBindingStrategy(AwsBindingStrategy bindingStrategy) {
 923         this.bindingStrategy = bindingStrategy;
 924     }
 925 
 926     public int getMinAvailableInstancesForPeerReplication() {
 927         return minAvailableInstancesForPeerReplication;
 928     }
 929 
 930     public void setMinAvailableInstancesForPeerReplication(
 931             int minAvailableInstancesForPeerReplication) {
 932         this.minAvailableInstancesForPeerReplication = minAvailableInstancesForPeerReplication;
 933     }
 934 
 935     @Override
 936     public boolean equals(Object o) {
 937         if (this == o) {
 938             return true;
 939         }
 940         if (o == null || getClass() != o.getClass()) {
 941             return false;
 942         }
 943         EurekaServerConfigBean that = (EurekaServerConfigBean) o;
 944         return aSGCacheExpiryTimeoutMs == that.aSGCacheExpiryTimeoutMs
 945                 && aSGQueryTimeoutMs == that.aSGQueryTimeoutMs
 946                 && aSGUpdateIntervalMs == that.aSGUpdateIntervalMs
 947                 && Objects.equals(aWSAccessId, that.aWSAccessId)
 948                 && Objects.equals(aWSSecretKey, that.aWSSecretKey)
 949                 && batchReplication == that.batchReplication
 950                 && bindingStrategy == that.bindingStrategy
 951                 && deltaRetentionTimerIntervalInMs == that.deltaRetentionTimerIntervalInMs
 952                 && disableDelta == that.disableDelta
 953                 && disableDeltaForRemoteRegions == that.disableDeltaForRemoteRegions
 954                 && disableTransparentFallbackToOtherRegion == that.disableTransparentFallbackToOtherRegion
 955                 && eIPBindingRetryIntervalMs == that.eIPBindingRetryIntervalMs
 956                 && eIPBindingRetryIntervalMsWhenUnbound == that.eIPBindingRetryIntervalMsWhenUnbound
 957                 && eIPBindRebindRetries == that.eIPBindRebindRetries
 958                 && enableReplicatedRequestCompression == that.enableReplicatedRequestCompression
 959                 && enableSelfPreservation == that.enableSelfPreservation
 960                 && evictionIntervalTimerInMs == that.evictionIntervalTimerInMs
 961                 && gZipContentFromRemoteRegion == that.gZipContentFromRemoteRegion
 962                 && Objects.equals(jsonCodecName, that.jsonCodecName)
 963                 && Objects.equals(listAutoScalingGroupsRoleName,
 964                         that.listAutoScalingGroupsRoleName)
 965                 && logIdentityHeaders == that.logIdentityHeaders
 966                 && maxElementsInPeerReplicationPool == that.maxElementsInPeerReplicationPool
 967                 && maxElementsInStatusReplicationPool == that.maxElementsInStatusReplicationPool
 968                 && maxIdleThreadAgeInMinutesForPeerReplication == that.maxIdleThreadAgeInMinutesForPeerReplication
 969                 && maxIdleThreadInMinutesAgeForStatusReplication == that.maxIdleThreadInMinutesAgeForStatusReplication
 970                 && maxThreadsForPeerReplication == that.maxThreadsForPeerReplication
 971                 && maxThreadsForStatusReplication == that.maxThreadsForStatusReplication
 972                 && maxTimeForReplication == that.maxTimeForReplication
 973                 && minAvailableInstancesForPeerReplication == that.minAvailableInstancesForPeerReplication
 974                 && minThreadsForPeerReplication == that.minThreadsForPeerReplication
 975                 && minThreadsForStatusReplication == that.minThreadsForStatusReplication
 976                 && numberOfReplicationRetries == that.numberOfReplicationRetries
 977                 && peerEurekaNodesUpdateIntervalMs == that.peerEurekaNodesUpdateIntervalMs
 978                 && peerEurekaStatusRefreshTimeIntervalMs == that.peerEurekaStatusRefreshTimeIntervalMs
 979                 && peerNodeConnectionIdleTimeoutSeconds == that.peerNodeConnectionIdleTimeoutSeconds
 980                 && peerNodeConnectTimeoutMs == that.peerNodeConnectTimeoutMs
 981                 && peerNodeReadTimeoutMs == that.peerNodeReadTimeoutMs
 982                 && peerNodeTotalConnections == that.peerNodeTotalConnections
 983                 && peerNodeTotalConnectionsPerHost == that.peerNodeTotalConnectionsPerHost
 984                 && primeAwsReplicaConnections == that.primeAwsReplicaConnections
 985                 && Objects.equals(propertyResolver, that.propertyResolver)
 986                 && rateLimiterBurstSize == that.rateLimiterBurstSize
 987                 && rateLimiterEnabled == that.rateLimiterEnabled
 988                 && rateLimiterFullFetchAverageRate == that.rateLimiterFullFetchAverageRate
 989                 && Objects.equals(rateLimiterPrivilegedClients,
 990                         that.rateLimiterPrivilegedClients)
 991                 && rateLimiterRegistryFetchAverageRate == that.rateLimiterRegistryFetchAverageRate
 992                 && rateLimiterThrottleStandardClients == that.rateLimiterThrottleStandardClients
 993                 && registrySyncRetries == that.registrySyncRetries
 994                 && registrySyncRetryWaitMs == that.registrySyncRetryWaitMs
 995                 && Objects.equals(remoteRegionAppWhitelist, that.remoteRegionAppWhitelist)
 996                 && remoteRegionConnectionIdleTimeoutSeconds == that.remoteRegionConnectionIdleTimeoutSeconds
 997                 && remoteRegionConnectTimeoutMs == that.remoteRegionConnectTimeoutMs
 998                 && remoteRegionFetchThreadPoolSize == that.remoteRegionFetchThreadPoolSize
 999                 && remoteRegionReadTimeoutMs == that.remoteRegionReadTimeoutMs
1000                 && remoteRegionRegistryFetchInterval == that.remoteRegionRegistryFetchInterval
1001                 && remoteRegionTotalConnections == that.remoteRegionTotalConnections
1002                 && remoteRegionTotalConnectionsPerHost == that.remoteRegionTotalConnectionsPerHost
1003                 && Objects.equals(remoteRegionTrustStore, that.remoteRegionTrustStore)
1004                 && Objects.equals(remoteRegionTrustStorePassword,
1005                         that.remoteRegionTrustStorePassword)
1006                 && Arrays.equals(remoteRegionUrls, that.remoteRegionUrls)
1007                 && Objects.equals(remoteRegionUrlsWithName, that.remoteRegionUrlsWithName)
1008                 && Double.compare(that.renewalPercentThreshold,
1009                         renewalPercentThreshold) == 0
1010                 && renewalThresholdUpdateIntervalMs == that.renewalThresholdUpdateIntervalMs
1011                 && responseCacheAutoExpirationInSeconds == that.responseCacheAutoExpirationInSeconds
1012                 && responseCacheUpdateIntervalMs == that.responseCacheUpdateIntervalMs
1013                 && retentionTimeInMSInDeltaQueue == that.retentionTimeInMSInDeltaQueue
1014                 && route53BindingRetryIntervalMs == that.route53BindingRetryIntervalMs
1015                 && route53BindRebindRetries == that.route53BindRebindRetries
1016                 && route53DomainTTL == that.route53DomainTTL
1017                 && syncWhenTimestampDiffers == that.syncWhenTimestampDiffers
1018                 && useReadOnlyResponseCache == that.useReadOnlyResponseCache
1019                 && waitTimeInMsWhenSyncEmpty == that.waitTimeInMsWhenSyncEmpty
1020                 && Objects.equals(xmlCodecName, that.xmlCodecName)
1021                 && initialCapacityOfResponseCache == that.initialCapacityOfResponseCache
1022                 && expectedClientRenewalIntervalSeconds == that.expectedClientRenewalIntervalSeconds
1023                 && useAwsAsgApi == that.useAwsAsgApi && Objects.equals(myUrl, that.myUrl);
1024     }
1025 
1026     @Override
1027     public int hashCode() {
1028         return Objects.hash(aSGCacheExpiryTimeoutMs, aSGQueryTimeoutMs,
1029                 aSGUpdateIntervalMs, aWSAccessId, aWSSecretKey, batchReplication,
1030                 bindingStrategy, deltaRetentionTimerIntervalInMs, disableDelta,
1031                 disableDeltaForRemoteRegions, disableTransparentFallbackToOtherRegion,
1032                 eIPBindRebindRetries, eIPBindingRetryIntervalMs,
1033                 eIPBindingRetryIntervalMsWhenUnbound, enableReplicatedRequestCompression,
1034                 enableSelfPreservation, evictionIntervalTimerInMs,
1035                 gZipContentFromRemoteRegion, jsonCodecName, listAutoScalingGroupsRoleName,
1036                 logIdentityHeaders, maxElementsInPeerReplicationPool,
1037                 maxElementsInStatusReplicationPool,
1038                 maxIdleThreadAgeInMinutesForPeerReplication,
1039                 maxIdleThreadInMinutesAgeForStatusReplication,
1040                 maxThreadsForPeerReplication, maxThreadsForStatusReplication,
1041                 maxTimeForReplication, minAvailableInstancesForPeerReplication,
1042                 minThreadsForPeerReplication, minThreadsForStatusReplication,
1043                 numberOfReplicationRetries, peerEurekaNodesUpdateIntervalMs,
1044                 peerEurekaStatusRefreshTimeIntervalMs, peerNodeConnectTimeoutMs,
1045                 peerNodeConnectionIdleTimeoutSeconds, peerNodeReadTimeoutMs,
1046                 peerNodeTotalConnections, peerNodeTotalConnectionsPerHost,
1047                 primeAwsReplicaConnections, propertyResolver, rateLimiterBurstSize,
1048                 rateLimiterEnabled, rateLimiterFullFetchAverageRate,
1049                 rateLimiterPrivilegedClients, rateLimiterRegistryFetchAverageRate,
1050                 rateLimiterThrottleStandardClients, registrySyncRetries,
1051                 registrySyncRetryWaitMs, remoteRegionAppWhitelist,
1052                 remoteRegionConnectTimeoutMs, remoteRegionConnectionIdleTimeoutSeconds,
1053                 remoteRegionFetchThreadPoolSize, remoteRegionReadTimeoutMs,
1054                 remoteRegionRegistryFetchInterval, remoteRegionTotalConnections,
1055                 remoteRegionTotalConnectionsPerHost, remoteRegionTrustStore,
1056                 remoteRegionTrustStorePassword, remoteRegionUrls,
1057                 remoteRegionUrlsWithName, renewalPercentThreshold,
1058                 renewalThresholdUpdateIntervalMs, responseCacheAutoExpirationInSeconds,
1059                 responseCacheUpdateIntervalMs, retentionTimeInMSInDeltaQueue,
1060                 route53BindRebindRetries, route53BindingRetryIntervalMs, route53DomainTTL,
1061                 syncWhenTimestampDiffers, useReadOnlyResponseCache,
1062                 waitTimeInMsWhenSyncEmpty, xmlCodecName, initialCapacityOfResponseCache,
1063                 expectedClientRenewalIntervalSeconds, useAwsAsgApi, myUrl);
1064     }
1065 
1066     @Override
1067     public String toString() {
1068         return new ToStringCreator(this)
1069                 .append("aSGCacheExpiryTimeoutMs", this.aSGCacheExpiryTimeoutMs)
1070                 .append("aSGQueryTimeoutMs", this.aSGQueryTimeoutMs)
1071                 .append("aSGUpdateIntervalMs", this.aSGUpdateIntervalMs)
1072                 .append("aWSAccessId", this.aWSAccessId)
1073                 .append("aWSSecretKey", this.aWSSecretKey)
1074                 .append("batchReplication", this.batchReplication)
1075                 .append("bindingStrategy", this.bindingStrategy)
1076                 .append("deltaRetentionTimerIntervalInMs",
1077                         this.deltaRetentionTimerIntervalInMs)
1078                 .append("disableDelta", this.disableDelta)
1079                 .append("disableDeltaForRemoteRegions", this.disableDeltaForRemoteRegions)
1080                 .append("disableTransparentFallbackToOtherRegion",
1081                         this.disableTransparentFallbackToOtherRegion)
1082                 .append("eIPBindRebindRetries", this.eIPBindRebindRetries)
1083                 .append("eIPBindingRetryIntervalMs", this.eIPBindingRetryIntervalMs)
1084                 .append("eIPBindingRetryIntervalMsWhenUnbound",
1085                         this.eIPBindingRetryIntervalMsWhenUnbound)
1086                 .append("enableReplicatedRequestCompression",
1087                         this.enableReplicatedRequestCompression)
1088                 .append("enableSelfPreservation", this.enableSelfPreservation)
1089                 .append("evictionIntervalTimerInMs", this.evictionIntervalTimerInMs)
1090                 .append("gZipContentFromRemoteRegion", this.gZipContentFromRemoteRegion)
1091                 .append("jsonCodecName", this.jsonCodecName)
1092                 .append("listAutoScalingGroupsRoleName",
1093                         this.listAutoScalingGroupsRoleName)
1094                 .append("logIdentityHeaders", this.logIdentityHeaders)
1095                 .append("maxElementsInPeerReplicationPool",
1096                         this.maxElementsInPeerReplicationPool)
1097                 .append("maxElementsInStatusReplicationPool",
1098                         this.maxElementsInStatusReplicationPool)
1099                 .append("maxIdleThreadAgeInMinutesForPeerReplication",
1100                         this.maxIdleThreadAgeInMinutesForPeerReplication)
1101                 .append("maxIdleThreadInMinutesAgeForStatusReplication",
1102                         this.maxIdleThreadInMinutesAgeForStatusReplication)
1103                 .append("maxThreadsForPeerReplication", this.maxThreadsForPeerReplication)
1104                 .append("maxThreadsForStatusReplication",
1105                         this.maxThreadsForStatusReplication)
1106                 .append("maxTimeForReplication", this.maxTimeForReplication)
1107                 .append("minAvailableInstancesForPeerReplication",
1108                         this.minAvailableInstancesForPeerReplication)
1109                 .append("minThreadsForPeerReplication", this.minThreadsForPeerReplication)
1110                 .append("minThreadsForStatusReplication",
1111                         this.minThreadsForStatusReplication)
1112                 .append("numberOfReplicationRetries", this.numberOfReplicationRetries)
1113                 .append("peerEurekaNodesUpdateIntervalMs",
1114                         this.peerEurekaNodesUpdateIntervalMs)
1115                 .append("peerEurekaStatusRefreshTimeIntervalMs",
1116                         this.peerEurekaStatusRefreshTimeIntervalMs)
1117                 .append("peerNodeConnectTimeoutMs", this.peerNodeConnectTimeoutMs)
1118                 .append("peerNodeConnectionIdleTimeoutSeconds",
1119                         this.peerNodeConnectionIdleTimeoutSeconds)
1120                 .append("peerNodeReadTimeoutMs", this.peerNodeReadTimeoutMs)
1121                 .append("peerNodeTotalConnections", this.peerNodeTotalConnections)
1122                 .append("peerNodeTotalConnectionsPerHost",
1123                         this.peerNodeTotalConnectionsPerHost)
1124                 .append("primeAwsReplicaConnections", this.primeAwsReplicaConnections)
1125                 .append("propertyResolver", this.propertyResolver)
1126                 .append("rateLimiterBurstSize", this.rateLimiterBurstSize)
1127                 .append("rateLimiterEnabled", this.rateLimiterEnabled)
1128                 .append("rateLimiterFullFetchAverageRate",
1129                         this.rateLimiterFullFetchAverageRate)
1130                 .append("rateLimiterPrivilegedClients", this.rateLimiterPrivilegedClients)
1131                 .append("rateLimiterRegistryFetchAverageRate",
1132                         this.rateLimiterRegistryFetchAverageRate)
1133                 .append("rateLimiterThrottleStandardClients",
1134                         this.rateLimiterThrottleStandardClients)
1135                 .append("registrySyncRetries", this.registrySyncRetries)
1136                 .append("registrySyncRetryWaitMs", this.registrySyncRetryWaitMs)
1137                 .append("remoteRegionAppWhitelist", this.remoteRegionAppWhitelist)
1138                 .append("remoteRegionConnectTimeoutMs", this.remoteRegionConnectTimeoutMs)
1139                 .append("remoteRegionConnectionIdleTimeoutSeconds",
1140                         this.remoteRegionConnectionIdleTimeoutSeconds)
1141                 .append("remoteRegionFetchThreadPoolSize",
1142                         this.remoteRegionFetchThreadPoolSize)
1143                 .append("remoteRegionReadTimeoutMs", this.remoteRegionReadTimeoutMs)
1144                 .append("remoteRegionRegistryFetchInterval",
1145                         this.remoteRegionRegistryFetchInterval)
1146                 .append("remoteRegionTotalConnections", this.remoteRegionTotalConnections)
1147                 .append("remoteRegionTotalConnectionsPerHost",
1148                         this.remoteRegionTotalConnectionsPerHost)
1149                 .append("remoteRegionTrustStore", this.remoteRegionTrustStore)
1150                 .append("remoteRegionTrustStorePassword",
1151                         this.remoteRegionTrustStorePassword)
1152                 .append("remoteRegionUrls", this.remoteRegionUrls)
1153                 .append("remoteRegionUrlsWithName", this.remoteRegionUrlsWithName)
1154                 .append("renewalPercentThreshold", this.renewalPercentThreshold)
1155                 .append("renewalThresholdUpdateIntervalMs",
1156                         this.renewalThresholdUpdateIntervalMs)
1157                 .append("responseCacheAutoExpirationInSeconds",
1158                         this.responseCacheAutoExpirationInSeconds)
1159                 .append("responseCacheUpdateIntervalMs",
1160                         this.responseCacheUpdateIntervalMs)
1161                 .append("retentionTimeInMSInDeltaQueue",
1162                         this.retentionTimeInMSInDeltaQueue)
1163                 .append("route53BindRebindRetries", this.route53BindRebindRetries)
1164                 .append("route53BindingRetryIntervalMs",
1165                         this.route53BindingRetryIntervalMs)
1166                 .append("route53DomainTTL", this.route53DomainTTL)
1167                 .append("syncWhenTimestampDiffers", this.syncWhenTimestampDiffers)
1168                 .append("useReadOnlyResponseCache", this.useReadOnlyResponseCache)
1169                 .append("waitTimeInMsWhenSyncEmpty", this.waitTimeInMsWhenSyncEmpty)
1170                 .append("xmlCodecName", this.xmlCodecName)
1171                 .append("initialCapacityOfResponseCache",
1172                         this.initialCapacityOfResponseCache)
1173                 .append("expectedClientRenewalIntervalSeconds",
1174                         this.expectedClientRenewalIntervalSeconds)
1175                 .append("useAwsAsgApi", this.useAwsAsgApi).append("myUrl", this.myUrl)
1176                 .toString();
1177     }
1178 
1179 }

 1 public void start() {
 2     new Thread(() -> {
 3         try {
 4             // TODO: is this class even needed now?
 5             eurekaServerBootstrap.contextInitialized(
 6                     EurekaServerInitializerConfiguration.this.servletContext);
 7             log.info("Started Eureka Server");
 8 
 9             publish(new EurekaRegistryAvailableEvent(getEurekaServerConfig()));
10             EurekaServerInitializerConfiguration.this.running = true;
11             publish(new EurekaServerStartedEvent(getEurekaServerConfig()));
12         }
13         catch (Exception ex) {
14             // Help!
15             log.error("Could not initialize Eureka servlet context", ex);
16         }
17     }).start();
18 }

  1 @Configuration(proxyBeanMethods = false)
  2 @EnableConfigurationProperties
  3 @ConditionalOnClass(EurekaClientConfig.class)
  4 @ConditionalOnProperty(value = "eureka.client.enabled", matchIfMissing = true)
  5 @ConditionalOnDiscoveryEnabled
  6 @AutoConfigureBefore({ NoopDiscoveryClientAutoConfiguration.class,
  7         CommonsClientAutoConfiguration.class, ServiceRegistryAutoConfiguration.class })
  8 @AutoConfigureAfter(name = {
  9         "org.springframework.cloud.netflix.eureka.config.DiscoveryClientOptionalArgsConfiguration",
 10         "org.springframework.cloud.autoconfigure.RefreshAutoConfiguration",
 11         "org.springframework.cloud.netflix.eureka.EurekaDiscoveryClientConfiguration",
 12         "org.springframework.cloud.client.serviceregistry.AutoServiceRegistrationAutoConfiguration" })
 13 public class EurekaClientAutoConfiguration {
 14 
 15     private ConfigurableEnvironment env;
 16 
 17     public EurekaClientAutoConfiguration(ConfigurableEnvironment env) {
 18         this.env = env;
 19     }
 20 
 21     @Bean
 22     public HasFeatures eurekaFeature() {
 23         return HasFeatures.namedFeature("Eureka Client", EurekaClient.class);
 24     }
 25 
 26     @Bean
 27     @ConditionalOnMissingBean(value = EurekaClientConfig.class,
 28             search = SearchStrategy.CURRENT)
 29     public EurekaClientConfigBean eurekaClientConfigBean(ConfigurableEnvironment env) {
 30         return new EurekaClientConfigBean();
 31     }
 32 
 33     @Bean
 34     @ConditionalOnMissingBean
 35     public ManagementMetadataProvider serviceManagementMetadataProvider() {
 36         return new DefaultManagementMetadataProvider();
 37     }
 38 
 39     private String getProperty(String property) {
 40         return this.env.containsProperty(property) ? this.env.getProperty(property) : "";
 41     }
 42 
 43     @Bean
 44     @ConditionalOnMissingBean(value = EurekaInstanceConfig.class,
 45             search = SearchStrategy.CURRENT)
 46     public EurekaInstanceConfigBean eurekaInstanceConfigBean(InetUtils inetUtils,
 47             ManagementMetadataProvider managementMetadataProvider) {
 48         String hostname = getProperty("eureka.instance.hostname");
 49         boolean preferIpAddress = Boolean
 50                 .parseBoolean(getProperty("eureka.instance.prefer-ip-address"));
 51         String ipAddress = getProperty("eureka.instance.ip-address");
 52         boolean isSecurePortEnabled = Boolean
 53                 .parseBoolean(getProperty("eureka.instance.secure-port-enabled"));
 54 
 55         String serverContextPath = env.getProperty("server.servlet.context-path", "/");
 56         int serverPort = Integer.parseInt(
 57                 env.getProperty("server.port", env.getProperty("port", "8080")));
 58 
 59         Integer managementPort = env.getProperty("management.server.port", Integer.class);
 60         String managementContextPath = env
 61                 .getProperty("management.server.servlet.context-path");
 62         Integer jmxPort = env.getProperty("com.sun.management.jmxremote.port",
 63                 Integer.class);
 64         EurekaInstanceConfigBean instance = new EurekaInstanceConfigBean(inetUtils);
 65 
 66         instance.setNonSecurePort(serverPort);
 67         instance.setInstanceId(getDefaultInstanceId(env));
 68         instance.setPreferIpAddress(preferIpAddress);
 69         instance.setSecurePortEnabled(isSecurePortEnabled);
 70         if (StringUtils.hasText(ipAddress)) {
 71             instance.setIpAddress(ipAddress);
 72         }
 73 
 74         if (isSecurePortEnabled) {
 75             instance.setSecurePort(serverPort);
 76         }
 77 
 78         if (StringUtils.hasText(hostname)) {
 79             instance.setHostname(hostname);
 80         }
 81         String statusPageUrlPath = getProperty("eureka.instance.status-page-url-path");
 82         String healthCheckUrlPath = getProperty("eureka.instance.health-check-url-path");
 83 
 84         if (StringUtils.hasText(statusPageUrlPath)) {
 85             instance.setStatusPageUrlPath(statusPageUrlPath);
 86         }
 87         if (StringUtils.hasText(healthCheckUrlPath)) {
 88             instance.setHealthCheckUrlPath(healthCheckUrlPath);
 89         }
 90 
 91         ManagementMetadata metadata = managementMetadataProvider.get(instance, serverPort,
 92                 serverContextPath, managementContextPath, managementPort);
 93 
 94         if (metadata != null) {
 95             instance.setStatusPageUrl(metadata.getStatusPageUrl());
 96             instance.setHealthCheckUrl(metadata.getHealthCheckUrl());
 97             if (instance.isSecurePortEnabled()) {
 98                 instance.setSecureHealthCheckUrl(metadata.getSecureHealthCheckUrl());
 99             }
100             Map<String, String> metadataMap = instance.getMetadataMap();
101             metadataMap.computeIfAbsent("management.port",
102                     k -> String.valueOf(metadata.getManagementPort()));
103         }
104         else {
105             // without the metadata the status and health check URLs will not be set
106             // and the status page and health check url paths will not include the
107             // context path so set them here
108             if (StringUtils.hasText(managementContextPath)) {
109                 instance.setHealthCheckUrlPath(
110                         managementContextPath + instance.getHealthCheckUrlPath());
111                 instance.setStatusPageUrlPath(
112                         managementContextPath + instance.getStatusPageUrlPath());
113             }
114         }
115 
116         setupJmxPort(instance, jmxPort);
117         return instance;
118     }
119 
120     private void setupJmxPort(EurekaInstanceConfigBean instance, Integer jmxPort) {
121         Map<String, String> metadataMap = instance.getMetadataMap();
122         if (metadataMap.get("jmx.port") == null && jmxPort != null) {
123             metadataMap.put("jmx.port", String.valueOf(jmxPort));
124         }
125     }
126 
127     @Bean
128     public EurekaServiceRegistry eurekaServiceRegistry() {
129         return new EurekaServiceRegistry();
130     }
131 
132     // @Bean
133     // @ConditionalOnBean(AutoServiceRegistrationProperties.class)
134     // @ConditionalOnProperty(value =
135     // "spring.cloud.service-registry.auto-registration.enabled", matchIfMissing = true)
136     // public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient,
137     // CloudEurekaInstanceConfig instanceConfig, ApplicationInfoManager
138     // applicationInfoManager, ObjectProvider<HealthCheckHandler> healthCheckHandler) {
139     // return EurekaRegistration.builder(instanceConfig)
140     // .with(applicationInfoManager)
141     // .with(eurekaClient)
142     // .with(healthCheckHandler)
143     // .build();
144     // }
145 
146     @Bean
147     @ConditionalOnBean(AutoServiceRegistrationProperties.class)
148     @ConditionalOnProperty(
149             value = "spring.cloud.service-registry.auto-registration.enabled",
150             matchIfMissing = true)
151     public EurekaAutoServiceRegistration eurekaAutoServiceRegistration(
152             ApplicationContext context, EurekaServiceRegistry registry,
153             EurekaRegistration registration) {
154         return new EurekaAutoServiceRegistration(context, registry, registration);
155     }
156 
157     @Configuration(proxyBeanMethods = false)
158     @ConditionalOnMissingRefreshScope
159     protected static class EurekaClientConfiguration {
160 
161         @Autowired
162         private ApplicationContext context;
163 
164         @Autowired
165         private AbstractDiscoveryClientOptionalArgs<?> optionalArgs;
166 
167         @Bean(destroyMethod = "shutdown")
168         @ConditionalOnMissingBean(value = EurekaClient.class,
169                 search = SearchStrategy.CURRENT)
170         public EurekaClient eurekaClient(ApplicationInfoManager manager,
171                 EurekaClientConfig config) {
172             return new CloudEurekaClient(manager, config, this.optionalArgs,
173                     this.context);
174         }
175 
176         @Bean
177         @ConditionalOnMissingBean(value = ApplicationInfoManager.class,
178                 search = SearchStrategy.CURRENT)
179         public ApplicationInfoManager eurekaApplicationInfoManager(
180                 EurekaInstanceConfig config) {
181             InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
182             return new ApplicationInfoManager(config, instanceInfo);
183         }
184 
185         @Bean
186         @ConditionalOnBean(AutoServiceRegistrationProperties.class)
187         @ConditionalOnProperty(
188                 value = "spring.cloud.service-registry.auto-registration.enabled",
189                 matchIfMissing = true)
190         public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient,
191                 CloudEurekaInstanceConfig instanceConfig,
192                 ApplicationInfoManager applicationInfoManager, @Autowired(
193                         required = false) ObjectProvider<HealthCheckHandler> healthCheckHandler) {
194             return EurekaRegistration.builder(instanceConfig).with(applicationInfoManager)
195                     .with(eurekaClient).with(healthCheckHandler).build();
196         }
197 
198     }
199 
200     @Configuration(proxyBeanMethods = false)
201     @ConditionalOnRefreshScope
202     protected static class RefreshableEurekaClientConfiguration {
203 
204         @Autowired
205         private ApplicationContext context;
206 
207         @Autowired
208         private AbstractDiscoveryClientOptionalArgs<?> optionalArgs;
209 
210         @Bean(destroyMethod = "shutdown")
211         @ConditionalOnMissingBean(value = EurekaClient.class,
212                 search = SearchStrategy.CURRENT)
213         @org.springframework.cloud.context.config.annotation.RefreshScope
214         @Lazy
215         public EurekaClient eurekaClient(ApplicationInfoManager manager,
216                 EurekaClientConfig config, EurekaInstanceConfig instance,
217                 @Autowired(required = false) HealthCheckHandler healthCheckHandler) {
218             // If we use the proxy of the ApplicationInfoManager we could run into a
219             // problem
220             // when shutdown is called on the CloudEurekaClient where the
221             // ApplicationInfoManager bean is
222             // requested but wont be allowed because we are shutting down. To avoid this
223             // we use the
224             // object directly.
225             ApplicationInfoManager appManager;
226             if (AopUtils.isAopProxy(manager)) {
227                 appManager = ProxyUtils.getTargetObject(manager);
228             }
229             else {
230                 appManager = manager;
231             }
232             CloudEurekaClient cloudEurekaClient = new CloudEurekaClient(appManager,
233                     config, this.optionalArgs, this.context);
234             cloudEurekaClient.registerHealthCheck(healthCheckHandler);
235             return cloudEurekaClient;
236         }
237 
238         @Bean
239         @ConditionalOnMissingBean(value = ApplicationInfoManager.class,
240                 search = SearchStrategy.CURRENT)
241         @org.springframework.cloud.context.config.annotation.RefreshScope
242         @Lazy
243         public ApplicationInfoManager eurekaApplicationInfoManager(
244                 EurekaInstanceConfig config) {
245             InstanceInfo instanceInfo = new InstanceInfoFactory().create(config);
246             return new ApplicationInfoManager(config, instanceInfo);
247         }
248 
249         @Bean
250         @org.springframework.cloud.context.config.annotation.RefreshScope
251         @ConditionalOnBean(AutoServiceRegistrationProperties.class)
252         @ConditionalOnProperty(
253                 value = "spring.cloud.service-registry.auto-registration.enabled",
254                 matchIfMissing = true)
255         public EurekaRegistration eurekaRegistration(EurekaClient eurekaClient,
256                 CloudEurekaInstanceConfig instanceConfig,
257                 ApplicationInfoManager applicationInfoManager, @Autowired(
258                         required = false) ObjectProvider<HealthCheckHandler> healthCheckHandler) {
259             return EurekaRegistration.builder(instanceConfig).with(applicationInfoManager)
260                     .with(eurekaClient).with(healthCheckHandler).build();
261         }
262 
263     }
264 
265     @Target({ ElementType.TYPE, ElementType.METHOD })
266     @Retention(RetentionPolicy.RUNTIME)
267     @Documented
268     @Conditional(OnMissingRefreshScopeCondition.class)
269     @interface ConditionalOnMissingRefreshScope {
270 
271     }
272 
273     @Target({ ElementType.TYPE, ElementType.METHOD })
274     @Retention(RetentionPolicy.RUNTIME)
275     @Documented
276     @ConditionalOnClass(RefreshScope.class)
277     @ConditionalOnBean(RefreshAutoConfiguration.class)
278     @ConditionalOnProperty(value = "eureka.client.refresh.enable", havingValue = "true",
279             matchIfMissing = true)
280     @interface ConditionalOnRefreshScope {
281 
282     }
283 
284     private static class OnMissingRefreshScopeCondition extends AnyNestedCondition {
285 
286         OnMissingRefreshScopeCondition() {
287             super(ConfigurationPhase.REGISTER_BEAN);
288         }
289 
290         @ConditionalOnMissingClass("org.springframework.cloud.context.scope.refresh.RefreshScope")
291         static class MissingClass {
292 
293         }
294 
295         @ConditionalOnMissingBean(RefreshAutoConfiguration.class)
296         static class MissingScope {
297 
298         }
299 
300         @ConditionalOnProperty(value = "eureka.client.refresh.enable",
301                 havingValue = "false")
302         static class OnPropertyDisabled {
303 
304         }
305 
306     }
307 
308     @Configuration(proxyBeanMethods = false)
309     @ConditionalOnClass(Health.class)
310     protected static class EurekaHealthIndicatorConfiguration {
311 
312         @Bean
313         @ConditionalOnMissingBean
314         @ConditionalOnEnabledHealthIndicator("eureka")
315         public EurekaHealthIndicator eurekaHealthIndicator(EurekaClient eurekaClient,
316                 EurekaInstanceConfig instanceConfig, EurekaClientConfig clientConfig) {
317             return new EurekaHealthIndicator(eurekaClient, instanceConfig, clientConfig);
318         }
319 
320     }
321 
322 }

 1 public void start() {
 2     // only set the port if the nonSecurePort or securePort is 0 and this.port != 0
 3     if (this.port.get() != 0) {
 4         if (this.registration.getNonSecurePort() == 0) {
 5             this.registration.setNonSecurePort(this.port.get());
 6         }
 7 
 8         if (this.registration.getSecurePort() == 0 && this.registration.isSecure()) {
 9             this.registration.setSecurePort(this.port.get());
10         }
11     }
12 
13     // only initialize if nonSecurePort is greater than 0 and it isn't already running
14     // because of containerPortInitializer below
15     if (!this.running.get() && this.registration.getNonSecurePort() > 0) {
16 
17         this.serviceRegistry.register(this.registration);
18 
19         this.context.publishEvent(new InstanceRegisteredEvent<>(this,
20                 this.registration.getInstanceConfig()));
21         this.running.set(true);
22     }
23 }