Aggregate info on the server

spring-boot-admin-server-ui/modules/applications/module.js

@@ -63,7 +63,7 @@ module.config(function ($stateProvider) {
   });
 });
 
-module.run(function ($rootScope, $state, Notification, Application, ApplicationGroups, MainViews, $timeout, $q) {
+module.run(function ($rootScope, $state, Notification, Application, ApplicationGroups, MainViews) {
   MainViews.register({
     title: 'Applications',
     state: 'applications-list',
@@ -73,62 +73,10 @@ module.run(function ($rootScope, $state, Notification, Application, ApplicationG
   var applicationGroups = new ApplicationGroups();
   $rootScope.applicationGroups = applicationGroups;
 
-  var refreshQueue = [];
-  var runningRefreshs = 0;
-
-  var queueRefresh = function (application) {
-    application.refreshing = true;
-    if (runningRefreshs++ >= 15) {
-      refreshQueue.push(application);
-    } else {
-      refresh(application);
-    }
-  };
-
-  var refresh = function (application) {
-    doRefresh(application).finally(function () {
-      application.refreshing = false;
-      runningRefreshs--;
-      if (refreshQueue.length > 0) {
-        refresh(refreshQueue.pop());
-      }
-    });
-  };
-
-  var doRefresh = function (application) {
-    application.info = {};
-    if (application.statusInfo.status === 'OFFLINE') {
-      return $q.reject();
-    }
-    return application.getInfo().then(function (response) {
-      var info = response.data;
-      application.version = info.version;
-      delete info.version;
-      if (info.build && info.build.version) {
-        application.version = info.build.version;
-      }
-      if (application.version) {
-        var group = application.group;
-        group.versionsCounter[application.version] = (group.versionsCounter[application.version] || 0) + 1;
-        var versions = Object.keys(group.versionsCounter);
-        versions.sort();
-        group.version = versions[0] + (versions.length > 1 ? ', ...' : '');
-      }
-      application.info = info;
-    });
-  };
-
   Application.query(function (applications) {
     applications.forEach(function (application) {
       applicationGroups.addApplication(application, true);
     });
-
-    //Defer refresh to give the browser time to render
-    $timeout(function () {
-      applicationGroups.applications.forEach(function (application) {
-        queueRefresh(application);
-      });
-    }, 50);
   });
 
   if (typeof (EventSource) !== 'undefined') {
@@ -148,14 +96,13 @@ module.run(function ($rootScope, $state, Notification, Application, ApplicationG
         body: 'Instance ' + event.application.id + '\n' + event.application.healthUrl,
         icon: require('./img/unknown.png'),
         timeout: 10000,
-        url: $state.href('apps.details', {
+        url: $state.href('applications.details', {
           id: event.application.id
         })
       };
 
       if (event.type === 'REGISTRATION') {
         applicationGroups.addApplication(event.application, false);
-        queueRefresh(event.application);
         title += ' instance registered.';
         options.tag = event.application.id + '-REGISTRY';
       } else if (event.type === 'DEREGISTRATION') {
@@ -164,7 +111,6 @@ module.run(function ($rootScope, $state, Notification, Application, ApplicationG
         options.tag = event.application.id + '-REGISTRY';
       } else if (event.type === 'STATUS_CHANGE') {
         applicationGroups.addApplication(event.application, true);
-        queueRefresh(event.application);
         title += ' instance is ' + event.to.status;
         options.tag = event.application.id + '-STATUS';
         options.icon = event.to.status !== 'UP' ? require('./img/error.png') : require('./img/ok.png');

spring-boot-admin-server-ui/modules/applications/services/applicationGroups.js

@@ -32,41 +32,55 @@ module.exports = function () {
       return 'UNKNOWN';
     };
 
+    var getGroupVersion = function (versionsCounter) {
+      var versions = Object.keys(versionsCounter);
+      versions.sort();
+      return versions[0] + (versions.length > 1 ? ', ...' : '');
+    };
+
     this.updateStatus = function (group) {
       var statusCounter = {};
+      var versionsCounter = {};
       var applicationCount = 0;
       this.applications.forEach(function (application) {
         if (application.name === group.name) {
           applicationCount++;
           statusCounter[application.statusInfo.status] = ++statusCounter[application.statusInfo.status] || 1;
+          var version = (application.info.build ? application.info.build.version : application.info.version);
+          if (version) {
+            versionsCounter[version] = ++versionsCounter[version] || 1;
+          }
         }
       });
       group.applicationCount = applicationCount;
       group.statusCounter = statusCounter;
       group.status = getMaxStatus(statusCounter);
+      group.version = getGroupVersion(versionsCounter);
     };
 
     this.addApplication = function (application, overwrite) {
       var idx = this.applications.findIndex(function (app) {
         return app.id === application.id;
       });
-      this.groups[application.name] = this.groups[application.name] || { applicationCount: 0, statusCounter: {}, versionsCounter: [], name: application.name, status: 'UNKNOWN' };
-      application.group = this.groups[application.name];
+      application.group = this.groups[application.name] || { applicationCount: 0, statusCounter: {}, name: application.name, status: 'UNKNOWN' };
+      this.groups[application.name] = application.group;
       if (idx < 0) {
         this.applications.push(application);
       } else if (overwrite) {
         this.applications.splice(idx, 1, application);
       }
-      this.updateStatus(this.groups[application.name]);
+      this.updateStatus(application.group);
     };
 
     this.removeApplication = function (id) {
       var idx = this.applications.findIndex(function (application) {
         return id === application.id;
       });
-      var group = this.applications[idx].group;
-      this.applications.splice(idx, 1);
-      this.updateStatus(group);
+      if (idx >= 0) {
+        var group = (this.applications[idx]).group;
+        this.applications.splice(idx, 1);
+        this.updateStatus(group);
+      }
     };
   };
 };

spring-boot-admin-server-ui/modules/applications/views/applications-list.html

@@ -15,7 +15,7 @@
         <th class="group-column" title="{{expandAll ? 'collapse' : 'expand'}} all" ng-click="toggleExpandAll()"><i class="fa" ng-class="{'fa-plus': !expandAll, 'fa-minus': expandAll}"></i></th>
         <th><span class="sortable" ng-class="orderByCssClass('name')" ng-click="orderBy('name')">Application</span> / <span class="sortable"
             ng-class="orderByCssClass('healthUrl')" ng-click="orderBy('healthUrl')">URL</span></th>
-        <th><span class="sortable" ng-class="orderByCssClass('info.version')" ng-click="orderBy('info.version')">Version</span></th>
+        <th><span class="sortable" ng-class="orderByCssClass('info.build.version')" ng-click="orderBy('info.build.version')">Version</span></th>
         <th>Info</th>
         <th>Status</th>
         <th></th>
@@ -39,8 +39,8 @@
           ng-click="application.group.collapsed = application.group.applicationCount > 1"><i ng-show="application.group.applicationCount > 1 &amp;&amp; (searchFilter == '' || searchFilter == undefined)"
             class="fa fa-minus"></i></td>
         <td>{{ application.name }} ({{ application.id }})<br/>
-          <span class="muted">{{ application.serviceUrl || application.managementUrl || application.healthUrl }}</span></td>
-        <td>{{ application.version }}</td>
+          <span class="muted" ng-bind="application.serviceUrl || application.managementUrl || application.healthUrl"></span></td>
+        <td ng-bind="application.info.build.version || application.info.version"></td>
         <td class="scroll">
           <sba-limited-text max-lines="3" bind-html="application.info | yaml | linkify:60"></sba-limited-text>
         </td>

spring-boot-admin-server/src/main/java/de/codecentric/boot/admin/config/AdminServerCoreConfiguration.java

@@ -36,6 +36,7 @@ import de.codecentric.boot.admin.registry.StatusUpdateApplicationListener;
 import de.codecentric.boot.admin.registry.StatusUpdater;
 import de.codecentric.boot.admin.registry.store.ApplicationStore;
 import de.codecentric.boot.admin.registry.store.SimpleApplicationStore;
+import de.codecentric.boot.admin.web.client.ApplicationOperations;
 import de.codecentric.boot.admin.web.client.BasicAuthHttpHeaderProvider;
 import de.codecentric.boot.admin.web.client.HttpHeadersProvider;
 
@@ -69,8 +70,8 @@ public class AdminServerCoreConfiguration {
 
 	@Bean
 	@ConditionalOnMissingBean
-	public StatusUpdater statusUpdater(RestTemplateBuilder restTemplBuilder,
-			ApplicationStore applicationStore) {
+	public ApplicationOperations applicationOperations(RestTemplateBuilder restTemplBuilder,
+			HttpHeadersProvider headersProvider) {
 		RestTemplateBuilder builder = restTemplBuilder
 				.messageConverters(new MappingJackson2HttpMessageConverter())
 				.errorHandler(new DefaultResponseErrorHandler() {
@@ -79,9 +80,15 @@ public class AdminServerCoreConfiguration {
 						return false;
 					}
 				});
+		return new ApplicationOperations(builder.build(), headersProvider);
+	};
 
-		StatusUpdater statusUpdater = new StatusUpdater(builder.build(), applicationStore,
-				httpHeadersProvider());
+	@Bean
+	@ConditionalOnMissingBean
+	public StatusUpdater statusUpdater(ApplicationStore applicationStore,
+			ApplicationOperations applicationOperations) {
+
+		StatusUpdater statusUpdater = new StatusUpdater(applicationStore, applicationOperations);
 		statusUpdater.setStatusLifetime(adminServerProperties.getMonitor().getStatusLifetime());
 		return statusUpdater;
 	}

spring-boot-admin-server/src/main/java/de/codecentric/boot/admin/model/Application.java

@@ -53,6 +53,7 @@ public class Application implements Serializable {
 	private final String source;
 	@JsonSerialize(using = Application.MetadataSerializer.class)
 	private final Map<String, String> metadata;
+	private final Info info;
 
 	protected Application(Builder builder) {
 		Assert.hasText(builder.name, "name must not be empty!");
@@ -66,6 +67,7 @@ public class Application implements Serializable {
 		this.statusInfo = builder.statusInfo;
 		this.source = builder.source;
 		this.metadata = Collections.unmodifiableMap(new HashMap<>(builder.metadata));
+		this.info = builder.info;
 	}
 
 	public static Builder create(String name) {
@@ -85,6 +87,7 @@ public class Application implements Serializable {
 		private StatusInfo statusInfo = StatusInfo.ofUnknown();
 		private String source;
 		private Map<String, String> metadata = new HashMap<>();
+		private Info info = Info.empty();
 
 		private Builder(String name) {
 			this.name = name;
@@ -99,6 +102,7 @@ public class Application implements Serializable {
 			this.statusInfo = application.statusInfo;
 			this.source = application.source;
 			this.metadata.putAll(application.getMetadata());
+			this.info = application.info;
 		}
 
 		public Builder withName(String name) {
@@ -136,13 +140,18 @@ public class Application implements Serializable {
 			return this;
 		}
 
-		public Builder withMetadata(String key, String value) {
+		public Builder addMetadata(String key, String value) {
 			this.metadata.put(key, value);
 			return this;
 		}
 
 		public Builder withMetadata(Map<String, String> metadata) {
-			this.metadata.putAll(metadata);
+			this.metadata = metadata;
+			return this;
+		}
+
+		public Builder withInfo(Info info) {
+			this.info = info;
 			return this;
 		}
 
@@ -182,6 +191,11 @@ public class Application implements Serializable {
 	public Map<String, String> getMetadata() {
 		return metadata;
 	}
+
+	public Info getInfo() {
+		return info;
+	}
+
 	@Override
 	public String toString() {
 		return "Application [id=" + id + ", name=" + name + ", managementUrl="
@@ -284,7 +298,7 @@ public class Application implements Serializable {
 				Iterator<Entry<String, JsonNode>> it = node.get("metadata").fields();
 				while (it.hasNext()) {
 					Entry<String, JsonNode> entry = it.next();
-					builder.withMetadata(entry.getKey(), entry.getValue().asText());
+					builder.addMetadata(entry.getKey(), entry.getValue().asText());
 				}
 			}
 			return builder.build();

spring-boot-admin-server/src/main/java/de/codecentric/boot/admin/model/Info.java

+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.codecentric.boot.admin.model;
+
+import static java.util.Collections.unmodifiableMap;
+
+import java.io.Serializable;
+import java.util.Collections;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import com.fasterxml.jackson.annotation.JsonAnyGetter;
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
+/**
+ * Represents the info fetched from the info actuator endpoint at a certain time.
+ * 
+ * @author Johannes Edmeier
+ */
+public class Info implements Serializable {
+	private static final long serialVersionUID = 2L;
+	private static Info EMPTY = new Info(0L, null);
+
+	@JsonIgnore
+	private final long timestamp;
+	private final Map<String, ? extends Serializable> values;
+
+	protected Info(long timestamp, Map<String, ? extends Serializable> values) {
+		this.timestamp = timestamp;
+		this.values = values != null ? unmodifiableMap(new LinkedHashMap<>(values))
+				: Collections.<String, Serializable>emptyMap();
+	}
+
+	public static Info from(Map<String, ? extends Serializable> values) {
+		return new Info(System.currentTimeMillis(), values);
+	}
+
+	public static Info empty() {
+		return EMPTY;
+	}
+
+	public long getTimestamp() {
+		return timestamp;
+	}
+
+	@JsonAnyGetter
+	public Map<String, ? extends Serializable> getValues() {
+		return values;
+	}
+
+	@Override
+	public String toString() {
+		return "Info [timestamp=" + timestamp + ", values=" + values + "]";
+	}
+
+}

spring-boot-admin-server/src/main/java/de/codecentric/boot/admin/model/StatusInfo.java

+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package de.codecentric.boot.admin.model;
 
 import java.io.Serializable;
@@ -5,6 +20,8 @@ import java.util.Collections;
 import java.util.HashMap;
 import java.util.Map;
 
+import com.fasterxml.jackson.annotation.JsonIgnore;
+
 /**
  * Represents a certain status a certain time.
  *
@@ -30,6 +47,10 @@ public class StatusInfo implements Serializable {
 		return new StatusInfo(statusCode, System.currentTimeMillis(), details);
 	}
 
+	public static StatusInfo valueOf(String statusCode) {
+		return valueOf(statusCode, null);
+	}
+
 	public static StatusInfo ofUnknown() {
 		return valueOf("UNKNOWN", null);
 	}
@@ -70,6 +91,26 @@ public class StatusInfo implements Serializable {
 		return details;
 	}
 
+	@JsonIgnore
+	public boolean isUp() {
+		return "UP".equals(status);
+	}
+
+	@JsonIgnore
+	public boolean isOffline() {
+		return "OFFLINE".equals(status);
+	}
+
+	@JsonIgnore
+	public boolean isDown() {
+		return "DOWN".equals(status);
+	}
+
+	@JsonIgnore
+	public boolean isUnknown() {
+		return "UNKNOWN".equals(status);
+	}
+
 	@Override
 	public int hashCode() {
 		final int prime = 31;
@@ -100,4 +141,9 @@ public class StatusInfo implements Serializable {
 		return true;
 	}
 
+	@Override
+	public String toString() {
+		return "StatusInfo [status=" + status + ", timestamp=" + timestamp + "]";
+	}
+
 }
\ No newline at end of file

spring-boot-admin-server/src/main/java/de/codecentric/boot/admin/registry/ApplicationRegistry.java

@@ -29,7 +29,6 @@ import org.springframework.util.StringUtils;
 import de.codecentric.boot.admin.event.ClientApplicationDeregisteredEvent;
 import de.codecentric.boot.admin.event.ClientApplicationRegisteredEvent;
 import de.codecentric.boot.admin.model.Application;
-import de.codecentric.boot.admin.model.StatusInfo;
 import de.codecentric.boot.admin.registry.store.ApplicationStore;
 
 /**
@@ -70,13 +69,15 @@ public class ApplicationRegistry implements ApplicationEventPublisherAware {
 		String applicationId = generator.generateId(application);
 		Assert.notNull(applicationId, "ID must not be null");
 
-		StatusInfo existingStatusInfo = getExistingStatusInfo(applicationId);
-
-		Application registering = Application.copyOf(application).withId(applicationId)
-				.withStatusInfo(existingStatusInfo).build();
+		Application.Builder builder = Application.copyOf(application).withId(applicationId);
+		Application existing = getApplication(applicationId);
+		if (existing != null) {
+			// Copy Status and Info from existing registration.
+			builder.withStatusInfo(existing.getStatusInfo()).withInfo(existing.getInfo());
+		}
+		Application registering = builder.build();
 
 		Application replaced = store.save(registering);
-
 		if (replaced == null) {
 			LOGGER.info("New Application {} registered ", registering);
 			publisher.publishEvent(new ClientApplicationRegisteredEvent(registering));
@@ -90,13 +91,6 @@ public class ApplicationRegistry implements ApplicationEventPublisherAware {
 		return registering;
 	}
 
-	private StatusInfo getExistingStatusInfo(String applicationId) {
-		Application existing = getApplication(applicationId);
-		if (existing != null) {
-			return existing.getStatusInfo();
-		}
-		return StatusInfo.ofUnknown();
-	}
 
 	/**
 	 * Checks the syntax of the given URL.

spring-boot-admin-server/src/main/java/de/codecentric/boot/admin/registry/StatusUpdater.java

@@ -15,8 +15,6 @@
  */
 package de.codecentric.boot.admin.registry;
 
-import static java.util.Arrays.asList;
-
 import java.io.Serializable;
 import java.util.HashMap;
 import java.util.Map;
@@ -25,18 +23,14 @@ import org.slf4j.Logger;
 import org.slf4j.LoggerFactory;
 import org.springframework.context.ApplicationEventPublisher;
 import org.springframework.context.ApplicationEventPublisherAware;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
-import org.springframework.http.MediaType;
 import org.springframework.http.ResponseEntity;
-import org.springframework.web.client.RestTemplate;
 
 import de.codecentric.boot.admin.event.ClientApplicationStatusChangedEvent;
 import de.codecentric.boot.admin.model.Application;
+import de.codecentric.boot.admin.model.Info;
 import de.codecentric.boot.admin.model.StatusInfo;
 import de.codecentric.boot.admin.registry.store.ApplicationStore;
-import de.codecentric.boot.admin.web.client.HttpHeadersProvider;
+import de.codecentric.boot.admin.web.client.ApplicationOperations;
 
 /**
  * The StatusUpdater is responsible for updating the status of all or a single application querying
@@ -48,16 +42,13 @@ public class StatusUpdater implements ApplicationEventPublisherAware {
 	private static final Logger LOGGER = LoggerFactory.getLogger(StatusUpdater.class);
 
 	private final ApplicationStore store;
-	private final RestTemplate restTemplate;
-	private final HttpHeadersProvider httpHeadersProvider;
+	private final ApplicationOperations applicationOps;
 	private ApplicationEventPublisher publisher;
 	private long statusLifetime = 10_000L;
 
-	public StatusUpdater(RestTemplate restTemplate, ApplicationStore store,
-			HttpHeadersProvider httpHeadersProvider) {
-		this.restTemplate = restTemplate;
+	public StatusUpdater(ApplicationStore store, ApplicationOperations applicationOps) {
 		this.store = store;
-		this.httpHeadersProvider = httpHeadersProvider;
+		this.applicationOps = applicationOps;
 	}
 
 	public void updateStatusForAllApplications() {
@@ -72,22 +63,45 @@ public class StatusUpdater implements ApplicationEventPublisherAware {
 	public void updateStatus(Application application) {
 		StatusInfo oldStatus = application.getStatusInfo();
 		StatusInfo newStatus = queryStatus(application);
+		boolean statusChanged = !newStatus.equals(oldStatus);
+
+		Application.Builder builder = Application.copyOf(application).withStatusInfo(newStatus);
 
-		Application newState = Application.copyOf(application).withStatusInfo(newStatus).build();
+		if (statusChanged && !newStatus.isOffline() && !newStatus.isUnknown()) {
+			builder.withInfo(queryInfo(application));
+		}
+
+		Application newState = builder.build();
 		store.save(newState);
 
-		if (!newStatus.equals(oldStatus)) {
+		if (statusChanged) {
 			publisher.publishEvent(
 					new ClientApplicationStatusChangedEvent(newState, oldStatus, newStatus));
 		}
 	}
 
+	private Info queryInfo(Application application) {
+		try {
+			ResponseEntity<Map<String, Serializable>> response = applicationOps
+					.getInfo(application);
+			if (response.getStatusCode().is2xxSuccessful() && response.hasBody()) {
+				return Info.from(response.getBody());
+			} else {
+				LOGGER.info("Couldn't retrieve info for {}: {} - {}", application,
+						response.getStatusCode(), response.getBody());
+				return Info.empty();
+			}
+		} catch (Exception ex) {
+			LOGGER.warn("Couldn't retrieve info for {}", application, ex);
+			return Info.empty();
+		}
+	}
+
 	protected StatusInfo queryStatus(Application application) {
 		LOGGER.trace("Updating status for {}", application);
-
 		try {
-			ResponseEntity<Map<String, Serializable>> response = doGetStatus(application);
-
+			ResponseEntity<Map<String, Serializable>> response = applicationOps
+					.getHealth(application);
 			if (response.hasBody() && response.getBody().get("status") instanceof String) {
 				return StatusInfo.valueOf((String) response.getBody().get("status"),
 						response.getBody());
@@ -100,28 +114,12 @@ public class StatusUpdater implements ApplicationEventPublisherAware {
 			if ("OFFLINE".equals(application.getStatusInfo().getStatus())) {
 				LOGGER.debug("Couldn't retrieve status for {}", application, ex);
 			} else {
-				LOGGER.warn("Couldn't retrieve status for {}", application, ex);
+				LOGGER.info("Couldn't retrieve status for {}", application, ex);
 			}
 			return StatusInfo.ofOffline(toDetails(ex));
 		}
 	}
 
-	private ResponseEntity<Map<String, Serializable>> doGetStatus(Application application) {
-		@SuppressWarnings("unchecked")
-		Class<Map<String, Serializable>> responseType = (Class<Map<String, Serializable>>) (Class<?>) Map.class;
-
-		HttpHeaders headers = new HttpHeaders();
-		headers.setAccept(asList(MediaType.APPLICATION_JSON));
-		headers.putAll(httpHeadersProvider.getHeaders(application));
-
-		ResponseEntity<Map<String, Serializable>> response = restTemplate.exchange(
-				application.getHealthUrl(), HttpMethod.GET, new HttpEntity<Void>(headers),
-				responseType);
-
-		LOGGER.debug("/health for {} responded with {}", application, response);
-		return response;
-	}
-
 	protected Map<String, Serializable> toDetails(Exception ex) {
 		Map<String, Serializable> details = new HashMap<>();
 		details.put("message", ex.getMessage());
@@ -141,5 +139,4 @@ public class StatusUpdater implements ApplicationEventPublisherAware {
 	public void setApplicationEventPublisher(ApplicationEventPublisher publisher) {
 		this.publisher = publisher;
 	}
-
 }

spring-boot-admin-server/src/main/java/de/codecentric/boot/admin/web/client/ApplicationOperations.java

+/*
+ * Copyright 2016 the original author or authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package de.codecentric.boot.admin.web.client;
+
+import static java.util.Arrays.asList;
+
+import java.io.Serializable;
+import java.net.URI;
+import java.util.Map;
+
+import org.slf4j.Logger;
+import org.slf4j.LoggerFactory;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.MediaType;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+import org.springframework.web.util.UriComponentsBuilder;
+
+import de.codecentric.boot.admin.model.Application;
+
+/**
+ * Handles all rest operations invoked on a registered application.
+ *
+ * @author Johannes Edmeier
+ */
+public class ApplicationOperations {
+	private static final Logger LOGGER = LoggerFactory.getLogger(ApplicationOperations.class);
+	@SuppressWarnings("unchecked")
+	private static final Class<Map<String, Serializable>> RESPONSE_TYPE_MAP = (Class<Map<String, Serializable>>) (Class<?>) Map.class;
+	private final RestTemplate restTemplate;
+	private final HttpHeadersProvider httpHeadersProvider;
+
+	public ApplicationOperations(RestTemplate restTemplate,
+			HttpHeadersProvider httpHeadersProvider) {
+		this.restTemplate = restTemplate;
+		this.httpHeadersProvider = httpHeadersProvider;
+	}
+
+	public ResponseEntity<Map<String, Serializable>> getInfo(
+			Application application) {
+		URI uri = UriComponentsBuilder.fromHttpUrl(application.getManagementUrl())
+				.pathSegment("info").build().toUri();
+		return doGet(application, uri, RESPONSE_TYPE_MAP);
+	}
+
+	public ResponseEntity<Map<String, Serializable>> getHealth(
+			Application application) {
+		URI uri = UriComponentsBuilder.fromHttpUrl(application.getHealthUrl()).build().toUri();
+		return doGet(application, uri, RESPONSE_TYPE_MAP);
+	}
+
+	protected <T> ResponseEntity<T> doGet(Application application, URI uri, Class<T> responseType) {
+		LOGGER.debug("Fetching '{}' for {}", uri, application);
+
+		HttpHeaders headers = new HttpHeaders();
+		headers.setAccept(asList(MediaType.APPLICATION_JSON));
+		headers.putAll(httpHeadersProvider.getHeaders(application));
+
+		ResponseEntity<T> response = restTemplate.exchange(uri, HttpMethod.GET,
+				new HttpEntity<Void>(headers), responseType);
+
+		LOGGER.debug("'{}' responded with {}", uri, response);
+		return response;
+	}
+}

spring-boot-admin-server/src/test/java/de/codecentric/boot/admin/model/ApplicationTest.java

@@ -82,7 +82,7 @@ public class ApplicationTest {
 	@Test
 	public void test_sanitize_metadata() throws JsonProcessingException {
 		Application app = Application.create("test").withHealthUrl("http://health")
-				.withMetadata("password", "qwertz123").withMetadata("user", "humptydumpty").build();
+				.addMetadata("password", "qwertz123").addMetadata("user", "humptydumpty").build();
 		String json = objectMapper.writeValueAsString(app);
 		assertThat(json, not(containsString("qwertz123")));
 		assertThat(json, containsString("humptydumpty"));

spring-boot-admin-server/src/test/java/de/codecentric/boot/admin/model/InfoTest.java

+package de.codecentric.boot.admin.model;
+
+import static org.assertj.core.api.Assertions.assertThat;
+
+import java.util.Collections;
+import java.util.Iterator;
+import java.util.LinkedHashMap;
+import java.util.Map;
+
+import org.junit.Test;
+import org.springframework.http.converter.json.Jackson2ObjectMapperBuilder;
+
+import com.fasterxml.jackson.databind.ObjectMapper;
+import com.jayway.jsonpath.DocumentContext;
+import com.jayway.jsonpath.JsonPath;
+
+public class InfoTest {
+	private ObjectMapper objectMapper = Jackson2ObjectMapperBuilder.json().build();
+
+	@Test
+	public void test_json_serialize() throws Exception {
+		Info info = Info.from(Collections.singletonMap("foo", "bar"));
+		String json = objectMapper.writeValueAsString(info);
+
+		DocumentContext doc = JsonPath.parse(json);
+
+		assertThat(doc.read("$.foo", String.class)).isEqualTo("bar");
+	}
+
+	@Test
+	public void test_retain_order() {
+		Map<String, String> map = new LinkedHashMap<>();
+		map.put("z", "1");
+		map.put("x", "2");
+
+		Iterator<?> iter = Info.from(map).getValues().entrySet().iterator();
+
+		assertThat(iter.next()).hasFieldOrPropertyWithValue("key", "z")
+				.hasFieldOrPropertyWithValue("value", "1");
+		assertThat(iter.next()).hasFieldOrPropertyWithValue("key", "x")
+				.hasFieldOrPropertyWithValue("value", "2");
+	}
+
+}

spring-boot-admin-server/src/test/java/de/codecentric/boot/admin/model/StatusInfoTest.java

@@ -19,4 +19,33 @@ public class StatusInfoTest {
 		assertThat(up.hashCode(), is(up2.hashCode()));
 	}
 
+	@Test
+	public void test_isMethods() {
+
+		assertThat(StatusInfo.valueOf("FOO").isUp(), is(false));
+		assertThat(StatusInfo.valueOf("FOO").isDown(), is(false));
+		assertThat(StatusInfo.valueOf("FOO").isUnknown(), is(false));
+		assertThat(StatusInfo.valueOf("FOO").isOffline(), is(false));
+
+		assertThat(StatusInfo.ofUp().isUp(), is(true));
+		assertThat(StatusInfo.ofUp().isDown(), is(false));
+		assertThat(StatusInfo.ofUp().isUnknown(), is(false));
+		assertThat(StatusInfo.ofUp().isOffline(), is(false));
+
+		assertThat(StatusInfo.ofDown().isUp(), is(false));
+		assertThat(StatusInfo.ofDown().isDown(), is(true));
+		assertThat(StatusInfo.ofDown().isUnknown(), is(false));
+		assertThat(StatusInfo.ofDown().isOffline(), is(false));
+
+		assertThat(StatusInfo.ofUnknown().isUp(), is(false));
+		assertThat(StatusInfo.ofUnknown().isDown(), is(false));
+		assertThat(StatusInfo.ofUnknown().isUnknown(), is(true));
+		assertThat(StatusInfo.ofUnknown().isOffline(), is(false));
+
+		assertThat(StatusInfo.ofOffline().isUp(), is(false));
+		assertThat(StatusInfo.ofOffline().isDown(), is(false));
+		assertThat(StatusInfo.ofOffline().isUnknown(), is(false));
+		assertThat(StatusInfo.ofOffline().isOffline(), is(true));
+	}
+
 }
\ No newline at end of file

spring-boot-admin-server/src/test/java/de/codecentric/boot/admin/registry/ApplicationRegistryTest.java

@@ -15,9 +15,12 @@
  */
 package de.codecentric.boot.admin.registry;
 
+import static java.util.Collections.singletonMap;
+import static org.hamcrest.Matchers.sameInstance;
 import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertFalse;
 import static org.junit.Assert.assertNotNull;
+import static org.junit.Assert.assertThat;
 import static org.junit.Assert.assertTrue;
 
 import java.util.Collection;
@@ -27,12 +30,15 @@ import org.mockito.Mockito;
 import org.springframework.context.ApplicationEventPublisher;
 
 import de.codecentric.boot.admin.model.Application;
+import de.codecentric.boot.admin.model.Info;
+import de.codecentric.boot.admin.model.StatusInfo;
+import de.codecentric.boot.admin.registry.store.ApplicationStore;
 import de.codecentric.boot.admin.registry.store.SimpleApplicationStore;
 
 public class ApplicationRegistryTest {
-
-	private ApplicationRegistry registry = new ApplicationRegistry(new SimpleApplicationStore(),
-			new HashingApplicationUrlIdGenerator());
+	private ApplicationStore store = new SimpleApplicationStore();
+	private ApplicationIdGenerator idGenerator = new HashingApplicationUrlIdGenerator();
+	private ApplicationRegistry registry = new ApplicationRegistry(store, idGenerator);
 
 	public ApplicationRegistryTest() {
 		registry.setApplicationEventPublisher(Mockito.mock(ApplicationEventPublisher.class));
@@ -81,6 +87,25 @@ public class ApplicationRegistryTest {
 	}
 
 	@Test
+	public void refresh() throws Exception {
+		// Given application is already reegistered and has status and info.
+		StatusInfo status = StatusInfo.ofUp();
+		Info info = Info.from(singletonMap("foo", "bar"));
+		Application app = Application.create("abc").withHealthUrl("http://localhost:8080/health")
+				.withStatusInfo(status).withInfo(info).build();
+		String id = idGenerator.generateId(app);
+		store.save(Application.copyOf(app).withId(id).build());
+
+		// When application registers second time
+		Application registered = registry.register(
+				Application.create("abc").withHealthUrl("http://localhost:8080/health").build());
+
+		// Then info and status are retained
+		assertThat(registered.getInfo(), sameInstance(info));
+		assertThat(registered.getStatusInfo(), sameInstance(status));
+	}
+
+	@Test
 	public void getApplication() throws Exception {
 		Application app = registry.register(Application.create("abc")
 				.withHealthUrl("http://localhost/health")

spring-boot-admin-server/src/test/java/de/codecentric/boot/admin/registry/StatusUpdaterTest.java

@@ -15,6 +15,7 @@
  */
 package de.codecentric.boot.admin.registry;
 
+import static org.hamcrest.Matchers.hasEntry;
 import static org.junit.Assert.assertThat;
 import static org.mockito.Matchers.any;
 import static org.mockito.Matchers.argThat;
@@ -25,6 +26,7 @@ import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
+import java.io.Serializable;
 import java.util.Collections;
 import java.util.Map;
 
@@ -32,44 +34,37 @@ import org.hamcrest.CoreMatchers;
 import org.junit.Before;
 import org.junit.Test;
 import org.springframework.context.ApplicationEventPublisher;
-import org.springframework.http.HttpEntity;
-import org.springframework.http.HttpHeaders;
-import org.springframework.http.HttpMethod;
 import org.springframework.http.ResponseEntity;
 import org.springframework.web.client.ResourceAccessException;
-import org.springframework.web.client.RestTemplate;
 
 import de.codecentric.boot.admin.event.ClientApplicationStatusChangedEvent;
 import de.codecentric.boot.admin.model.Application;
 import de.codecentric.boot.admin.model.StatusInfo;
 import de.codecentric.boot.admin.registry.store.SimpleApplicationStore;
-import de.codecentric.boot.admin.web.client.HttpHeadersProvider;
+import de.codecentric.boot.admin.web.client.ApplicationOperations;
 
 public class StatusUpdaterTest {
 
+	private ApplicationOperations applicationOps;
 	private StatusUpdater updater;
 	private SimpleApplicationStore store;
-	private RestTemplate template;
 	private ApplicationEventPublisher publisher;
 
 	@Before
 	public void setup() {
-		HttpHeadersProvider httpHeadersProvider = mock(HttpHeadersProvider.class);
-		when(httpHeadersProvider.getHeaders(any(Application.class))).thenReturn(new HttpHeaders());
-
 		store = new SimpleApplicationStore();
-		template = mock(RestTemplate.class);
-		updater = new StatusUpdater(template, store, httpHeadersProvider);
+		applicationOps = mock(ApplicationOperations.class);
+		updater = new StatusUpdater(store, applicationOps);
 		publisher = mock(ApplicationEventPublisher.class);
 		updater.setApplicationEventPublisher(publisher);
 	}
 
 	@Test
-	@SuppressWarnings("rawtypes")
 	public void test_update_statusChanged() {
-		when(template.exchange(eq("health"), eq(HttpMethod.GET), isA(HttpEntity.class),
-				eq(Map.class))).thenReturn(
-						ResponseEntity.ok().body((Map) Collections.singletonMap("status", "UP")));
+		when(applicationOps.getHealth(isA(Application.class))).thenReturn(ResponseEntity.ok()
+				.body(Collections.<String, Serializable>singletonMap("status", "UP")));
+		when(applicationOps.getInfo(isA(Application.class))).thenReturn(ResponseEntity.ok()
+				.body(Collections.<String, Serializable>singletonMap("foo", "bar")));
 
 		updater.updateStatus(
 				Application.create("foo").withId("id").withHealthUrl("health").build());
@@ -77,30 +72,30 @@ public class StatusUpdaterTest {
 		Application app = store.find("id");
 
 		assertThat(app.getStatusInfo().getStatus(), CoreMatchers.is("UP"));
+		assertThat((Map<String, ? extends Serializable>) app.getInfo().getValues(),
+				hasEntry("foo", (Serializable) "bar"));
 		verify(publisher)
 				.publishEvent(argThat(CoreMatchers.isA(ClientApplicationStatusChangedEvent.class)));
 	}
 
 	@Test
-	@SuppressWarnings("rawtypes")
 	public void test_update_statusUnchanged() {
-		when(template.exchange(eq("health"), eq(HttpMethod.GET), isA(HttpEntity.class),
-				eq(Map.class))).thenReturn(
-						ResponseEntity.ok((Map) Collections.singletonMap("status", "UNKNOWN")));
+		when(applicationOps.getHealth(any(Application.class))).thenReturn(ResponseEntity
+				.ok(Collections.<String, Serializable>singletonMap("status", "UNKNOWN")));
 
 		updater.updateStatus(
 				Application.create("foo").withId("id").withHealthUrl("health").build());
 
 		verify(publisher, never())
 				.publishEvent(argThat(CoreMatchers.isA(ClientApplicationStatusChangedEvent.class)));
+		verify(applicationOps, never()).getInfo(isA(Application.class));
 	}
 
 	@Test
-	@SuppressWarnings("rawtypes")
 	public void test_update_noBody() {
 		// HTTP 200 - UP
-		when(template.exchange(eq("health"), eq(HttpMethod.GET), isA(HttpEntity.class),
-				eq(Map.class))).thenReturn(ResponseEntity.ok((Map) null));
+		when(applicationOps.getHealth(any(Application.class)))
+				.thenReturn(ResponseEntity.ok((Map<String, Serializable>) null));
 
 		updater.updateStatus(
 				Application.create("foo").withId("id").withHealthUrl("health").build());
@@ -108,8 +103,8 @@ public class StatusUpdaterTest {
 		assertThat(store.find("id").getStatusInfo().getStatus(), CoreMatchers.is("UP"));
 
 		// HTTP != 200 - DOWN
-		when(template.exchange(eq("health"), eq(HttpMethod.GET), isA(HttpEntity.class),
-				eq(Map.class))).thenReturn(ResponseEntity.status(503).body((Map) null));
+		when(applicationOps.getHealth(any(Application.class)))
+				.thenReturn(ResponseEntity.status(503).body((Map<String, Serializable>) null));
 
 		updater.updateStatus(
 				Application.create("foo").withId("id").withHealthUrl("health").build());
@@ -119,8 +114,8 @@ public class StatusUpdaterTest {
 
 	@Test
 	public void test_update_offline() {
-		when(template.exchange(eq("health"), eq(HttpMethod.GET), isA(HttpEntity.class),
-				eq(Map.class))).thenThrow(new ResourceAccessException("error"));
+		when(applicationOps.getHealth(any(Application.class)))
+				.thenThrow(new ResourceAccessException("error"));
 
 		Application app = Application.create("foo").withId("id").withHealthUrl("health")
 				.withStatusInfo(StatusInfo.ofUp()).build();
@@ -130,21 +125,23 @@ public class StatusUpdaterTest {
 	}
 
 	@Test
-	@SuppressWarnings("rawtypes")
 	public void test_updateStatusForApplications() throws InterruptedException {
 		updater.setStatusLifetime(100L);
-		store.save(Application.create("foo").withId("id-1").withHealthUrl("health-1").build());
+		Application app1 = Application.create("foo").withId("id-1").withHealthUrl("health-1")
+				.build();
+		store.save(app1);
 		Thread.sleep(120L); // Let the StatusInfo of id-1 expire
-		store.save(Application.create("foo").withId("id-2").withHealthUrl("health-2").build());
+		Application app2 = Application.create("foo").withId("id-2").withHealthUrl("health-2")
+				.build();
+		store.save(app2);
 
-		when(template.exchange(eq("health-1"), eq(HttpMethod.GET), isA(HttpEntity.class),
-				eq(Map.class))).thenReturn(ResponseEntity.ok((Map) null));
+		when(applicationOps.getHealth(eq(app1)))
+				.thenReturn(ResponseEntity.ok((Map<String, Serializable>) null));
 
 		updater.updateStatusForAllApplications();
 
 		assertThat(store.find("id-1").getStatusInfo().getStatus(), CoreMatchers.is("UP"));
-		verify(template, never()).exchange(eq("health-2"), eq(HttpMethod.GET),
-				isA(HttpEntity.class), eq(Map.class));
+		verify(applicationOps, never()).getHealth(eq(app2));
 	}
 
 }

spring-boot-admin-server/src/test/java/de/codecentric/boot/admin/web/client/ApplicationOperationsTest.java

+package de.codecentric.boot.admin.web.client;
+
+import static java.util.Arrays.asList;
+import static java.util.Collections.singletonMap;
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.mockito.Matchers.eq;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import java.io.Serializable;
+import java.net.URI;
+import java.util.Map;
+
+import org.junit.Test;
+import org.mockito.ArgumentCaptor;
+import org.springframework.http.HttpEntity;
+import org.springframework.http.HttpHeaders;
+import org.springframework.http.HttpMethod;
+import org.springframework.http.ResponseEntity;
+import org.springframework.web.client.RestTemplate;
+
+import de.codecentric.boot.admin.model.Application;
+
+public class ApplicationOperationsTest {
+
+	private RestTemplate restTemplate = mock(RestTemplate.class);
+	private HttpHeadersProvider headersProvider = mock(HttpHeadersProvider.class);
+	private ApplicationOperations ops = new ApplicationOperations(restTemplate, headersProvider);
+
+	@Test
+	@SuppressWarnings("rawtypes")
+	public void test_getInfo() {
+		Application app = Application.create("test").withHealthUrl("http://health")
+				.withManagementUrl("http://mgmt").build();
+		ArgumentCaptor<HttpEntity> requestEntity = ArgumentCaptor.forClass(HttpEntity.class);
+
+		HttpHeaders headers = new HttpHeaders();
+		headers.add("auth", "foo:bar");
+		when(headersProvider.getHeaders(eq(app))).thenReturn(headers);
+
+		when(restTemplate.exchange(eq(URI.create("http://mgmt/info")), eq(HttpMethod.GET),
+				requestEntity.capture(), eq(Map.class)))
+						.thenReturn(ResponseEntity.ok().body((Map) singletonMap("foo", "bar")));
+
+		ResponseEntity<Map<String, Serializable>> response = ops.getInfo(app);
+
+		assertThat(response.getBody()).containsEntry("foo", "bar");
+		assertThat(requestEntity.getValue().getHeaders()).containsEntry("auth", asList("foo:bar"));
+	}
+
+	@Test
+	@SuppressWarnings("rawtypes")
+	public void test_getHealth() {
+		Application app = Application.create("test").withHealthUrl("http://health")
+				.withManagementUrl("http://mgmt").build();
+		ArgumentCaptor<HttpEntity> requestEntity = ArgumentCaptor.forClass(HttpEntity.class);
+
+		HttpHeaders headers = new HttpHeaders();
+		headers.add("auth", "foo:bar");
+		when(headersProvider.getHeaders(eq(app))).thenReturn(headers);
+
+		when(restTemplate.exchange(eq(URI.create("http://health")), eq(HttpMethod.GET),
+				requestEntity.capture(), eq(Map.class)))
+						.thenReturn(ResponseEntity.ok().body((Map) singletonMap("foo", "bar")));
+
+		ResponseEntity<Map<String, Serializable>> response = ops.getHealth(app);
+
+		assertThat(response.getBody()).containsEntry("foo", "bar");
+		assertThat(requestEntity.getValue().getHeaders()).containsEntry("auth", asList("foo:bar"));
+	}
+
+}

spring-boot-admin-server/src/test/java/de/codecentric/boot/admin/web/client/BasicAuthHttpHeaderProviderTest.java

@@ -16,7 +16,7 @@ public class BasicAuthHttpHeaderProviderTest {
 	@Test
 	public void test_auth_header() {
 		Application app = Application.create("test").withHealthUrl("/health")
-				.withMetadata("user.name", "test").withMetadata("user.password", "drowssap")
+				.addMetadata("user.name", "test").addMetadata("user.password", "drowssap")
 				.build();
 		assertThat(headersProvider.getHeaders(app).get(HttpHeaders.AUTHORIZATION).get(0),
 				is("Basic dGVzdDpkcm93c3NhcA=="));