private String name;
private String host;
private int port;
- private long started;
+ private long startedAt;
/**
* Required for Serialization
this.name = builder.name;
this.host = builder.host;
this.port = builder.port;
- this.started = builder.started;
+ this.startedAt = builder.startedAt;
}
public static Builder newNodeDetailsBuilder() {
return port;
}
- public long getStarted() {
- return started;
+ public long getStartedAt() {
+ return startedAt;
}
@Override
", name='" + name + '\'' +
", host='" + host + '\'' +
", port=" + port +
- ", started=" + started +
+ ", startedAt=" + startedAt +
'}';
}
out.writeUTF(name);
out.writeUTF(host);
out.writeInt(port);
- out.writeLong(started);
+ out.writeLong(startedAt);
}
@Override
this.name = in.readUTF();
this.host = in.readUTF();
this.port = in.readInt();
- this.started = in.readLong();
+ this.startedAt = in.readLong();
}
@Override
}
NodeDetails that = (NodeDetails) o;
return port == that.port &&
- started == that.started &&
+ startedAt == that.startedAt &&
type == that.type &&
name.equals(that.name) &&
host.equals(that.host);
@Override
public int hashCode() {
- return Objects.hash(type, name, host, port, started);
+ return Objects.hash(type, name, host, port, startedAt);
}
public static class Builder {
private String name;
private String host;
private int port;
- private long started;
+ private long startedAt;
private Builder() {
// use static factory method
return this;
}
- public Builder setStarted(long started) {
- checkStarted(started);
- this.started = started;
+ public Builder setStartedAt(long startedAt) {
+ checkStartedAt(startedAt);
+ this.startedAt = startedAt;
return this;
}
checkString(name, "name");
checkString(host, "host");
checkPort(port);
- checkStarted(started);
+ checkStartedAt(startedAt);
return new NodeDetails(this);
}
checkArgument(port > 0, "port must be > 0");
}
- private static void checkStarted(long started) {
- checkArgument(started > 0, "started must be > 0");
+ private static void checkStartedAt(long startedAt) {
+ checkArgument(startedAt > 0, "startedAt must be > 0");
}
}
@Test
public void setStarted_throws_IAE_if_arg_is_less_than_1() {
expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("started must be > 0");
+ expectedException.expectMessage("startedAt must be > 0");
- builderUnderTest.setStarted(-random.nextInt(5));
+ builderUnderTest.setStartedAt(-random.nextInt(5));
}
@Test
.setPort(1 + random.nextInt(33));
expectedException.expect(IllegalArgumentException.class);
- expectedException.expectMessage("started must be > 0");
+ expectedException.expectMessage("startedAt must be > 0");
builderUnderTest.build();
}
String name = randomAlphanumeric(3);
String host = randomAlphanumeric(10);
int port = 1 + random.nextInt(10);
- int started = 1 + random.nextInt(666);
+ long startedAt = 1 + random.nextInt(666);
NodeDetails underTest = builderUnderTest
.setType(randomType)
.setName(name)
.setHost(host)
.setPort(port)
- .setStarted(started)
+ .setStartedAt(startedAt)
.build();
assertThat(underTest.toString())
- .isEqualTo("NodeDetails{type=" + randomType + ", name='" + name + "', host='" + host + "', port=" + port + ", started=" + started + "}");
+ .isEqualTo("NodeDetails{type=" + randomType + ", name='" + name + "', host='" + host + "', port=" + port + ", startedAt=" + startedAt + "}");
}
@Test
String name = randomAlphanumeric(3);
String host = randomAlphanumeric(10);
int port = 1 + random.nextInt(10);
- int started = 1 + random.nextInt(666);
+ long startedAt = 1 + random.nextInt(666);
NodeDetails underTest = builderUnderTest
.setType(randomType)
.setName(name)
.setHost(host)
.setPort(port)
- .setStarted(started)
+ .setStartedAt(startedAt)
.build();
assertThat(underTest.getType()).isEqualTo(randomType);
assertThat(underTest.getName()).isEqualTo(name);
assertThat(underTest.getHost()).isEqualTo(host);
assertThat(underTest.getPort()).isEqualTo(port);
- assertThat(underTest.getStarted()).isEqualTo(started);
+ assertThat(underTest.getStartedAt()).isEqualTo(startedAt);
}
}
.setName(randomAlphanumeric(3))
.setHost(randomAlphanumeric(10))
.setPort(1 + random.nextInt(10))
- .setStarted(1 + random.nextInt(666));
+ .setStartedAt(1 + random.nextInt(666));
}
NodeDetails.Type randomType() {
.setName(randomAlphanumeric(30))
.setHost(randomAlphanumeric(10))
.setPort(1 + random.nextInt(666))
- .setStarted(1 + random.nextInt(852))
+ .setStartedAt(1 + random.nextInt(852))
.build())
.build();
}
.setName(props.nonNullValue(CLUSTER_NODE_NAME))
.setHost(getHost(props, networkUtils))
.setPort(Integer.valueOf(props.nonNullValue(CLUSTER_NODE_PORT)))
- .setStarted(system2.now())
+ .setStartedAt(system2.now())
.build();
}
NodeHealth nodeHealth = underTest.get();
- assertThat(nodeHealth.getDetails().getStarted()).isEqualTo(now);
+ assertThat(nodeHealth.getDetails().getStartedAt()).isEqualTo(now);
// change now
when(system2.now()).thenReturn(now);
NodeHealth newNodeHealth = underTest.get();
- assertThat(newNodeHealth.getDetails().getStarted()).isEqualTo(now);
+ assertThat(newNodeHealth.getDetails().getStartedAt()).isEqualTo(now);
}
@Test
.setType(NodeDetails.Type.APPLICATION)
.setHost(computeHost(configuration, networkUtils))
.setPort(computePort(configuration))
- .setStarted(server.getStartedAt().getTime())
+ .setStartedAt(server.getStartedAt().getTime())
.build();
}
import org.sonar.server.health.HealthChecker;
import org.sonarqube.ws.WsSystem;
-import static java.lang.String.valueOf;
import static org.sonar.api.utils.DateUtils.formatDateTime;
public class HealthActionSupport {
.setType(WsSystem.NodeType.valueOf(details.getType().name()))
.setName(details.getName())
.setHost(details.getHost())
- .setPort(valueOf(details.getPort()))
- .setStarted(formatDateTime(details.getStarted()));
+ .setPort(details.getPort())
+ .setStartedAt(formatDateTime(details.getStartedAt()));
return nodeBuilder.build();
}
"name": "app-1",
"type": "APPLICATION",
"host": "192.168.1.1",
- "port": "999",
- "started": "2015-08-13T23:34:59+0200",
+ "port": 999,
+ "startedAt": "2015-08-13T23:34:59+0200",
"health": "RED",
"causes": [
{
"name": "app-2",
"type": "APPLICATION",
"host": "192.168.1.2",
- "port": "999",
- "started": "2015-08-13T23:34:59+0200",
+ "port": 999,
+ "startedAt": "2015-08-13T23:34:59+0200",
"health": "YELLOW",
"causes": [
{
"name": "es-1",
"type": "SEARCH",
"host": "192.168.1.3",
- "port": "999",
- "started": "2015-08-13T23:34:59+0200",
+ "port": 999,
+ "startedAt": "2015-08-13T23:34:59+0200",
"health": "GREEN",
"causes": []
},
"name": "es-2",
"type": "SEARCH",
"host": "192.168.1.4",
- "port": "999",
- "started": "2015-08-13T23:34:59+0200",
+ "port": 999,
+ "startedAt": "2015-08-13T23:34:59+0200",
"health": "GREEN",
"causes": []
},
"name": "es-3",
"type": "SEARCH",
"host": "192.168.1.5",
- "port": "999",
- "started": "2015-08-13T23:34:59+0200",
+ "port": 999,
+ "startedAt": "2015-08-13T23:34:59+0200",
"health": "GREEN",
"causes": []
}
.setHost(randomAlphanumeric(32))
.setName(randomAlphanumeric(32))
.setPort(1 + random.nextInt(88))
- .setStarted(1 + random.nextInt(54))
+ .setStartedAt(1 + random.nextInt(54))
.build())
.build();
}
.setName(randomAlphanumeric(3))
.setHost(randomAlphanumeric(4))
.setPort(1 + random.nextInt(344))
- .setStarted(1 + random.nextInt(999))
+ .setStartedAt(1 + random.nextInt(999))
.build())
.build()).collect(Collectors.toSet());
}
.setName(randomAlphanumeric(23))
.setHost(randomAlphanumeric(23))
.setPort(1 + random.nextInt(96))
- .setStarted(1 + random.nextInt(966))
+ .setStartedAt(1 + random.nextInt(966))
.build())
.build())
.collect(Collectors.toSet());
.setName(randomAlphanumeric(10))
.setHost(randomAlphanumeric(5))
.setPort(1 + random.nextInt(333))
- .setStarted(1 + random.nextInt(444))
+ .setStartedAt(1 + random.nextInt(444))
.build())
.build();
}
NodeHealth nodeHealth = underTest.get();
- assertThat(nodeHealth.getDetails().getStarted()).isEqualTo(date.getTime());
+ assertThat(nodeHealth.getDetails().getStartedAt()).isEqualTo(date.getTime());
// change startedAt value
setStartedAt();
NodeHealth newNodeHealth = underTest.get();
- assertThat(newNodeHealth.getDetails().getStarted()).isEqualTo(date.getTime());
+ assertThat(newNodeHealth.getDetails().getStartedAt()).isEqualTo(date.getTime());
}
private void setStartedAt() {
.setHost(randomAlphanumeric(32))
.setName(randomAlphanumeric(32))
.setPort(1 + random.nextInt(88))
- .setStarted(1 + random.nextInt(54))
+ .setStartedAt(1 + random.nextInt(54))
.build())
.build();
}
.setType(NodeDetails.Type.APPLICATION)
.setHost("192.168.1.1")
.setPort(999)
- .setStarted(time)
+ .setStartedAt(time)
.build())
.build(),
newNodeHealthBuilder()
.setType(NodeDetails.Type.APPLICATION)
.setHost("192.168.1.2")
.setPort(999)
- .setStarted(time)
+ .setStartedAt(time)
.build())
.build(),
newNodeHealthBuilder()
.setType(NodeDetails.Type.SEARCH)
.setHost("192.168.1.3")
.setPort(999)
- .setStarted(time)
+ .setStartedAt(time)
.build())
.build(),
newNodeHealthBuilder()
.setType(NodeDetails.Type.SEARCH)
.setHost("192.168.1.4")
.setPort(999)
- .setStarted(time)
+ .setStartedAt(time)
.build())
.build(),
newNodeHealthBuilder()
.setType(NodeDetails.Type.SEARCH)
.setHost("192.168.1.5")
.setPort(999)
- .setStarted(time)
+ .setStartedAt(time)
.build())
.build())));
.containsOnly(nodeHealth.getCauses().stream().toArray(String[]::new));
assertThat(node.getName()).isEqualTo(nodeHealth.getDetails().getName());
assertThat(node.getHost()).isEqualTo(nodeHealth.getDetails().getHost());
- assertThat(node.getPort()).isEqualTo(String.valueOf(nodeHealth.getDetails().getPort()));
- assertThat(node.getStarted()).isEqualTo(formatDateTime(nodeHealth.getDetails().getStarted()));
+ assertThat(node.getPort()).isEqualTo(nodeHealth.getDetails().getPort());
+ assertThat(node.getStartedAt()).isEqualTo(formatDateTime(nodeHealth.getDetails().getStartedAt()));
assertThat(node.getType().name()).isEqualTo(nodeHealth.getDetails().getType().name());
}
randomNodeHealth(NodeDetails.Type.SEARCH, "2_name", "1_host", 2, 28),
randomNodeHealth(NodeDetails.Type.SEARCH, "2_name", "2_host", 1, 66),
randomNodeHealth(NodeDetails.Type.SEARCH, "2_name", "2_host", 2, 77)));
- String[] expected = nodeHealths.stream().map(s -> formatDateTime(new Date(s.getDetails().getStarted()))).toArray(String[]::new);
+ String[] expected = nodeHealths.stream().map(s -> formatDateTime(new Date(s.getDetails().getStartedAt()))).toArray(String[]::new);
Collections.shuffle(nodeHealths);
when(webServer.isStandalone()).thenReturn(false);
WsSystem.HealthResponse response = underTest.newRequest().executeProtobuf(WsSystem.HealthResponse.class);
assertThat(response.getNodes().getNodesList())
- .extracting(WsSystem.Node::getStarted)
+ .extracting(WsSystem.Node::getStartedAt)
.containsExactly(expected);
}
.setName(randomAlphanumeric(3))
.setHost(randomAlphanumeric(4))
.setPort(1 + random.nextInt(3))
- .setStarted(1 + random.nextInt(23))
+ .setStartedAt(1 + random.nextInt(23))
.build())
.build();
}
.setName(name)
.setHost(host)
.setPort(port)
- .setStarted(started)
+ .setStartedAt(started)
.build())
.build();
}
optional string name = 1;
optional NodeType type = 2;
optional string host = 3;
- optional string port = 4;
- optional string started = 5;
+ optional int32 port = 4;
+ optional string startedAt = 5;
optional Health health = 6;
repeated Cause causes = 7;
}