diff --git a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/AbstractNodeWithManageable.java b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/AbstractNodeWithManageable.java
deleted file mode 100644
index 269c83a1ca..0000000000
--- a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/AbstractNodeWithManageable.java
+++ /dev/null
@@ -1,130 +0,0 @@
-/*
- * Copyright Terracotta, Inc.
- *
- * 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 org.terracotta.management.model.cluster;
-
-import org.terracotta.management.model.context.Context;
-
-import java.io.Serializable;
-import java.util.Map;
-import java.util.Optional;
-import java.util.concurrent.ConcurrentHashMap;
-import java.util.concurrent.ConcurrentMap;
-import java.util.stream.Collectors;
-import java.util.stream.Stream;
-
-/**
- * @author Mathieu Carbou
- */
-abstract class AbstractNodeWithManageable
extends AbstractNode
implements NodeWithManageable, Serializable {
-
- // services, server entities, client entities, etc.
- private final ConcurrentMap manageables = new ConcurrentHashMap<>();
-
- public AbstractNodeWithManageable(String id) {
- super(id);
- }
-
- @Override
- public final Map getManageables() {
- return manageables;
- }
-
- @Override
- public final int getManageableCount() {
- return manageables.size();
- }
-
- @Override
- public final Stream manageableStream() {
- return manageables.values().stream();
- }
-
- @Override
- @SuppressWarnings("unchecked")
- public final B addManageable(Manageable manageable) {
- // manageabled are unique per their ID but also per their combination of (type + name)
- for (Manageable m : manageables.values()) {
- if (m.is(manageable.getType(), manageable.getName())) {
- throw new IllegalArgumentException("Duplicate manageable: type=" + manageable.getType() + ", name=" + manageable.getName());
- }
- }
- if (manageables.putIfAbsent(manageable.getId(), manageable) != null) {
- throw new IllegalArgumentException("Duplicate manageable: " + manageable.getId());
- }
- manageable.setParent(this);
- return (B) this;
- }
-
- @Override
- public final Optional getManageable(Context context) {
- return getManageable(context.get(Manageable.KEY));
- }
-
- @Override
- public final Optional getManageable(String id) {
- return id == null ? Optional.empty() : Optional.ofNullable(manageables.get(id));
- }
-
- @Override
- public final Optional getManageable(String name, String type) {
- return manageableStream().filter(manageable -> manageable.is(name, type)).findFirst();
- }
-
- @Override
- public final boolean hasManageable(String name, String type) {
- return getManageable(name, type).isPresent();
- }
-
- @Override
- public final Optional removeManageable(String id) {
- Optional manageable = getManageable(id);
- manageable.ifPresent(m -> {
- if (manageables.remove(id, m)) {
- m.detach();
- }
- });
- return manageable;
- }
-
- @Override
- public final Stream manageableStream(String type) {
- return manageableStream().filter(manageable -> manageable.isType(type));
- }
-
- @Override
- public boolean equals(Object o) {
- if (this == o) return true;
- if (o == null || getClass() != o.getClass()) return false;
- if (!super.equals(o)) return false;
- AbstractNodeWithManageable, ?> that = (AbstractNodeWithManageable, ?>) o;
- return manageables.equals(that.manageables);
- }
-
- @Override
- public int hashCode() {
- int result = super.hashCode();
- result = 31 * result + manageables.hashCode();
- return result;
- }
-
- @Override
- public Map toMap() {
- Map map = super.toMap();
- map.put("manageables", manageableStream().sorted((o1, o2) -> o1.getId().compareTo(o2.getId())).map(Manageable::toMap).collect(Collectors.toList()));
- return map;
- }
-
-}
diff --git a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Client.java b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Client.java
index 4e2aea05de..8611e123af 100644
--- a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Client.java
+++ b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Client.java
@@ -32,7 +32,7 @@
/**
* @author Mathieu Carbou
*/
-public final class Client extends AbstractNodeWithManageable implements Serializable {
+public final class Client extends AbstractNode implements Serializable {
private static final long serialVersionUID = 1;
@@ -44,12 +44,22 @@ public final class Client extends AbstractNodeWithManageable im
private final ClientIdentifier clientIdentifier;
private final SortedSet tags = new TreeSet<>();
private String hostName;
+ private ManagementRegistry managementRegistry;
private Client(ClientIdentifier clientIdentifier) {
super(clientIdentifier.getClientId());
this.clientIdentifier = Objects.requireNonNull(clientIdentifier);
}
+ public Optional getManagementRegistry() {
+ return Optional.ofNullable(managementRegistry);
+ }
+
+ public Client setManagementRegistry(ManagementRegistry managementRegistry) {
+ this.managementRegistry = managementRegistry;
+ return this;
+ }
+
public SortedSet getTags() {
return tags;
}
@@ -161,16 +171,14 @@ public Optional removeConnection(String id) {
return connection;
}
- public Stream serverManageableStream() {
+ public Stream fetchedServerEntityStream() {
return connectionStream()
- .filter(Connection::isConnectedToActiveServer)
- .flatMap(Connection::serverManageableStream);
+ .flatMap(Connection::fetchedServerEntityStream);
}
- public int getServerManageableCount() {
+ public int getFetchedServerEntityCount() {
return connectionStream()
- .filter(Connection::isConnectedToActiveServer)
- .mapToInt(Connection::getServerManageableCount).sum();
+ .mapToInt(Connection::getFetchedServerEntityCount).sum();
}
@Override
@@ -189,16 +197,12 @@ public boolean isConnected() {
return connectionStream().filter(Connection::isConnected).findFirst().isPresent();
}
- public boolean isConnectedToActive() {
- return connectionStream().filter(Connection::isConnectedToActiveServer).findFirst().isPresent();
- }
-
- public boolean isConnectedToServerManageable(String name, String type) {
- return getServerManageable(name, type).isPresent();
+ public boolean hasFetchedServerEntity(String name, String type) {
+ return getFetchedServerEntity(name, type).isPresent();
}
- public Optional getServerManageable(String name, String type) {
- return serverManageableStream().filter(manageable -> manageable.is(name, type)).findFirst();
+ public Optional getFetchedServerEntity(String name, String type) {
+ return fetchedServerEntityStream().filter(serverEntity -> serverEntity.is(name, type)).findFirst();
}
@Override
@@ -216,7 +220,9 @@ public boolean equals(Object o) {
if (!connections.equals(client.connections)) return false;
if (!clientIdentifier.equals(client.clientIdentifier)) return false;
- return hostName != null ? hostName.equals(client.hostName) : client.hostName == null;
+ if (!tags.equals(client.tags)) return false;
+ if (hostName != null ? !hostName.equals(client.hostName) : client.hostName != null) return false;
+ return managementRegistry != null ? managementRegistry.equals(client.managementRegistry) : client.managementRegistry == null;
}
@@ -225,7 +231,9 @@ public int hashCode() {
int result = super.hashCode();
result = 31 * result + connections.hashCode();
result = 31 * result + clientIdentifier.hashCode();
+ result = 31 * result + tags.hashCode();
result = 31 * result + (hostName != null ? hostName.hashCode() : 0);
+ result = 31 * result + (managementRegistry != null ? managementRegistry.hashCode() : 0);
return result;
}
@@ -241,6 +249,7 @@ public Map toMap() {
map.put("hostName", getHostName());
map.put("tags", tags);
map.put("connections", connectionStream().sorted((o1, o2) -> o1.getId().compareTo(o2.getId())).map(Connection::toMap).collect(Collectors.toList()));
+ map.put("managementRegistry", managementRegistry == null ? null : managementRegistry.toMap());
return map;
}
diff --git a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Cluster.java b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Cluster.java
index 37bfdc9258..9feccc3dcf 100644
--- a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Cluster.java
+++ b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Cluster.java
@@ -128,12 +128,8 @@ public Optional removeStripe(String id) {
return stripe;
}
- public Optional getManageable(Context context) {
- Optional manageable = getStripe(context).flatMap(s -> s.getActiveManageable(context));
- if (manageable.isPresent()) {
- return manageable;
- }
- return getClient(context).flatMap(c -> c.getManageable(context));
+ public Optional getServerEntity(Context context) {
+ return getStripe(context).flatMap(s -> s.getServerEntity(context));
}
public Optional getServer(Context context) {
@@ -146,13 +142,10 @@ public List extends Node> getNodes(Context context) {
nodes.add(stripe1);
stripe1.getServer(context).ifPresent(server -> {
nodes.add(server);
- server.getManageable(context).ifPresent(nodes::add);
+ server.getServerEntity(context).ifPresent(nodes::add);
});
});
- getClient(context).ifPresent(client -> {
- nodes.add(client);
- client.getManageable(context).ifPresent(nodes::add);
- });
+ getClient(context).ifPresent(nodes::add);
return nodes;
}
@@ -165,16 +158,8 @@ public String getPath(Context context) {
return sb.toString();
}
- public Stream allManageableStream() {
- return Stream.concat(serverManageableStream(), clientManageableStream());
- }
-
- public Stream serverManageableStream() {
- return stripeStream().flatMap(Stripe::activeManageableStream);
- }
-
- public Stream clientManageableStream() {
- return clientStream().flatMap(Client::manageableStream);
+ public Stream serverEntityStream() {
+ return stripeStream().flatMap(Stripe::serverEntityStream);
}
public Stream serverStream() {
diff --git a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Connection.java b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Connection.java
index 8a3ad11b0a..36fc113529 100644
--- a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Connection.java
+++ b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Connection.java
@@ -34,7 +34,7 @@ public final class Connection extends AbstractNode implements Serializab
public static final String KEY = "connectionId";
- private final Collection manageableIds = new ConcurrentSkipListSet<>();
+ private final Collection serverEntityIds = new ConcurrentSkipListSet<>();
private final Endpoint clientEndpoint;
private final String stripeId;
private final String serverId;
@@ -77,19 +77,19 @@ public Optional getServer() {
}
}
- public Stream serverManageableStream() {
+ public Stream fetchedServerEntityStream() {
return getServer()
- .map(server -> manageableIds.stream()
- .map(server::getManageable)
+ .map(server -> serverEntityIds.stream()
+ .map(server::getServerEntity)
.filter(Optional::isPresent)
.map(Optional::get))
.orElse(Stream.empty());
}
- public int getServerManageableCount() {
+ public int getFetchedServerEntityCount() {
return getServer()
- .map(server -> manageableIds.stream()
- .map(server::getManageable)
+ .map(server -> serverEntityIds.stream()
+ .map(server::getServerEntity)
.filter(Optional::isPresent)
.count())
.orElse(0L).intValue();
@@ -118,7 +118,7 @@ public boolean equals(Object o) {
Connection that = (Connection) o;
- if (!manageableIds.equals(that.manageableIds)) return false;
+ if (!serverEntityIds.equals(that.serverEntityIds)) return false;
if (!clientEndpoint.equals(that.clientEndpoint)) return false;
if (stripeId != null ? !stripeId.equals(that.stripeId) : that.stripeId != null) return false;
return serverId != null ? serverId.equals(that.serverId) : that.serverId == null;
@@ -131,7 +131,7 @@ public int hashCode() {
// and can be different whether we opened/closed several connections in our different tests
//int result = super.hashCode();
int result = 0;
- result = 31 * result + manageableIds.hashCode();
+ result = 31 * result + serverEntityIds.hashCode();
result = 31 * result + clientEndpoint.hashCode();
result = 31 * result + (stripeId != null ? stripeId.hashCode() : 0);
result = 31 * result + (serverId != null ? serverId.hashCode() : 0);
@@ -145,34 +145,30 @@ public Map toMap() {
map.put("clientEndpoint", clientEndpoint.toMap());
map.put("stripeId", this.stripeId);
map.put("serverId", this.serverId);
- map.put("manageableIds", this.manageableIds);
+ map.put("serverEntityIds", this.serverEntityIds);
return map;
}
- public void disconnectServerManageable(String name, String type) {
- manageableIds.remove(Manageable.key(name, type));
+ public void unfetchServerEntity(String name, String type) {
+ serverEntityIds.remove(ServerEntity.key(name, type));
}
- public boolean connectServerManageable(Manageable manageable) {
+ public boolean fetchServerEntity(ServerEntity serverEntity) {
if (!isConnected()) {
throw new IllegalStateException("not connnected");
}
- if (!(manageable.getParent() instanceof Server)) {
- throw new IllegalArgumentException(String.valueOf(manageable.getParent()));
+ if (!(serverEntity.getParent() instanceof Server)) {
+ throw new IllegalArgumentException(String.valueOf(serverEntity.getParent()));
}
- Server server = (Server) manageable.getParent();
+ Server server = (Server) serverEntity.getParent();
if (server != getServer().get()) {
- throw new IllegalStateException("wrong server manageable");
+ throw new IllegalStateException("wrong server serverEntity");
}
- return manageableIds.add(manageable.getId());
+ return serverEntityIds.add(serverEntity.getId());
}
- public boolean isConnectedToServerManageable(String name, String type) {
- return serverManageableStream().filter(manageable -> manageable.is(name, type)).findFirst().isPresent();
- }
-
- public boolean isConnectedToActiveServer() {
- return getServer().filter(Server::isActive).isPresent();
+ public boolean hasFetchedServerEntity(String name, String type) {
+ return fetchedServerEntityStream().filter(serverEntity -> serverEntity.is(name, type)).findFirst().isPresent();
}
public boolean isConnectedTo(Server server) {
diff --git a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/ManageableContainer.java b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/ManageableContainer.java
deleted file mode 100644
index ed638f09f3..0000000000
--- a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/ManageableContainer.java
+++ /dev/null
@@ -1,48 +0,0 @@
-/*
- * Copyright Terracotta, Inc.
- *
- * 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 org.terracotta.management.model.cluster;
-
-import org.terracotta.management.model.context.Context;
-
-import java.util.Map;
-import java.util.Optional;
-import java.util.stream.Stream;
-
-/**
- * @author Mathieu Carbou
- */
-public interface ManageableContainer {
- Map getManageables();
-
- int getManageableCount();
-
- B addManageable(Manageable manageable);
-
- Stream manageableStream();
-
- Optional getManageable(Context context);
-
- Optional getManageable(String id);
-
- Optional getManageable(String name, String type);
-
- boolean hasManageable(String name, String type);
-
- Optional removeManageable(String id);
-
- Stream manageableStream(String type);
-}
diff --git a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Manageable.java b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/ManagementRegistry.java
similarity index 57%
rename from cluster-topology/src/main/java/org/terracotta/management/model/cluster/Manageable.java
rename to cluster-topology/src/main/java/org/terracotta/management/model/cluster/ManagementRegistry.java
index 19c1a38777..8a3a944ba6 100644
--- a/cluster-topology/src/main/java/org/terracotta/management/model/cluster/Manageable.java
+++ b/cluster-topology/src/main/java/org/terracotta/management/model/cluster/ManagementRegistry.java
@@ -23,7 +23,6 @@
import org.terracotta.management.model.capabilities.descriptors.Settings;
import org.terracotta.management.model.capabilities.descriptors.StatisticDescriptor;
import org.terracotta.management.model.capabilities.descriptors.StatisticDescriptorCategory;
-import org.terracotta.management.model.context.Context;
import org.terracotta.management.model.context.ContextContainer;
import java.io.Serializable;
@@ -39,42 +38,33 @@
/**
* @author Mathieu Carbou
*/
-public final class Manageable extends AbstractNode implements Serializable {
+public final class ManagementRegistry implements Serializable {
private static final long serialVersionUID = 1;
- public static final String KEY = "manageableId";
- public static final String TYPE_KEY = "manageableType";
- public static final String NAME_KEY = "manageableName";
+ private final ContextContainer contextContainer;
+ private final Map capabilities = new LinkedHashMap<>();
- private final String type; // type (service, client entity, server entity, etc)
- private final String name; // type (entity type name)
- private ContextContainer contextContainer; // management registry output
- private Map capabilities = new LinkedHashMap<>();
-
- // matches management registry config, or entity id, or service type
- private Manageable(String id, String name, String type) {
- super(id);
- this.type = Objects.requireNonNull(type);
- this.name = Objects.requireNonNull(name);
+ private ManagementRegistry(ContextContainer contextContainer) {
+ this.contextContainer = Objects.requireNonNull(contextContainer);
}
- public Manageable setCapabilities(Collection capabilities) {
+ public ManagementRegistry setCapabilities(Collection capabilities) {
this.capabilities.clear();
capabilities.forEach(this::addCapability);
return this;
}
- public Manageable setCapabilities(Capability... capabilities) {
+ public ManagementRegistry setCapabilities(Capability... capabilities) {
return setCapabilities(Arrays.asList(capabilities));
}
- public Manageable addCapability(Capability capability) {
+ public ManagementRegistry addCapability(Capability capability) {
this.capabilities.put(capability.getName(), capability);
return this;
}
- public Manageable addCapabilities(Capability... capabilities) {
+ public ManagementRegistry addCapabilities(Capability... capabilities) {
for (Capability capability : capabilities) {
addCapability(capability);
}
@@ -85,131 +75,54 @@ public Collection getCapabilities() {
return capabilities.values();
}
- public Capability findCapability(String id) {
+ public Capability findCapability(String capabilityName) {
for (Capability capability : capabilities.values()) {
- if (capability.getName().equals(name)) {
+ if (capability.getName().equals(capabilityName)) {
return capability;
}
}
return null;
}
- public Manageable setContextContainer(ContextContainer contextContainer) {
- this.contextContainer = contextContainer;
- return this;
- }
-
public ContextContainer getContextContainer() {
return contextContainer;
}
- public String getType() {
- return type;
- }
-
- public boolean isType(String type) {
- return this.type.equals(type);
- }
-
- public String getName() {
- return name;
- }
-
- @Override
- public Context getContext() {
- Context context = super.getContext()
- .with(NAME_KEY, name)
- .with(TYPE_KEY, type);
- return contextContainer == null ? context : context.with(contextContainer.getName(), contextContainer.getValue());
- }
-
- @Override
- public void remove() {
- Node parent = getParent();
- if (parent != null && parent instanceof ManageableContainer) {
- ((ManageableContainer) parent).removeManageable(getId());
- }
- }
-
- public T getContainer(Class type) {
- return type.cast(getParent());
- }
-
- public Collection getAllCapabilityContexts(String capabilityName) {
- Context thisContext = getContext();
- Capability capability = capabilities.get(capabilityName);
- if (capability == null) {
- throw new IllegalArgumentException(capabilityName);
- }
-
- // get all attributes to make this capability works
- Collection requiredAttributesNames = capability.getCapabilityContext().getRequiredAttributeNames();
- boolean addMainCtx = requiredAttributesNames.contains(contextContainer.getName());
-
- Collection contexts = new ArrayList<>(contextContainer.getSubContexts().size());
- for (ContextContainer subCtx : contextContainer.getSubContexts()) {
- if (requiredAttributesNames.contains(subCtx.getName())) {
- Context ctx = thisContext.with(subCtx.getName(), subCtx.getValue());
- if (addMainCtx) {
- ctx = ctx.with(contextContainer.getName(), contextContainer.getValue());
- }
- contexts.add(ctx);
- }
- }
-
- return contexts;
- }
-
- @Override
- String getContextKey() {
- return KEY;
- }
-
- public boolean is(String name, String type) {
- return this.name.equals(name) && this.type.equals(type);
- }
-
@Override
public boolean equals(Object o) {
if (this == o) return true;
if (o == null || getClass() != o.getClass()) return false;
- if (!super.equals(o)) return false;
- Manageable that = (Manageable) o;
+ ManagementRegistry that = (ManagementRegistry) o;
- if (!type.equals(that.type)) return false;
- if (!name.equals(that.name)) return false;
- if (contextContainer != null ? !contextContainer.equals(that.contextContainer) : that.contextContainer != null) return false;
- return capabilities != null ? capabilities.equals(that.capabilities) : that.capabilities == null;
+ if (!contextContainer.equals(that.contextContainer)) return false;
+ return capabilities.equals(that.capabilities);
}
@Override
public int hashCode() {
- int result = super.hashCode();
- result = 31 * result + type.hashCode();
- result = 31 * result + name.hashCode();
- result = 31 * result + (contextContainer != null ? contextContainer.hashCode() : 0);
- result = 31 * result + (capabilities != null ? capabilities.hashCode() : 0);
+ int result = contextContainer.hashCode();
+ result = 31 * result + capabilities.hashCode();
return result;
}
@Override
+ public String toString() {
+ return contextContainer.getValue();
+ }
+
public Map toMap() {
- Map map = super.toMap();
- map.put("type", getType());
- map.put("name", getName());
- if (contextContainer != null) {
- map.put("contextContainer", toMap(contextContainer));
- }
- map.put("capabilities", this.capabilities.values().stream().map(Manageable::toMap).collect(Collectors.toList()));
+ Map map = new LinkedHashMap<>();
+ map.put("contextContainer", toMap(contextContainer));
+ map.put("capabilities", this.capabilities.values().stream().map(ManagementRegistry::toMap).collect(Collectors.toList()));
return map;
}
private static Map toMap(Capability capability) {
Map map = new LinkedHashMap<>();
map.put("name", capability.getName());
- map.put("context", capability.getCapabilityContext().getAttributes().stream().map(Manageable::toMap).collect(Collectors.toList()));
+ map.put("context", capability.getCapabilityContext().getAttributes().stream().map(ManagementRegistry::toMap).collect(Collectors.toList()));
List