public static void handleClusterRemoved(ClusterContext ctxt) {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(ctxt.getCartridgeType());
String deploymentPolicy;
if (service == null) {
log.warn(String.format("Service %s does not exist", ctxt.getCartridgeType()));
return;
}
if (!service.clusterExists(ctxt.getClusterId())) {
log.warn(
String.format(
"Cluster %s does not exist for service %s",
ctxt.getClusterId(), ctxt.getCartridgeType()));
return;
}
try {
TopologyManager.acquireWriteLock();
Cluster cluster = service.removeCluster(ctxt.getClusterId());
deploymentPolicy = cluster.getDeploymentPolicyName();
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
TopologyEventPublisher.sendClusterRemovedEvent(ctxt, deploymentPolicy);
}
/**
* This is directly called when the connection to the node is gone, or when the node sends a
* disconnection. Look for callers of this method!
*/
public void notifyNodeDown(final long eventTime, final String nodeID) {
if (!ha) {
// there's no topology here
return;
}
if (HornetQLogger.LOGGER.isDebugEnabled()) {
HornetQLogger.LOGGER.debug(
"nodeDown " + this + " nodeID=" + nodeID + " as being down", new Exception("trace"));
}
topology.removeMember(eventTime, nodeID);
if (clusterConnection) {
updateArraysAndPairs();
} else {
synchronized (this) {
if (topology.isEmpty()) {
// Resetting the topology to its original condition as it was brand new
receivedTopology = false;
topologyArray = null;
} else {
updateArraysAndPairs();
if (topology.nodes() == 1 && topology.getMember(this.nodeID) != null) {
// Resetting the topology to its original condition as it was brand new
receivedTopology = false;
}
}
}
}
}
public static void handleServiceRemoved(List<Cartridge> cartridgeList) {
Topology topology = TopologyManager.getTopology();
for (Cartridge cartridge : cartridgeList) {
Service service = topology.getService(cartridge.getType());
if (service == null) {
log.warn("Cartridge does not exist [cartidge] " + cartridge);
return;
}
if (service.getClusters().size() == 0) {
if (topology.serviceExists(cartridge.getType())) {
try {
TopologyManager.acquireWriteLock();
topology.removeService(cartridge.getType());
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
TopologyEventPublisher.sendServiceRemovedEvent(cartridgeList);
} else {
log.warn(String.format("Service %s does not exist..", cartridge.getType()));
}
} else {
log.warn(
"Subscription already exists. Hence not removing the service:"
+ cartridge.getType()
+ " from the topology");
}
}
}
public ClientSessionFactory createSessionFactory(String nodeID) throws Exception {
TopologyMember topologyMember = topology.getMember(nodeID);
if (HornetQLogger.LOGGER.isTraceEnabled()) {
HornetQLogger.LOGGER.trace(
"Creating connection factory towards "
+ nodeID
+ " = "
+ topologyMember
+ ", topology="
+ topology.describe());
}
if (topologyMember == null) {
return null;
} else if (topologyMember.getA() != null) {
ClientSessionFactoryInternal factory =
(ClientSessionFactoryInternal) createSessionFactory(topologyMember.getA());
if (topologyMember.getB() != null) {
factory.setBackupConnector(topologyMember.getA(), topologyMember.getB());
}
return factory;
} else if (topologyMember.getA() == null && topologyMember.getB() != null) {
// This shouldn't happen, however I wanted this to consider all possible cases
ClientSessionFactoryInternal factory =
(ClientSessionFactoryInternal) createSessionFactory(topologyMember.getB());
return factory;
} else {
// it shouldn't happen
return null;
}
}
public static void handleClusterTerminatedEvent(ClusterStatusClusterTerminatedEvent event) {
TopologyManager.acquireWriteLock();
try {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(event.getServiceName());
// update the status of the cluster
if (service == null) {
log.warn(String.format("Service %s does not exist", event.getServiceName()));
return;
}
Cluster cluster = service.getCluster(event.getClusterId());
if (cluster == null) {
log.warn(String.format("Cluster %s does not exist", event.getClusterId()));
return;
}
ClusterInstance context = cluster.getInstanceContexts(event.getInstanceId());
if (context == null) {
log.warn(
"Cluster Instance Context is not found for [cluster] "
+ event.getClusterId()
+ " [instance-id] "
+ event.getInstanceId());
return;
}
ClusterStatus status = ClusterStatus.Terminated;
if (context.isStateTransitionValid(status)) {
context.setStatus(status);
log.info(
"Cluster Terminated adding status started for and removing the cluster instance"
+ cluster.getClusterId());
cluster.removeInstanceContext(event.getInstanceId());
TopologyManager.updateTopology(topology);
// publishing data
ClusterInstanceTerminatedEvent clusterTerminatedEvent =
new ClusterInstanceTerminatedEvent(
event.getAppId(),
event.getServiceName(),
event.getClusterId(),
event.getInstanceId());
TopologyEventPublisher.sendClusterTerminatedEvent(clusterTerminatedEvent);
} else {
log.error(
String.format(
"Cluster state transition is not valid: [cluster-id] %s "
+ " [instance-id] %s [current-status] %s [status-requested] %s",
event.getClusterId(), event.getInstanceId(), context.getStatus(), status));
return;
}
} finally {
TopologyManager.releaseWriteLock();
}
}
public static void handleClusterTerminatingEvent(ClusterStatusClusterTerminatingEvent event) {
TopologyManager.acquireWriteLock();
try {
Topology topology = TopologyManager.getTopology();
Cluster cluster =
topology.getService(event.getServiceName()).getCluster(event.getClusterId());
if (!cluster.isStateTransitionValid(ClusterStatus.Terminating, event.getInstanceId())) {
log.error(
"Invalid state transfer from "
+ cluster.getStatus(event.getInstanceId())
+ " to "
+ ClusterStatus.Terminating);
}
ClusterInstance context = cluster.getInstanceContexts(event.getInstanceId());
if (context == null) {
log.warn(
"Cluster Instance Context is not found for [cluster] "
+ event.getClusterId()
+ " [instance-id] "
+ event.getInstanceId());
return;
}
ClusterStatus status = ClusterStatus.Terminating;
if (context.isStateTransitionValid(status)) {
context.setStatus(status);
log.info("Cluster Terminating started for " + cluster.getClusterId());
TopologyManager.updateTopology(topology);
// publishing data
ClusterInstanceTerminatingEvent clusterTerminaingEvent =
new ClusterInstanceTerminatingEvent(
event.getAppId(),
event.getServiceName(),
event.getClusterId(),
event.getInstanceId());
TopologyEventPublisher.sendClusterTerminatingEvent(clusterTerminaingEvent);
// Remove kubernetes services if available
ClusterContext clusterContext =
CloudControllerContext.getInstance().getClusterContext(event.getClusterId());
if (StringUtils.isNotBlank(clusterContext.getKubernetesClusterId())) {
KubernetesIaas.removeKubernetesServices(event.getAppId(), event.getClusterId());
}
} else {
log.error(
String.format(
"Cluster state transition is not valid: [cluster-id] %s "
+ " [instance-id] %s [current-status] %s [status-requested] %s",
event.getClusterId(), event.getInstanceId(), context.getStatus(), status));
}
} finally {
TopologyManager.releaseWriteLock();
}
}
public static void handleMemberMaintenance(
InstanceMaintenanceModeEvent instanceMaintenanceModeEvent)
throws InvalidMemberException, InvalidCartridgeTypeException {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(instanceMaintenanceModeEvent.getServiceName());
// update the status of the member
if (service == null) {
log.warn(
String.format(
"Service %s does not exist", instanceMaintenanceModeEvent.getServiceName()));
return;
}
Cluster cluster = service.getCluster(instanceMaintenanceModeEvent.getClusterId());
if (cluster == null) {
log.warn(
String.format("Cluster %s does not exist", instanceMaintenanceModeEvent.getClusterId()));
return;
}
Member member = cluster.getMember(instanceMaintenanceModeEvent.getMemberId());
if (member == null) {
log.warn(
String.format("Member %s does not exist", instanceMaintenanceModeEvent.getMemberId()));
return;
}
MemberMaintenanceModeEvent memberMaintenanceModeEvent =
new MemberMaintenanceModeEvent(
instanceMaintenanceModeEvent.getServiceName(),
instanceMaintenanceModeEvent.getClusterId(),
instanceMaintenanceModeEvent.getClusterInstanceId(),
instanceMaintenanceModeEvent.getMemberId(),
instanceMaintenanceModeEvent.getNetworkPartitionId(),
instanceMaintenanceModeEvent.getPartitionId());
try {
TopologyManager.acquireWriteLock();
// try update lifecycle state
if (!member.isStateTransitionValid(MemberStatus.In_Maintenance)) {
log.error(
"Invalid State Transition from "
+ member.getStatus()
+ " to "
+ MemberStatus.In_Maintenance);
return;
}
member.setStatus(MemberStatus.In_Maintenance);
log.info("member maintenance mode event adding status started");
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
// publishing data
TopologyEventPublisher.sendMemberMaintenanceModeEvent(memberMaintenanceModeEvent);
}
public static void handleClusterInstanceCreated(
String serviceType,
String clusterId,
String alias,
String instanceId,
String partitionId,
String networkPartitionId) {
TopologyManager.acquireWriteLock();
try {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(serviceType);
if (service == null) {
log.error(
"Service "
+ serviceType
+ " not found in Topology, unable to update the cluster status to Created");
return;
}
Cluster cluster = service.getCluster(clusterId);
if (cluster == null) {
log.error(
"Cluster "
+ clusterId
+ " not found in Topology, unable to update "
+ "status to Created");
return;
}
if (cluster.getInstanceContexts(instanceId) != null) {
log.warn(
"The Instance context for the cluster already exists for [cluster] "
+ clusterId
+ " [instance-id] "
+ instanceId);
return;
}
ClusterInstance clusterInstance = new ClusterInstance(alias, clusterId, instanceId);
clusterInstance.setNetworkPartitionId(networkPartitionId);
clusterInstance.setPartitionId(partitionId);
cluster.addInstanceContext(instanceId, clusterInstance);
TopologyManager.updateTopology(topology);
ClusterInstanceCreatedEvent clusterInstanceCreatedEvent =
new ClusterInstanceCreatedEvent(serviceType, clusterId, clusterInstance);
clusterInstanceCreatedEvent.setPartitionId(partitionId);
TopologyEventPublisher.sendClusterInstanceCreatedEvent(clusterInstanceCreatedEvent);
} finally {
TopologyManager.releaseWriteLock();
}
}
public static void handleApplicationClustersCreated(String appId, List<Cluster> appClusters) {
TopologyManager.acquireWriteLock();
try {
Topology topology = TopologyManager.getTopology();
for (Cluster cluster : appClusters) {
Service service = topology.getService(cluster.getServiceName());
if (service == null) {
log.error(
"Service "
+ cluster.getServiceName()
+ " not found in Topology, unable to create Application cluster");
} else {
service.addCluster(cluster);
log.info("Application Cluster " + cluster.getClusterId() + " created in CC topology");
}
}
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
log.debug("Creating cluster port mappings: [appication-id] " + appId);
for (Cluster cluster : appClusters) {
String cartridgeType = cluster.getServiceName();
Cartridge cartridge = CloudControllerContext.getInstance().getCartridge(cartridgeType);
if (cartridge == null) {
throw new CloudControllerException(
"Cartridge not found: [cartridge-type] " + cartridgeType);
}
for (PortMapping portMapping : cartridge.getPortMappings()) {
ClusterPortMapping clusterPortMapping =
new ClusterPortMapping(
appId,
cluster.getClusterId(),
portMapping.getName(),
portMapping.getProtocol(),
portMapping.getPort(),
portMapping.getProxyPort());
if (portMapping.getKubernetesPortType() != null) {
clusterPortMapping.setKubernetesServiceType(portMapping.getKubernetesPortType());
}
CloudControllerContext.getInstance().addClusterPortMapping(clusterPortMapping);
log.debug("Cluster port mapping created: " + clusterPortMapping.toString());
}
}
// Persist cluster port mappings
CloudControllerContext.getInstance().persist();
// Send application clusters created event
TopologyEventPublisher.sendApplicationClustersCreated(appId, appClusters);
}
public static void handleApplicationClustersRemoved(
String appId, Set<ClusterDataHolder> clusterData) {
TopologyManager.acquireWriteLock();
List<Cluster> removedClusters = new ArrayList<Cluster>();
CloudControllerContext context = CloudControllerContext.getInstance();
try {
Topology topology = TopologyManager.getTopology();
if (clusterData != null) {
// remove clusters from CC topology model and remove runtime information
for (ClusterDataHolder aClusterData : clusterData) {
Service aService = topology.getService(aClusterData.getServiceType());
if (aService != null) {
removedClusters.add(aService.removeCluster(aClusterData.getClusterId()));
} else {
log.warn(
"Service "
+ aClusterData.getServiceType()
+ " not found, "
+ "unable to remove Cluster "
+ aClusterData.getClusterId());
}
// remove runtime data
context.removeClusterContext(aClusterData.getClusterId());
log.info(
"Removed application [ "
+ appId
+ " ]'s Cluster "
+ "[ "
+ aClusterData.getClusterId()
+ " ] from the topology");
}
// persist runtime data changes
CloudControllerContext.getInstance().persist();
} else {
log.info("No cluster data found for application " + appId + " to remove");
}
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
// Remove cluster port mappings of application
CloudControllerContext.getInstance().removeClusterPortMappings(appId);
CloudControllerContext.getInstance().persist();
TopologyEventPublisher.sendApplicationClustersRemoved(appId, clusterData);
}
public void act() {
Message message_NF;
Message message_LFF;
Message message_LFS;
// Link failure handling
if (failure_type == Link_F) {
message_LFF = new Message(Values.interruptMessage, Values.ReachLoss, second_node);
kernel.schedule(
new ArrivalEventV2(first_node, message_LFF, kernel, GetTime.getNextSchedule(kernel)));
message_LFS = new Message(Values.interruptMessage, Values.ReachLoss, first_node);
kernel.schedule(
new ArrivalEventV2(second_node, message_LFS, kernel, GetTime.getNextSchedule(kernel)));
}
// Node failure handling
else {
if (failure_type == Node_F) {
NodeV2 Failed_Node = Topology.getNodeByAddressV2(failed_node);
adjacenes = (TIntArrayList) (Failed_Node.getAdjacenes().clone());
Failed_Node.eraseState();
message_NF = new Message(Values.interruptMessage, Values.ReachLoss, failed_node);
for (int i = 0; i < adjacenes.size(); i++) {
kernel.schedule(
new ArrivalEventV2(
adjacenes.get(i), message_NF, kernel, GetTime.getNextSchedule(kernel)));
}
} else {
}
}
}
/**
* Update token map with a set of token/endpoint pairs in normal state.
*
* <p>Prefer this whenever there are multiple pairs to update, as each update (whether a single or
* multiple) is expensive (CASSANDRA-3831).
*
* @param endpointTokens
*/
public void updateNormalTokens(Multimap<InetAddress, Token> endpointTokens) {
if (endpointTokens.isEmpty()) return;
lock.writeLock().lock();
try {
boolean shouldSortTokens = false;
for (InetAddress endpoint : endpointTokens.keySet()) {
Collection<Token> tokens = endpointTokens.get(endpoint);
assert tokens != null && !tokens.isEmpty();
bootstrapTokens.removeValue(endpoint);
tokenToEndpointMap.removeValue(endpoint);
topology.addEndpoint(endpoint);
leavingEndpoints.remove(endpoint);
removeFromMoving(endpoint); // also removing this endpoint from moving
for (Token token : tokens) {
InetAddress prev = tokenToEndpointMap.put(token, endpoint);
if (!endpoint.equals(prev)) {
if (prev != null)
logger.warn("Token {} changing ownership from {} to {}", token, prev, endpoint);
shouldSortTokens = true;
}
}
}
if (shouldSortTokens) sortedTokens = sortTokens();
} finally {
lock.writeLock().unlock();
}
}
/**
* Remove member from topology and send member terminated event.
*
* @param serviceName
* @param clusterId
* @param networkPartitionId
* @param partitionId
* @param memberId
*/
public static void handleMemberTerminated(
String serviceName,
String clusterId,
String networkPartitionId,
String partitionId,
String memberId) {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(serviceName);
Properties properties;
if (service == null) {
log.warn(String.format("Service %s does not exist", serviceName));
return;
}
Cluster cluster = service.getCluster(clusterId);
if (cluster == null) {
log.warn(String.format("Cluster %s does not exist", clusterId));
return;
}
Member member = cluster.getMember(memberId);
if (member == null) {
log.warn(String.format("Member %s does not exist", memberId));
return;
}
String clusterInstanceId = member.getClusterInstanceId();
try {
TopologyManager.acquireWriteLock();
properties = member.getProperties();
cluster.removeMember(member);
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
/* @TODO leftover from grouping_poc*/
String groupAlias = null;
TopologyEventPublisher.sendMemberTerminatedEvent(
serviceName,
clusterId,
memberId,
clusterInstanceId,
networkPartitionId,
partitionId,
properties,
groupAlias);
}
/**
* Create a ServerLocatorImpl using a static list of live servers
*
* @param transportConfigs
*/
public ServerLocatorImpl(final boolean useHA, final TransportConfiguration... transportConfigs) {
this(new Topology(null), useHA, null, transportConfigs);
if (useHA) {
// We only set the owner at where the Topology was created.
// For that reason we can't set it at the main constructor
topology.setOwner(this);
}
}
public void notifyNodeUp(
long uniqueEventID,
final String nodeID,
final Pair<TransportConfiguration, TransportConfiguration> connectorPair,
final boolean last) {
if (!ha) {
// there's no topology
return;
}
if (HornetQLogger.LOGGER.isDebugEnabled()) {
HornetQLogger.LOGGER.debug(
"NodeUp " + this + "::nodeID=" + nodeID + ", connectorPair=" + connectorPair,
new Exception("trace"));
}
TopologyMember member = new TopologyMember(connectorPair.getA(), connectorPair.getB());
topology.updateMember(uniqueEventID, nodeID, member);
TopologyMember actMember = topology.getMember(nodeID);
if (actMember != null
&& actMember.getConnector().getA() != null
&& actMember.getConnector().getB() != null) {
HashSet<ClientSessionFactory> clonedFactories = new HashSet<ClientSessionFactory>();
synchronized (factories) {
clonedFactories.addAll(factories);
}
for (ClientSessionFactory factory : clonedFactories) {
((ClientSessionFactoryInternal) factory)
.setBackupConnector(actMember.getConnector().getA(), actMember.getConnector().getB());
}
}
updateArraysAndPairs();
if (last) {
synchronized (this) {
receivedTopology = true;
// Notify if waiting on getting topology
notifyAll();
}
}
}
/** Create a ServerLocatorImpl using UDP discovery to lookup cluster */
public ServerLocatorImpl(
final boolean useHA, final DiscoveryGroupConfiguration groupConfiguration) {
this(new Topology(null), useHA, groupConfiguration, null);
if (useHA) {
// We only set the owner at where the Topology was created.
// For that reason we can't set it at the main constructor
topology.setOwner(this);
}
}
/**
* Add member object to the topology and publish member created event
*
* @param memberContext
*/
public static void handleMemberCreatedEvent(MemberContext memberContext) {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(memberContext.getCartridgeType());
String clusterId = memberContext.getClusterId();
Cluster cluster = service.getCluster(clusterId);
String memberId = memberContext.getMemberId();
String clusterInstanceId = memberContext.getClusterInstanceId();
String networkPartitionId = memberContext.getNetworkPartitionId();
String partitionId = memberContext.getPartition().getId();
String lbClusterId = memberContext.getLbClusterId();
long initTime = memberContext.getInitTime();
if (cluster.memberExists(memberId)) {
log.warn(String.format("Member %s already exists", memberId));
return;
}
try {
TopologyManager.acquireWriteLock();
Member member =
new Member(
service.getServiceName(),
clusterId,
memberId,
clusterInstanceId,
networkPartitionId,
partitionId,
memberContext.getLoadBalancingIPType(),
initTime);
member.setStatus(MemberStatus.Created);
member.setLbClusterId(lbClusterId);
member.setProperties(CloudControllerUtil.toJavaUtilProperties(memberContext.getProperties()));
cluster.addMember(member);
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
TopologyEventPublisher.sendMemberCreatedEvent(memberContext);
}
public synchronized void connectorsChanged() {
List<DiscoveryEntry> newConnectors = discoveryGroup.getDiscoveryEntries();
TransportConfiguration[] newInitialconnectors =
(TransportConfiguration[])
Array.newInstance(TransportConfiguration.class, newConnectors.size());
int count = 0;
for (DiscoveryEntry entry : newConnectors) {
newInitialconnectors[count++] = entry.getConnector();
if (ha && topology.getMember(entry.getNodeID()) == null) {
TopologyMember member = new TopologyMember(entry.getConnector(), null);
// on this case we set it as zero as any update coming from server should be accepted
topology.updateMember(0, entry.getNodeID(), member);
}
}
this.initialConnectors = newInitialconnectors;
if (clusterConnection && !receivedTopology && initialConnectors.length > 0) {
// The node is alone in the cluster. We create a connection to the new node
// to trigger the node notification to form the cluster.
Runnable connectRunnable =
new Runnable() {
public void run() {
try {
connect();
} catch (HornetQException e) {
HornetQLogger.LOGGER.errorConnectingToNodes(e);
}
}
};
if (startExecutor != null) {
startExecutor.execute(connectRunnable);
} else {
connectRunnable.run();
}
}
}
@SuppressWarnings("unchecked")
private synchronized void updateArraysAndPairs() {
Collection<TopologyMember> membersCopy = topology.getMembers();
topologyArray =
(Pair<TransportConfiguration, TransportConfiguration>[])
Array.newInstance(Pair.class, membersCopy.size());
int count = 0;
for (TopologyMember pair : membersCopy) {
topologyArray[count++] = pair.getConnector();
}
}
/** used by tests */
public void clearUnsafe() {
lock.writeLock().lock();
try {
bootstrapTokens.clear();
tokenToEndpointMap.clear();
topology.clear();
leavingEndpoints.clear();
pendingRanges.clear();
endpointToHostIdMap.clear();
invalidateCachedRings();
} finally {
lock.writeLock().unlock();
}
}
public void removeEndpoint(InetAddress endpoint) {
assert endpoint != null;
lock.writeLock().lock();
try {
bootstrapTokens.removeValue(endpoint);
tokenToEndpointMap.removeValue(endpoint);
topology.removeEndpoint(endpoint);
leavingEndpoints.remove(endpoint);
endpointToHostIdMap.remove(endpoint);
sortedTokens = sortTokens();
invalidateCachedRings();
} finally {
lock.writeLock().unlock();
}
}
private void addFactory(ClientSessionFactoryInternal factory) {
if (factory == null) {
return;
}
if (isClosed()) {
factory.close();
return;
}
TransportConfiguration backup = null;
if (ha) {
backup = topology.getBackupForConnector(factory.getConnectorConfiguration());
}
factory.setBackupConnector(factory.getConnectorConfiguration(), backup);
synchronized (factories) {
factories.add(factory);
}
}
public void removeClusterTopologyListener(final ClusterTopologyListener listener) {
topology.removeClusterTopologyListener(listener);
}
public void addClusterTopologyListener(final ClusterTopologyListener listener) {
topology.addClusterTopologyListener(listener);
}
public static void handleMemberActivated(InstanceActivatedEvent instanceActivatedEvent) {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(instanceActivatedEvent.getServiceName());
if (service == null) {
log.warn(String.format("Service %s does not exist", instanceActivatedEvent.getServiceName()));
return;
}
Cluster cluster = service.getCluster(instanceActivatedEvent.getClusterId());
if (cluster == null) {
log.warn(String.format("Cluster %s does not exist", instanceActivatedEvent.getClusterId()));
return;
}
Member member = cluster.getMember(instanceActivatedEvent.getMemberId());
if (member == null) {
log.warn(String.format("Member %s does not exist", instanceActivatedEvent.getMemberId()));
return;
}
MemberActivatedEvent memberActivatedEvent =
new MemberActivatedEvent(
instanceActivatedEvent.getServiceName(),
instanceActivatedEvent.getClusterId(),
instanceActivatedEvent.getClusterInstanceId(),
instanceActivatedEvent.getMemberId(),
instanceActivatedEvent.getNetworkPartitionId(),
instanceActivatedEvent.getPartitionId());
// grouping - set grouid
// TODO
memberActivatedEvent.setApplicationId(null);
try {
TopologyManager.acquireWriteLock();
// try update lifecycle state
if (!member.isStateTransitionValid(MemberStatus.Active)) {
log.error(
"Invalid state transition from ["
+ member.getStatus()
+ "] to ["
+ MemberStatus.Active
+ "]");
return;
} else {
member.setStatus(MemberStatus.Active);
// Set member ports
try {
Cartridge cartridge =
CloudControllerContext.getInstance().getCartridge(service.getServiceName());
if (cartridge == null) {
throw new RuntimeException(
String.format(
"Cartridge not found: [cartridge-type] %s", service.getServiceName()));
}
Port port;
int portValue;
List<PortMapping> portMappings = Arrays.asList(cartridge.getPortMappings());
String clusterId = cluster.getClusterId();
ClusterContext clusterContext =
CloudControllerContext.getInstance().getClusterContext(clusterId);
List<KubernetesService> kubernetesServices = clusterContext.getKubernetesServices();
for (PortMapping portMapping : portMappings) {
if (kubernetesServices != null) {
portValue = findKubernetesServicePort(clusterId, kubernetesServices, portMapping);
} else {
portValue = portMapping.getPort();
}
port = new Port(portMapping.getProtocol(), portValue, portMapping.getProxyPort());
member.addPort(port);
memberActivatedEvent.addPort(port);
}
} catch (Exception e) {
String message =
String.format(
"Could not add member ports: [service-name] %s [member-id] %s",
memberActivatedEvent.getServiceName(), memberActivatedEvent.getMemberId());
log.error(message, e);
}
// Set member ip addresses
memberActivatedEvent.setDefaultPrivateIP(member.getDefaultPrivateIP());
memberActivatedEvent.setMemberPrivateIPs(member.getMemberPrivateIPs());
memberActivatedEvent.setDefaultPublicIP(member.getDefaultPublicIP());
memberActivatedEvent.setMemberPublicIPs(member.getMemberPublicIPs());
TopologyManager.updateTopology(topology);
// Publish member activated event
TopologyEventPublisher.sendMemberActivatedEvent(memberActivatedEvent);
// Publish statistics data
BAMUsageDataPublisher.publish(
memberActivatedEvent.getMemberId(),
memberActivatedEvent.getPartitionId(),
memberActivatedEvent.getNetworkPartitionId(),
memberActivatedEvent.getClusterId(),
memberActivatedEvent.getServiceName(),
MemberStatus.Active.toString(),
null);
}
} finally {
TopologyManager.releaseWriteLock();
}
}
@SuppressWarnings("empty-statement")
public GenericTest() {
try {
// setup environment
simLogger = SimLogger.getInstance(SimLogger.INFO);
Topology topology = new Topology();
SimulationEngine simEngine = new SimulationEngine(topology);
simEngine.setInstance(simEngine);
// specify Topology matrices for test nodes to send and receive
// WAN: three subnets interconnected by network #1 router
topology.setNumberOfSubnets(3);
topology.setDiameter(2);
int links[][] = {{0}, {0, 0, 1544, 384}, {0, 1544, 0, 0}, {0, 384, 0, 0}};
topology.setLinksMatrix(links);
byte exitInterfaces[][] = {{0}, {0, 0, 1, 2}, {0, 3, 0, 0}, {0, 4, 0, 0}};
topology.setExitInterfacesMatrix(1, exitInterfaces);
int[][] routingMatrix = {{0}, {0, 1, 2, 3}, {0, 1, 2, 1}, {0, 1, 1, 3}};
topology.setStaticRoutingMatrix(routingMatrix);
// setup LAN:
// subnet 1 has two hosts; subnets 2 and 3 have one host
// all subnets are 100 MB/s contention LANs
int[] lanTypes = {0, 1, 1, 1};
topology.setLanTypes(lanTypes);
int[] subnetHostCount = {0, 2, 1, 1};
topology.setSubnetHostCount(subnetHostCount);
int[] subnetDataRate = {0, 100, 100, 100};
topology.setSubnetDataRate(subnetDataRate);
byte[][] lanInterfaces = {{0}, {0, 51, 52, 53}, {0, 54, 55}, {0, 56, 57}};
topology.setLanInterfacesMatrix(lanInterfaces);
topology.findTotalNumberOfHosts();
// setup print layers
topology.setPrintAtLayer(2);
topology.setPrintAtLayer(3);
topology.setPrintAtLayer(5);
// print out the new topology and load it into simulator
topology.printTopology();
// load the configuration into simulator
if (!simEngine.loadConfiguration()) {
simLogger.logWarn("Configuration Error");
return;
}
ConnectivityMatrix cm = simEngine.getConnectivityMatrix();
simLogger.setPrintAtLayers(topology.getPrintAtLayers());
// set hostnames for printout
Router router1 = (Router) cm.getHost(1, 1);
router1.setName("router-1.1");
Host host1_2 = (Host) cm.getHost(1, 2);
host1_2.setName("host-1.2");
Host host1_3 = (Host) cm.getHost(1, 3);
host1_3.setName("host-1.3");
Router router2 = (Router) cm.getHost(2, 1);
router2.setName("router-2.1");
Host host2_2 = (Host) cm.getHost(2, 2);
host2_2.setName("host-2.2");
Router router3 = (Router) cm.getHost(3, 1);
router3.setName("router-3.1");
Host host3_2 = (Host) cm.getHost(3, 2);
host3_2.setName("host-3.2");
// send 10 messages over unreliable transport from host 1.2 to host 1.3, via LAN
for (int i = 1; i <= 10; i++) {
host1_2.sendMessage(i + " 1.2 Watson are you there?", 1, 3, Message.UNRELIABLE);
}
// send 10 messages over unreliable transport from host 1.3 to host 1.2, via LAN
for (int i = 1; i <= 10; i++) {
host1_3.sendMessage(i + " 1.3 Yep I'm here.", 1, 2, Message.UNRELIABLE);
}
// send 10 messages over unreliable transport from host 1.2 to host 2.2, via WAN (1 hop)
for (int i = 1; i <= 10; i++) {
host1_2.sendMessage(i + " 1.2 Watson are you there?", 2, 2, Message.UNRELIABLE);
}
// send 10 messages over unreliable transport from host 2.2 to host 1.2, via WAN (1 hop)
for (int i = 1; i <= 10; i++) {
host2_2.sendMessage(i + " 2.2 Yep I'm here.", 1, 2, Message.UNRELIABLE);
}
// send 10 messages over unreliable transport from host 2.2 to host 3.2, via WAN (2 hops)
for (int i = 1; i <= 10; i++) {
host2_2.sendMessage(i + " 2.2 Watson are you there?", 3, 2, Message.UNRELIABLE);
}
// send 10 messages over unreliable transport from host 3.2 to host 2.2, via WAN (2 hops)
for (int i = 1; i <= 10; i++) {
host3_2.sendMessage(i + " 3.2 Yep I'm here.", 2, 2, Message.UNRELIABLE);
}
// send 10 messages over unreliable transport from host 1.1 to host 2.1, via WAN (1 hop)
for (int i = 1; i <= 10; i++) {
router1.sendMessage(i + " 1.1 Watson are you there?", 2, 1, Message.UNRELIABLE);
}
// execute the simulation
DiscreteEventSimulator des = simEngine.getDes();
while (des.nextEvent()) ;
// print out connectivity matrix
System.out.println("\nConfiguration:\n" + cm.toString());
// print out host statistics
System.out.println("\nStatistics for Simulation:");
System.out.println("Router node 1.1 LAN:");
System.out.println(router1.getLanInterface().getStatistics().toString());
System.out.println("Router node 1.1 link to 2.1:");
System.out.println(router1.getLinkInterfaceById(1).getStatistics().toString());
System.out.println("Router node 1.1 link to 3.1:");
System.out.println(router1.getLinkInterfaceById(2).getStatistics().toString());
System.out.println("Host node 1.2:");
System.out.println(host1_2.getLanInterface().getStatistics().toString());
System.out.println("Host node 1.3:");
System.out.println(host1_3.getLanInterface().getStatistics().toString());
System.out.println("Router node 2.1 LAN:");
System.out.println(router2.getLanInterface().getStatistics().toString());
System.out.println("Router node 2.1 link to 1.1:");
System.out.println(router2.getLinkInterfaceById(3).getStatistics().toString());
System.out.println("Host node 2.2:");
System.out.println(host2_2.getLanInterface().getStatistics().toString());
System.out.println("Router node 3.1 LAN:");
System.out.println(router3.getLinkInterfaceById(4).getStatistics().toString());
System.out.println("Router node 3.1 link to 1.1):");
System.out.println(router3.getLanInterface().getStatistics().toString());
System.out.println("Host node 3.2:");
System.out.println(host3_2.getLanInterface().getStatistics().toString());
simLogger.logStats("Configuration:\n" + cm.toString());
simLogger.logInfo("Simulation Finished");
simLogger.close();
} catch (Exception e) {
System.err.println("Exception in GenericTest:" + e.getMessage());
simLogger.logException(e);
}
} // end GenericTest constructor
private boolean doProcess(MemberMaintenanceModeEvent event, Topology topology) {
String serviceName = event.getServiceName();
String clusterId = event.getClusterId();
// Apply service filter
if (TopologyServiceFilter.apply(serviceName)) {
return false;
}
// Apply cluster filter
if (TopologyClusterFilter.apply(clusterId)) {
return false;
}
// Validate event against the existing topology
Service service = topology.getService(event.getServiceName());
if (service == null) {
if (log.isWarnEnabled()) {
log.warn(String.format("Service does not exist: [service] %s", event.getServiceName()));
}
return false;
}
Cluster cluster = service.getCluster(event.getClusterId());
if (cluster == null) {
if (log.isWarnEnabled()) {
log.warn(
String.format(
"Cluster does not exist: [service] %s [cluster] %s",
event.getServiceName(), event.getClusterId()));
}
return false;
}
// Apply application filter
if (TopologyApplicationFilter.apply(cluster.getAppId())) {
return false;
}
Member member = cluster.getMember(event.getMemberId());
if (member == null) {
if (log.isWarnEnabled()) {
log.warn(
String.format(
"Member does not exist: [service] %s [cluster] %s [member] %s",
event.getServiceName(), event.getClusterId(), event.getMemberId()));
}
return false;
}
// Apply member filter
if (TopologyMemberFilter.apply(member.getLbClusterId(), member.getNetworkPartitionId())) {
return false;
}
if (member.getStatus() == MemberStatus.In_Maintenance) {
if (log.isDebugEnabled()) {
log.debug(
String.format(
"Member already updated as In_Maintenance: "
+ "[service] %s [cluster] %s [member] %s",
event.getServiceName(), event.getClusterId(), event.getMemberId()));
}
} else {
// Apply changes to the topology
if (!member.isStateTransitionValid(MemberStatus.In_Maintenance)) {
log.error(
"Invalid State Transition from "
+ member.getStatus()
+ " to "
+ MemberStatus.In_Maintenance);
}
member.setStatus(MemberStatus.In_Maintenance);
if (log.isInfoEnabled()) {
log.info(
String.format(
"Member updated as In_Maintenance: [service] %s [cluster] %s [member] %s",
event.getServiceName(), event.getClusterId(), event.getMemberId()));
}
}
// Notify event listeners
notifyEventListeners(event);
return true;
}
@Before
public void setUp() throws Exception {
serverAddress = application.getConfiguration().getServerAddress();
topology.remove(clientAddress, serverAddress).await();
}
public static void handleClusterActivatedEvent(
ClusterStatusClusterActivatedEvent clusterStatusClusterActivatedEvent) {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(clusterStatusClusterActivatedEvent.getServiceName());
// update the status of the cluster
if (service == null) {
log.warn(
String.format(
"Service %s does not exist", clusterStatusClusterActivatedEvent.getServiceName()));
return;
}
Cluster cluster = service.getCluster(clusterStatusClusterActivatedEvent.getClusterId());
if (cluster == null) {
log.warn(
String.format(
"Cluster %s does not exist", clusterStatusClusterActivatedEvent.getClusterId()));
return;
}
String clusterId = cluster.getClusterId();
ClusterContext clusterContext =
CloudControllerContext.getInstance().getClusterContext(clusterId);
if (clusterContext == null) {
log.warn("Cluster context not found: [cluster-id] " + clusterId);
return;
}
ClusterInstanceActivatedEvent clusterInstanceActivatedEvent =
new ClusterInstanceActivatedEvent(
clusterStatusClusterActivatedEvent.getAppId(),
clusterStatusClusterActivatedEvent.getServiceName(),
clusterStatusClusterActivatedEvent.getClusterId(),
clusterStatusClusterActivatedEvent.getInstanceId());
try {
TopologyManager.acquireWriteLock();
List<KubernetesService> kubernetesServices = clusterContext.getKubernetesServices();
cluster.setKubernetesServices(kubernetesServices);
if (kubernetesServices != null) {
// Set kubernetes services
cluster.setKubernetesServices(kubernetesServices);
try {
// Generate access URLs for kubernetes services
for (KubernetesService kubernetesService : kubernetesServices) {
if (kubernetesService.getServiceType().equals(KubernetesConstants.NODE_PORT)) {
// Public IP = Kubernetes minion public IP
String[] publicIPs = kubernetesService.getPublicIPs();
if ((publicIPs != null) && (publicIPs.length > 0)) {
for (String publicIP : publicIPs) {
// There can be a String array with null values
if (publicIP != null) {
// Using type URI since only http, https, ftp, file, jar protocols are supported
// in URL
URI accessURL =
new URI(
kubernetesService.getProtocol(),
null,
publicIP,
kubernetesService.getPort(),
null,
null,
null);
cluster.addAccessUrl(accessURL.toString());
clusterInstanceActivatedEvent.addAccessUrl(accessURL.toString());
} else {
log.error(
String.format(
"Could not create access URL for [Kubernetes-service] %s , "
+ "since Public IP is not available",
kubernetesService.getId()));
}
}
}
}
}
} catch (URISyntaxException e) {
log.error("Could not create access URLs for Kubernetes services", e);
}
}
ClusterInstance context =
cluster.getInstanceContexts(clusterStatusClusterActivatedEvent.getInstanceId());
if (context == null) {
log.warn(
"Cluster instance context is not found for [cluster] "
+ clusterStatusClusterActivatedEvent.getClusterId()
+ " [instance-id] "
+ clusterStatusClusterActivatedEvent.getInstanceId());
return;
}
ClusterStatus status = ClusterStatus.Active;
if (context.isStateTransitionValid(status)) {
context.setStatus(status);
log.info("Cluster activated adding status started for " + cluster.getClusterId());
TopologyManager.updateTopology(topology);
// publish event
TopologyEventPublisher.sendClusterActivatedEvent(clusterInstanceActivatedEvent);
} else {
log.error(
String.format(
"Cluster state transition is not valid: [cluster-id] %s "
+ " [instance-id] %s [current-status] %s [status-requested] %s",
clusterStatusClusterActivatedEvent.getClusterId(),
clusterStatusClusterActivatedEvent.getInstanceId(),
context.getStatus(),
status));
return;
}
} finally {
TopologyManager.releaseWriteLock();
}
}
public static void handleMemberReadyToShutdown(
InstanceReadyToShutdownEvent instanceReadyToShutdownEvent)
throws InvalidMemberException, InvalidCartridgeTypeException {
Topology topology = TopologyManager.getTopology();
Service service = topology.getService(instanceReadyToShutdownEvent.getServiceName());
// update the status of the member
if (service == null) {
log.warn(
String.format(
"Service %s does not exist", instanceReadyToShutdownEvent.getServiceName()));
return;
}
Cluster cluster = service.getCluster(instanceReadyToShutdownEvent.getClusterId());
if (cluster == null) {
log.warn(
String.format("Cluster %s does not exist", instanceReadyToShutdownEvent.getClusterId()));
return;
}
Member member = cluster.getMember(instanceReadyToShutdownEvent.getMemberId());
if (member == null) {
log.warn(
String.format("Member %s does not exist", instanceReadyToShutdownEvent.getMemberId()));
return;
}
MemberReadyToShutdownEvent memberReadyToShutdownEvent =
new MemberReadyToShutdownEvent(
instanceReadyToShutdownEvent.getServiceName(),
instanceReadyToShutdownEvent.getClusterId(),
instanceReadyToShutdownEvent.getClusterInstanceId(),
instanceReadyToShutdownEvent.getMemberId(),
instanceReadyToShutdownEvent.getNetworkPartitionId(),
instanceReadyToShutdownEvent.getPartitionId());
try {
TopologyManager.acquireWriteLock();
if (!member.isStateTransitionValid(MemberStatus.ReadyToShutDown)) {
log.error(
"Invalid State Transition from "
+ member.getStatus()
+ " to "
+ MemberStatus.ReadyToShutDown);
return;
}
member.setStatus(MemberStatus.ReadyToShutDown);
log.info("Member Ready to shut down event adding status started");
TopologyManager.updateTopology(topology);
} finally {
TopologyManager.releaseWriteLock();
}
TopologyEventPublisher.sendMemberReadyToShutdownEvent(memberReadyToShutdownEvent);
// publishing data
BAMUsageDataPublisher.publish(
instanceReadyToShutdownEvent.getMemberId(),
instanceReadyToShutdownEvent.getPartitionId(),
instanceReadyToShutdownEvent.getNetworkPartitionId(),
instanceReadyToShutdownEvent.getClusterId(),
instanceReadyToShutdownEvent.getServiceName(),
MemberStatus.ReadyToShutDown.toString(),
null);
// termination of particular instance will be handled by autoscaler
}
