Adding health reports to microservices

 1<server description="Sample Liberty server">
 2
 3  <featureManager>
 4    <feature>jaxrs-2.1</feature>
 5    <feature>jsonp-1.1</feature>
 6    <feature>cdi-2.0</feature>
 7    <feature>mpConfig-1.3</feature>
 8    <feature>mpRestClient-1.3</feature>
 9    <feature>mpHealth-2.0</feature>
10  </featureManager>
11
12  <httpEndpoint host="*" httpPort="${default.http.port}"
13    httpsPort="${default.https.port}" id="defaultHttpEndpoint"/>
14
15  <webApplication location="microprofile-health.war" contextRoot="/"/>
16</server>

 1package it.io.openliberty.guides.health;
 2
 3import static org.junit.Assert.assertEquals;
 4import java.util.HashMap;
 5import javax.json.JsonArray;
 6import org.junit.After;
 7import org.junit.Before;
 8import org.junit.Test;
 9
10public class HealthTest {
11
12    private JsonArray servicesStates;
13    private static HashMap<String, String> endpointData;
14
15    private String HEALTH_ENDPOINT = "/health";
16    private String READINESS_ENDPOINT = "/health/ready";
17    private String LIVENES_ENDPOINT = "/health/live";
18
19    @Before
20    public void setup() {
21        endpointData = new HashMap<String, String>();
22    }
23
24    @Test
25    public void testIfServicesAreUp() {
26        endpointData.put("SystemResourceReadiness", "UP");
27        endpointData.put("SystemResourceLiveness", "UP");
28        endpointData.put("InventoryResourceReadiness", "UP");
29        endpointData.put("InventoryResourceLiveness", "UP");
30
31        servicesStates = HealthTestUtil.connectToHealthEnpoint(200, HEALTH_ENDPOINT);
32        checkStates(endpointData, servicesStates);
33    }
34
35    @Test
36    public void testReadiness() {
37        endpointData.put("SystemResourceReadiness", "UP");
38        endpointData.put("InventoryResourceReadiness", "UP");
39
40        servicesStates = HealthTestUtil.connectToHealthEnpoint(200, READINESS_ENDPOINT);
41        checkStates(endpointData, servicesStates);
42    }
43
44    @Test
45    public void testLiveness() {
46        endpointData.put("SystemResourceLiveness", "UP");
47        endpointData.put("InventoryResourceLiveness", "UP");
48
49        servicesStates = HealthTestUtil.connectToHealthEnpoint(200, LIVENES_ENDPOINT);
50        checkStates(endpointData, servicesStates);
51    }
52
53    @Test
54    public void testIfInventoryServiceIsDown() {
55        endpointData.put("SystemResourceReadiness", "UP");
56        endpointData.put("SystemResourceLiveness", "UP");
57        endpointData.put("InventoryResourceReadiness", "UP");
58        endpointData.put("InventoryResourceLiveness", "UP");
59
60        servicesStates = HealthTestUtil.connectToHealthEnpoint(200, HEALTH_ENDPOINT);
61        checkStates(endpointData, servicesStates);
62
63        endpointData.put("InventoryResourceReadiness", "DOWN");
64        HealthTestUtil.changeInventoryProperty(HealthTestUtil.INV_MAINTENANCE_FALSE,
65                                               HealthTestUtil.INV_MAINTENANCE_TRUE);
66        servicesStates = HealthTestUtil.connectToHealthEnpoint(503, HEALTH_ENDPOINT);
67        checkStates(endpointData, servicesStates);
68   }
69
70    private void checkStates(HashMap<String, String> testData, JsonArray servStates) {
71        testData.forEach((service, expectedState) -> {
72            assertEquals("The state of " + service + " service is not matching.",
73                         expectedState,
74                         HealthTestUtil.getActualState(service, servStates));
75        });
76    }
77
78    @After
79    public void teardown() {
80        HealthTestUtil.cleanUp();
81    }
82
83}

1{
2    "config_ordinal":700,
3    "io_openliberty_guides_inventory_inMaintenance":false
4}

  1package it.io.openliberty.guides.inventory;
  2
  3import static org.junit.Assert.assertEquals;
  4import static org.junit.Assert.assertTrue;
  5import javax.json.JsonObject;
  6import javax.ws.rs.client.Client;
  7import javax.ws.rs.client.ClientBuilder;
  8import javax.ws.rs.core.MediaType;
  9import javax.ws.rs.core.Response;
 10import org.apache.cxf.jaxrs.provider.jsrjsonp.JsrJsonpProvider;
 11import org.junit.After;
 12import org.junit.Before;
 13import org.junit.BeforeClass;
 14import org.junit.Test;
 15
 16public class InventoryEndpointTest {
 17
 18  private static String port;
 19  private static String baseUrl;
 20
 21  private Client client;
 22
 23  private final String SYSTEM_PROPERTIES = "system/properties";
 24  private final String INVENTORY_SYSTEMS = "inventory/systems";
 25
 26  @BeforeClass
 27  public static void oneTimeSetup() {
 28    port = System.getProperty("liberty.test.port");
 29    baseUrl = "http://localhost:" + port + "/";
 30  }
 31
 32  @Before
 33  public void setup() {
 34    client = ClientBuilder.newClient();
 35    client.register(JsrJsonpProvider.class);
 36  }
 37
 38  @After
 39  public void teardown() {
 40    client.close();
 41  }
 42
 43  @Test
 44  public void testSuite() {
 45    this.testEmptyInventory();
 46    this.testHostRegistration();
 47    this.testSystemPropertiesMatch();
 48    this.testUnknownHost();
 49  }
 50
 51  public void testEmptyInventory() {
 52    Response response = this.getResponse(baseUrl + INVENTORY_SYSTEMS);
 53    this.assertResponse(baseUrl, response);
 54
 55    JsonObject obj = response.readEntity(JsonObject.class);
 56
 57    int expected = 0;
 58    int actual = obj.getInt("total");
 59    assertEquals("The inventory should be empty on application start but it wasn't",
 60                 expected, actual);
 61
 62    response.close();
 63  }
 64
 65  public void testHostRegistration() {
 66    this.visitLocalhost();
 67
 68    Response response = this.getResponse(baseUrl + INVENTORY_SYSTEMS);
 69    this.assertResponse(baseUrl, response);
 70
 71    JsonObject obj = response.readEntity(JsonObject.class);
 72
 73    int expected = 1;
 74    int actual = obj.getInt("total");
 75    assertEquals("The inventory should have one entry for localhost", expected,
 76                 actual);
 77    boolean localhostExists = obj.getJsonArray("systems").getJsonObject(0)
 78                                 .get("hostname").toString()
 79                                 .contains("localhost");
 80    assertTrue("A host was registered, but it was not localhost",
 81               localhostExists);
 82
 83    response.close();
 84  }
 85
 86  public void testSystemPropertiesMatch() {
 87    Response invResponse = this.getResponse(baseUrl + INVENTORY_SYSTEMS);
 88    Response sysResponse = this.getResponse(baseUrl + SYSTEM_PROPERTIES);
 89
 90    this.assertResponse(baseUrl, invResponse);
 91    this.assertResponse(baseUrl, sysResponse);
 92
 93    JsonObject jsonFromInventory = (JsonObject) invResponse.readEntity(JsonObject.class)
 94                                                           .getJsonArray("systems")
 95                                                           .getJsonObject(0)
 96                                                           .get("properties");
 97
 98    JsonObject jsonFromSystem = sysResponse.readEntity(JsonObject.class);
 99
100    String osNameFromInventory = jsonFromInventory.getString("os.name");
101    String osNameFromSystem = jsonFromSystem.getString("os.name");
102    this.assertProperty("os.name", "localhost", osNameFromSystem,
103                        osNameFromInventory);
104
105    String userNameFromInventory = jsonFromInventory.getString("user.name");
106    String userNameFromSystem = jsonFromSystem.getString("user.name");
107    this.assertProperty("user.name", "localhost", userNameFromSystem,
108                        userNameFromInventory);
109
110    invResponse.close();
111    sysResponse.close();
112  }
113
114  public void testUnknownHost() {
115    Response response = this.getResponse(baseUrl + INVENTORY_SYSTEMS);
116    this.assertResponse(baseUrl, response);
117
118    Response badResponse = client.target(baseUrl + INVENTORY_SYSTEMS + "/"
119        + "badhostname").request(MediaType.APPLICATION_JSON).get();
120
121    String obj = badResponse.readEntity(String.class);
122
123    boolean isError = obj.contains("error");
124    assertTrue("badhostname is not a valid host but it didn't raise an error",
125               isError);
126
127    response.close();
128    badResponse.close();
129  }
130
131  /**
132   * <p>
133   * Returns response information from the specified URL.
134   * </p>
135   *
136   * @param url
137   *          - target URL.
138   * @return Response object with the response from the specified URL.
139   */
140  private Response getResponse(String url) {
141    return client.target(url).request().get();
142  }
143
144  /**
145   * <p>
146   * Asserts that the given URL has the correct response code of 200.
147   * </p>
148   *
149   * @param url
150   *          - target URL.
151   * @param response
152   *          - response received from the target URL.
153   */
154  private void assertResponse(String url, Response response) {
155    assertEquals("Incorrect response code from " + url, 200,
156                 response.getStatus());
157  }
158
159  /**
160   * Asserts that the specified JVM system property is equivalent in both the
161   * system and inventory services.
162   *
163   * @param propertyName
164   *          - name of the system property to check.
165   * @param hostname
166   *          - name of JVM's host.
167   * @param expected
168   *          - expected name.
169   * @param actual
170   *          - actual name.
171   */
172  private void assertProperty(String propertyName, String hostname,
173      String expected, String actual) {
174    assertEquals("JVM system property [" + propertyName + "] "
175        + "in the system service does not match the one stored in "
176        + "the inventory service for " + hostname, expected, actual);
177  }
178
179  /**
180   * Makes a simple GET request to inventory/localhost.
181   */
182  private void visitLocalhost() {
183    Response response = this.getResponse(baseUrl + SYSTEM_PROPERTIES);
184    this.assertResponse(baseUrl, response);
185    response.close();
186
187    Response targetResponse = client.target(baseUrl + INVENTORY_SYSTEMS
188        + "/localhost").request().get();
189    targetResponse.close();
190  }
191}

 1package it.io.openliberty.guides.system;
 2
 3import static org.junit.Assert.assertEquals;
 4import javax.json.JsonObject;
 5import javax.ws.rs.client.Client;
 6import javax.ws.rs.client.ClientBuilder;
 7import javax.ws.rs.client.WebTarget;
 8import javax.ws.rs.core.Response;
 9import org.apache.cxf.jaxrs.provider.jsrjsonp.JsrJsonpProvider;
10import org.junit.Test;
11
12public class SystemEndpointTest {
13
14  @Test
15  public void testGetProperties() {
16    String port = System.getProperty("liberty.test.port");
17    String url = "http://localhost:" + port + "/";
18
19    Client client = ClientBuilder.newClient();
20    client.register(JsrJsonpProvider.class);
21
22    WebTarget target = client.target(url + "system/properties");
23    Response response = target.request().get();
24
25    assertEquals("Incorrect response code from " + url, 200,
26                 response.getStatus());
27
28    JsonObject obj = response.readEntity(JsonObject.class);
29
30    assertEquals("The system property for the local and remote JVM should match",
31                 System.getProperty("os.name"), obj.getString("os.name"));
32
33    response.close();
34  }
35}