org.graylog2.restclient.models.Node Maven / Gradle / Ivy
/**
* This file is part of Graylog.
*
* Graylog is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* Graylog is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with Graylog. If not, see allLoggerSubsystems() {
Map subsystems = Maps.newHashMap();
try {
LoggerSubsystemsResponse response = api.path(routes.LoggersResource().subsystems(), LoggerSubsystemsResponse.class)
.node(this)
.execute();
for (Map.Entry ss : response.subsystems.entrySet()) {
subsystems.put(ss.getKey(), new InternalLoggerSubsystem(
ss.getValue().title,
ss.getValue().level,
ss.getValue().levelSyslog
));
}
} catch (Exception e) {
LOG.error("Unable to load subsystems for node " + this, e);
}
return subsystems;
}
public List allLoggers() {
List loggers = Lists.newArrayList();
try {
LoggersResponse response = api.path(routes.LoggersResource().loggers(), LoggersResponse.class)
.node(this)
.execute();
for (Map.Entry logger : response.loggers.entrySet()) {
loggers.add(new InternalLogger(logger.getKey(), logger.getValue().level, logger.getValue().syslogLevel));
}
} catch (Exception e) {
LOG.error("Unable to load loggers for node " + this, e);
}
return loggers;
}
public void setSubsystemLoggerLevel(String subsystem, String level) throws APIException, IOException {
api.path(routes.LoggersResource().setSubsystemLoggerLevel(subsystem, level))
.node(this)
.execute();
}
public String getThreadDump() throws IOException, APIException {
return api.path(routes.SystemResource().threaddump(), String.class)
.node(this)
.accept(MediaType.ANY_TEXT_TYPE)
.execute();
}
@JsonIgnore
public List getInputStates() {
List inputStates = Lists.newArrayList();
for (InputStateSummaryResponse issr : inputs().inputs) {
inputStates.add(inputStateFactory.fromSummaryResponse(issr, this));
}
return inputStates;
}
public List getInputs() {
List inputs = Lists.newArrayList();
for (InputState input : getInputStates()) {
inputs.add(input.getInput());
}
return inputs;
}
public Input getInput(String inputId) throws IOException, APIException {
final InputSummaryResponse inputSummaryResponse = api.path(routes.InputsResource().single(inputId), InputSummaryResponse.class).node(this).execute();
return inputFactory.fromSummaryResponse(inputSummaryResponse, this);
}
public int numberOfInputs() {
return inputs().total;
}
public InputLaunchResponse updateInput(String inputId, String title, String type, boolean global, Map configuration, String node) {
final InputLaunchRequest request = InputLaunchRequest.create(title, type, global, configuration, node);
try {
return api.path(routes.InputsResource().update(inputId), InputLaunchResponse.class)
.node(this)
.body(request)
.expect(Http.Status.CREATED)
.execute();
} catch (APIException | IOException e) {
LOG.error("Could not update input " + title, e);
return null;
}
}
@Override
public InputLaunchResponse launchInput(String title, String type, Boolean global, Map configuration, boolean isExclusive, String nodeId) throws ExclusiveInputException {
if (isExclusive) {
for (Input input : getInputs()) {
if (input.getType().equals(type)) {
throw new ExclusiveInputException();
}
}
}
final InputLaunchRequest request = InputLaunchRequest.create(title, type, global, configuration, nodeId);
try {
return api.path(routes.InputsResource().create(), InputLaunchResponse.class)
.node(this)
.body(request)
.expect(Http.Status.ACCEPTED)
.execute();
} catch (Exception e) {
LOG.error("Could not launch input " + title, e);
return null;
}
}
@Override
public boolean launchExistingInput(String inputId) {
try {
api.path(routes.InputsResource().launchExisting(inputId))
.node(this)
.expect(Http.Status.ACCEPTED)
.execute();
return true;
} catch (Exception e) {
LOG.error("Could not launch input " + inputId, e);
}
return false;
}
@Override
public boolean terminateInput(String inputId) {
try {
api.path(routes.InputsResource().terminate(inputId))
.node(this)
.expect(Http.Status.ACCEPTED)
.execute();
return true;
} catch (Exception e) {
LOG.error("Could not terminate input " + inputId, e);
}
return false;
}
public Map getInputTypes() throws IOException, APIException {
return api.path(routes.InputTypesResource().types(), InputTypesResponse.class).node(this).execute().types;
}
public InputTypeSummaryResponse getInputTypeInformation(String type) throws IOException, APIException {
return api.path(routes.InputTypesResource().info(type), InputTypeSummaryResponse.class).node(this).execute();
}
@JsonIgnore
public Map getAllInputTypeInformation() throws IOException, APIException {
Map types = Maps.newHashMap();
for (String type : getInputTypes().keySet()) {
InputTypeSummaryResponse itr = getInputTypeInformation(type);
types.put(itr.type, itr);
}
return types;
}
// TODO nodes should not have state beyond their activity status
public synchronized SystemOverviewResponse loadSystemInformation() {
try {
return api.path(routes.SystemResource().system(), SystemOverviewResponse.class)
.node(this)
.execute();
} catch (Exception e) {
LOG.error("Unable to load system information for node " + this, e);
return null;
}
}
public synchronized NodeJVMStats loadJVMInformation() {
try {
return new NodeJVMStats(api.path(routes.SystemResource().jvm(), ClusterEntityJVMStatsResponse.class)
.node(this)
.execute()
);
} catch (Exception e) {
LOG.error("Unable to load JVM information for node " + this, e);
return null;
}
}
@Override
public String getTransportAddress() {
return transportAddress.toASCIIString();
}
public URI getTransportAddressUri() {
return transportAddress;
}
public DateTime getLastSeen() {
return lastSeen;
}
public String getClusterId() {
return clusterId;
}
public String getNodeId() {
return nodeId;
}
@Override
public String getShortNodeId() {
return shortNodeId;
}
@Override
public String getHostname() {
requireSystemInfo();
return systemInfo.hostname;
}
public boolean isMaster() {
return isMaster;
}
public boolean isProcessing() {
requireSystemInfo();
return this.systemInfo.isProcessing;
}
public String getLifecycle() {
requireSystemInfo();
return this.systemInfo.lifecycle;
}
public boolean lbAlive() {
requireSystemInfo();
return this.systemInfo.lbStatus != null && this.systemInfo.lbStatus.equals("alive");
}
public String getVersion() {
requireSystemInfo();
return systemInfo.version;
}
public String getCodename() {
requireSystemInfo();
return systemInfo.codename;
}
public String getTimezone() {
requireSystemInfo();
return systemInfo.timezone;
}
public String getPid() {
requireJVMInfo();
return jvmInfo.getPid();
}
public String getJVMDescription() {
requireJVMInfo();
return jvmInfo.getInfo();
}
public NodeJVMStats jvm() {
requireJVMInfo();
return jvmInfo;
}
public Map getMetrics(String namespace) throws APIException, IOException {
MetricsListResponse response = api.path(routes.MetricsResource().byNamespace(namespace), MetricsListResponse.class)
.node(this)
.expect(200)
.execute();
if (response == null) {
return Collections.emptyMap();
}
return response.getMetrics();
}
public Metric getSingleMetric(String metricName) throws APIException, IOException {
return getMetrics(metricName).get(metricName);
}
public void pause() throws IOException, APIException {
api.path(routes.SystemProcessingResource().pauseProcessing())
.node(this)
.execute();
}
public void resume() throws IOException, APIException {
api.path(routes.SystemProcessingResource().resumeProcessing())
.node(this)
.execute();
}
public void overrideLbStatus(String override) throws APIException, IOException {
api.path(routes.LoadBalancerStatusResource().override(override))
.node(this)
.execute();
}
public int getThroughput() {
try {
return api.path(routes.ThroughputResource().total(), NodeThroughputResponse.class).node(this).execute().throughput;
} catch (Exception e) {
LOG.error("Could not load throughput for node " + this, e);
}
return 0;
}
/**
* This swallows all exceptions to allow easy lazy-loading in views without exception handling.
*
* @return List of running inputs o this node.
*/
private InputsResponse inputs() {
try {
return api.path(routes.InputsResource().list(), InputsResponse.class).node(this).execute();
} catch (Exception e) {
LOG.error("Could not get inputs.", e);
throw new RuntimeException("Could not get inputs.", e);
}
}
public boolean isFromConfiguration() {
return fromConfiguration;
}
@Override
public void markFailure() {
failureCount.incrementAndGet();
setActive(false);
LOG.info("{} failed, marking as inactive.", this);
}
public int getFailureCount() {
return failureCount.get();
}
public DateTime getLastContact() {
return lastContact;
}
public void merge(Node updatedNode) {
LOG.debug("Merging node {} in this node {}", updatedNode, this);
this.lastSeen = updatedNode.lastSeen;
this.isMaster = updatedNode.isMaster;
this.nodeId = updatedNode.nodeId;
this.shortNodeId = updatedNode.shortNodeId;
this.setActive(updatedNode.isActive());
}
@Override
public void touch() {
this.lastContact = DateTools.nowInUTC();
setActive(true);
}
public boolean isActive() {
return active.get();
}
public void setActive(boolean active) {
this.active.set(active);
}
public void shutdown() throws APIException, IOException {
api.path(routes.SystemShutdownResource().shutdown())
.node(this)
.expect(Http.Status.ACCEPTED)
.execute();
}
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
Node node = (Node) o;
// if both have a node id, and they are the same, the nodes are the same.
if (nodeId != null && node.nodeId != null) {
if (nodeId.equals(node.nodeId)) {
return true;
}
}
// otherwise if the transport addresses are the same, we consider the nodes to be the same.
if (transportAddress.equals(node.transportAddress)) return true;
// otherwise the nodes aren't the same
return false;
}
@Override
public int hashCode() {
int result = transportAddress.hashCode();
result = 31 * result + (nodeId != null ? nodeId.hashCode() : 0);
return result;
}
@Override
public String toString() {
final StringBuilder b = new StringBuilder();
if (nodeId == null) {
b.append("UnresolvedNode {'").append(transportAddress).append("'}");
return b.toString();
}
b.append("Node {");
b.append("'").append(nodeId).append("'");
b.append(", ").append(transportAddress);
if (isMaster) {
b.append(", master");
}
if (isActive()) {
b.append(", active");
} else {
b.append(", inactive");
}
final int failures = getFailureCount();
if (failures > 0) {
b.append(", failed: ").append(failures).append(" times");
}
b.append("}");
return b.toString();
}
public void requireSystemInfo() {
if (this.systemInfo == null) {
this.systemInfo = firstNonNull(loadSystemInformation(), SystemOverviewResponse.buildEmpty());
}
}
public void requireJVMInfo() {
if (this.jvmInfo == null) {
this.jvmInfo = firstNonNull(loadJVMInformation(), NodeJVMStats.buildEmpty());
}
}
@Override
public void stopInput(String inputId) throws IOException, APIException {
api.path(routes.InputsResource().stop(inputId))
.node(this)
.expect(Http.Status.ACCEPTED)
.execute();
}
@Override
public void startInput(String inputId) throws IOException, APIException {
api.path(routes.InputsResource().launchExisting(inputId))
.node(this)
.expect(Http.Status.ACCEPTED)
.execute();
}
@Override
public void restartInput(String inputId) throws IOException, APIException {
api.path(routes.InputsResource().restart(inputId))
.node(this)
.expect(Http.Status.ACCEPTED)
.execute();
}
}
© 2015 - 2025 Weber Informatics LLC | Privacy Policy