Java tutorial
/* * Licensed to the Apache Software Foundation (ASF) under one or more contributor license * agreements. See the NOTICE file distributed with this work for additional information regarding * copyright ownership. The ASF licenses this file to You 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.apache.geode.management.internal.beans; import java.lang.reflect.Type; import java.util.ArrayList; import java.util.HashMap; import java.util.List; import java.util.Map; import java.util.Set; import javax.management.InstanceNotFoundException; import javax.management.MBeanServer; import javax.management.MalformedObjectNameException; import javax.management.Notification; import javax.management.NotificationBroadcasterSupport; import javax.management.ObjectInstance; import javax.management.ObjectName; import org.apache.commons.lang.StringUtils; import org.apache.logging.log4j.Logger; import org.apache.geode.cache.Cache; import org.apache.geode.cache.DiskStore; import org.apache.geode.cache.Region; import org.apache.geode.cache.asyncqueue.AsyncEventQueue; import org.apache.geode.cache.server.CacheServer; import org.apache.geode.cache.wan.GatewayReceiver; import org.apache.geode.cache.wan.GatewaySender; import org.apache.geode.distributed.Locator; import org.apache.geode.distributed.internal.DistributionManager; import org.apache.geode.distributed.internal.InternalDistributedSystem; import org.apache.geode.distributed.internal.InternalLocator; import org.apache.geode.distributed.internal.locks.DLockService; import org.apache.geode.distributed.internal.membership.InternalDistributedMember; import org.apache.geode.internal.ClassLoadUtil; import org.apache.geode.internal.cache.CacheService; import org.apache.geode.internal.cache.InternalCache; import org.apache.geode.internal.cache.LocalRegion; import org.apache.geode.internal.cache.PartitionedRegionHelper; import org.apache.geode.internal.logging.LogService; import org.apache.geode.management.AsyncEventQueueMXBean; import org.apache.geode.management.CacheServerMXBean; import org.apache.geode.management.DiskStoreMXBean; import org.apache.geode.management.GatewayReceiverMXBean; import org.apache.geode.management.GatewaySenderMXBean; import org.apache.geode.management.JMXNotificationType; import org.apache.geode.management.JMXNotificationUserData; import org.apache.geode.management.LocatorMXBean; import org.apache.geode.management.LockServiceMXBean; import org.apache.geode.management.ManagementException; import org.apache.geode.management.ManagementService; import org.apache.geode.management.ManagerMXBean; import org.apache.geode.management.MemberMXBean; import org.apache.geode.management.RegionMXBean; import org.apache.geode.management.internal.AlertDetails; import org.apache.geode.management.internal.FederationComponent; import org.apache.geode.management.internal.MBeanJMXAdapter; import org.apache.geode.management.internal.ManagementConstants; import org.apache.geode.management.internal.SystemManagementService; import org.apache.geode.management.membership.ClientMembership; import org.apache.geode.management.membership.ClientMembershipEvent; import org.apache.geode.management.membership.ClientMembershipListener; import org.apache.geode.management.membership.ClientMembershipListenerAdapter; import org.apache.geode.pdx.internal.PeerTypeRegistration; /** * Acts as an intermediate between MBean layer and Federation Layer. Handles all Call backs from * GemFire to instantiate or remove MBeans from GemFire Domain. * * Even though this class have a lot of utility functions it interacts with the state of the system * and contains some state itself. */ public class ManagementAdapter { private static final Logger logger = LogService.getLogger(); /** Internal ManagementService Instance **/ private SystemManagementService service; /** GemFire Cache impl **/ private InternalCache internalCache; /** Member Name **/ private String memberSource; /** * emitter is a helper class for sending notifications on behalf of the MemberMBean **/ private NotificationBroadcasterSupport memberLevelNotifEmitter; /** The <code>MBeanServer</code> for this application */ public static final MBeanServer mbeanServer = MBeanJMXAdapter.mbeanServer; /** MemberMBean instance **/ private MemberMBean memberBean; private volatile boolean serviceInitialised = false; private MBeanAggregator aggregator; public static final List<Class> refreshOnInit = new ArrayList<>(); public static final List<String> internalLocks = new ArrayList<>(); static { refreshOnInit.add(RegionMXBean.class); refreshOnInit.add(MemberMXBean.class); internalLocks.add(DLockService.DTLS); // From reserved lock service name internalLocks.add(DLockService.LTLS); // From reserved lock service name internalLocks.add(PartitionedRegionHelper.PARTITION_LOCK_SERVICE_NAME); internalLocks.add(PeerTypeRegistration.LOCK_SERVICE_NAME); } protected MemberMBeanBridge memberMBeanBridge; private final Object regionOpLock = new Object(); /** * Adapter life cycle is tied with the Cache . So its better to make all cache level artifacts as * instance variable * * @param cache gemfire cache */ public void handleCacheCreation(InternalCache cache) throws ManagementException { try { this.internalCache = cache; this.service = (SystemManagementService) ManagementService.getManagementService(internalCache); this.memberMBeanBridge = new MemberMBeanBridge(internalCache, service).init(); this.memberBean = new MemberMBean(memberMBeanBridge); this.memberLevelNotifEmitter = memberBean; ObjectName memberMBeanName = MBeanJMXAdapter .getMemberMBeanName(InternalDistributedSystem.getConnectedInstance().getDistributedMember()); memberSource = MBeanJMXAdapter .getMemberNameOrId(internalCache.getDistributedSystem().getDistributedMember()); // Type casting to MemberMXBean to expose only those methods described in // the interface; ObjectName changedMBeanName = service.registerInternalMBean(memberBean, memberMBeanName); service.federate(changedMBeanName, MemberMXBean.class, true); this.serviceInitialised = true; // Service initialised is only for ManagementService and not necessarily // Manager service. // For situations where locator is created before any cache is created if (InternalLocator.hasLocator()) { Locator loc = InternalLocator.getLocator(); handleLocatorStart(loc); } if (cache.getInternalDistributedSystem().getConfig().getJmxManager()) { this.service.createManager(); if (cache.getInternalDistributedSystem().getConfig().getJmxManagerStart()) { this.service.startManager(); } } } finally { if (!serviceInitialised && service != null) { service.close(); if (logger.isDebugEnabled()) { logger.debug("Management Service Could not initialise hence closing"); } } else { if (logger.isDebugEnabled()) { logger.debug("Management Service is initialised and Running"); } } } } /** * Handles all the distributed mbean creation part when a Manager is started */ public void handleManagerStart() throws ManagementException { if (!isServiceInitialised("handleManagerStart")) { return; } MBeanJMXAdapter jmxAdapter = service.getJMXAdapter(); Map<ObjectName, Object> registeredMBeans = jmxAdapter.getLocalGemFireMBean(); DistributedSystemBridge dsBridge = new DistributedSystemBridge(service); this.aggregator = new MBeanAggregator(dsBridge); // register the aggregator for Federation framework to use service.addProxyListener(aggregator); /* * get the local member mbean as it need to be provided to aggregator first */ MemberMXBean localMember = service.getMemberMXBean(); ObjectName memberObjectName = MBeanJMXAdapter .getMemberMBeanName(InternalDistributedSystem.getConnectedInstance().getDistributedMember()); FederationComponent addedComp = service.getLocalManager().getFedComponents().get(memberObjectName); service.afterCreateProxy(memberObjectName, MemberMXBean.class, localMember, addedComp); for (ObjectName objectName : registeredMBeans.keySet()) { if (objectName.equals(memberObjectName)) { continue; } Object object = registeredMBeans.get(objectName); ObjectInstance instance; try { instance = mbeanServer.getObjectInstance(objectName); String className = instance.getClassName(); Class cls = ClassLoadUtil.classFromName(className); Type[] intfTyps = cls.getGenericInterfaces(); FederationComponent newObj = service.getLocalManager().getFedComponents().get(objectName); for (Type intfTyp1 : intfTyps) { Class intfTyp = (Class) intfTyp1; service.afterCreateProxy(objectName, intfTyp, object, newObj); } } catch (InstanceNotFoundException e) { if (logger.isDebugEnabled()) { logger.debug("Failed in Registering distributed mbean "); } throw new ManagementException(e); } catch (ClassNotFoundException e) { if (logger.isDebugEnabled()) { logger.debug("Failed in Registering distributed mbean"); } throw new ManagementException(e); } } } /** * Handles all the clean up activities when a Manager is stopped It clears the distributed mbeans * and underlying data structures */ public void handleManagerStop() throws ManagementException { if (!isServiceInitialised("handleManagerStop")) { return; } MBeanJMXAdapter jmxAdapter = service.getJMXAdapter(); Map<ObjectName, Object> registeredMBeans = jmxAdapter.getLocalGemFireMBean(); ObjectName aggregatemMBeanPattern; try { aggregatemMBeanPattern = new ObjectName(ManagementConstants.AGGREGATE_MBEAN_PATTERN); } catch (MalformedObjectNameException | NullPointerException e1) { throw new ManagementException(e1); } MemberMXBean localMember = service.getMemberMXBean(); ObjectName memberObjectName = MBeanJMXAdapter .getMemberMBeanName(InternalDistributedSystem.getConnectedInstance().getDistributedMember()); FederationComponent removedComp = service.getLocalManager().getFedComponents().get(memberObjectName); service.afterRemoveProxy(memberObjectName, MemberMXBean.class, localMember, removedComp); for (ObjectName objectName : registeredMBeans.keySet()) { if (objectName.equals(memberObjectName)) { continue; } if (aggregatemMBeanPattern.apply(objectName)) { continue; } Object object = registeredMBeans.get(objectName); ObjectInstance instance; try { instance = mbeanServer.getObjectInstance(objectName); String className = instance.getClassName(); Class cls = ClassLoadUtil.classFromName(className); Type[] intfTyps = cls.getGenericInterfaces(); FederationComponent oldObj = service.getLocalManager().getFedComponents().get(objectName); for (Type intfTyp1 : intfTyps) { Class intfTyp = (Class) intfTyp1; service.afterRemoveProxy(objectName, intfTyp, object, oldObj); } } catch (InstanceNotFoundException | ClassNotFoundException e) { logger.warn("Failed to invoke aggregator for {} with exception {}", objectName, e.getMessage(), e); } } service.removeProxyListener(this.aggregator); this.aggregator = null; } /** * Assumption is always cache and MemberMbean has been will be created first */ public void handleManagerCreation() throws ManagementException { if (!isServiceInitialised("handleManagerCreation")) { return; } ObjectName managerMBeanName = MBeanJMXAdapter.getManagerName(); ManagerMBeanBridge bridge = new ManagerMBeanBridge(service); ManagerMXBean bean = new ManagerMBean(bridge); service.registerInternalMBean(bean, managerMBeanName); } /** * Handles Region Creation. This is the call back which will create the specified RegionMXBean and * will send a notification on behalf of Member Mbean * * @param region the region for which the call back is invoked */ public <K, V> void handleRegionCreation(Region<K, V> region) throws ManagementException { if (!isServiceInitialised("handleRegionCreation")) { return; } // Moving region creation operation inside a guarded block // After getting access to regionOpLock it again checks for region // destroy status synchronized (regionOpLock) { LocalRegion localRegion = (LocalRegion) region; if (localRegion.isDestroyed()) { return; } // Bridge is responsible for extracting data from GemFire Layer RegionMBeanBridge<K, V> bridge = RegionMBeanBridge.getInstance(region); RegionMXBean regionMBean = new RegionMBean<>(bridge); ObjectName regionMBeanName = MBeanJMXAdapter.getRegionMBeanName( internalCache.getDistributedSystem().getDistributedMember(), region.getFullPath()); ObjectName changedMBeanName = service.registerInternalMBean(regionMBean, regionMBeanName); service.federate(changedMBeanName, RegionMXBean.class, true); Notification notification = new Notification(JMXNotificationType.REGION_CREATED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.REGION_CREATED_PREFIX + region.getFullPath()); memberLevelNotifEmitter.sendNotification(notification); memberMBeanBridge.addRegion(region); } } /** * Handles Disk Creation. Will create DiskStoreMXBean and will send a notification * * @param disk the disk store for which the call back is invoked */ public void handleDiskCreation(DiskStore disk) throws ManagementException { if (!isServiceInitialised("handleDiskCreation")) { return; } DiskStoreMBeanBridge bridge = new DiskStoreMBeanBridge(disk); DiskStoreMXBean diskStoreMBean = new DiskStoreMBean(bridge); ObjectName diskStoreMBeanName = MBeanJMXAdapter .getDiskStoreMBeanName(internalCache.getDistributedSystem().getDistributedMember(), disk.getName()); ObjectName changedMBeanName = service.registerInternalMBean(diskStoreMBean, diskStoreMBeanName); service.federate(changedMBeanName, DiskStoreMXBean.class, true); Notification notification = new Notification(JMXNotificationType.DISK_STORE_CREATED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.DISK_STORE_CREATED_PREFIX + disk.getName()); memberLevelNotifEmitter.sendNotification(notification); memberMBeanBridge.addDiskStore(disk); } /** * Handles LockService Creation * * @param lockService */ public void handleLockServiceCreation(DLockService lockService) throws ManagementException { if (!isServiceInitialised("handleLockServiceCreation")) { return; } // Internal Locks Should not be exposed to client for monitoring if (internalLocks.contains(lockService.getName())) { return; } LockServiceMBeanBridge bridge = new LockServiceMBeanBridge(lockService); LockServiceMXBean lockServiceMBean = new LockServiceMBean(bridge); ObjectName lockServiceMBeanName = MBeanJMXAdapter.getLockServiceMBeanName( internalCache.getDistributedSystem().getDistributedMember(), lockService.getName()); ObjectName changedMBeanName = service.registerInternalMBean(lockServiceMBean, lockServiceMBeanName); service.federate(changedMBeanName, LockServiceMXBean.class, true); Notification notification = new Notification(JMXNotificationType.LOCK_SERVICE_CREATED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.LOCK_SERVICE_CREATED_PREFIX + lockService.getName()); memberLevelNotifEmitter.sendNotification(notification); memberMBeanBridge.addLockServiceStats(lockService); } /** * Handles GatewaySender creation * * @param sender the specific gateway sender * @throws ManagementException */ public void handleGatewaySenderCreation(GatewaySender sender) throws ManagementException { if (!isServiceInitialised("handleGatewaySenderCreation")) { return; } GatewaySenderMBeanBridge bridge = new GatewaySenderMBeanBridge(sender); GatewaySenderMXBean senderMBean = new GatewaySenderMBean(bridge); ObjectName senderObjectName = MBeanJMXAdapter.getGatewaySenderMBeanName( internalCache.getDistributedSystem().getDistributedMember(), sender.getId()); ObjectName changedMBeanName = service.registerInternalMBean(senderMBean, senderObjectName); service.federate(changedMBeanName, GatewaySenderMXBean.class, true); Notification notification = new Notification(JMXNotificationType.GATEWAY_SENDER_CREATED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_SENDER_CREATED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); } /** * Handles Gateway receiver creation * * @param recv specific gateway receiver * @throws ManagementException */ public void handleGatewayReceiverCreate(GatewayReceiver recv) throws ManagementException { if (!isServiceInitialised("handleGatewayReceiverCreate")) { return; } if (!recv.isManualStart()) { return; } createGatewayReceiverMBean(recv); } private void createGatewayReceiverMBean(GatewayReceiver recv) { GatewayReceiverMBeanBridge bridge = new GatewayReceiverMBeanBridge(recv); GatewayReceiverMXBean receiverMBean = new GatewayReceiverMBean(bridge); ObjectName recvObjectName = MBeanJMXAdapter .getGatewayReceiverMBeanName(internalCache.getDistributedSystem().getDistributedMember()); ObjectName changedMBeanName = service.registerInternalMBean(receiverMBean, recvObjectName); service.federate(changedMBeanName, GatewayReceiverMXBean.class, true); Notification notification = new Notification(JMXNotificationType.GATEWAY_RECEIVER_CREATED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_RECEIVER_CREATED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); } /** * Handles Gateway receiver creation * * @param recv specific gateway receiver * @throws ManagementException */ public void handleGatewayReceiverStart(GatewayReceiver recv) throws ManagementException { if (!isServiceInitialised("handleGatewayReceiverStart")) { return; } if (!recv.isManualStart()) { createGatewayReceiverMBean(recv); } GatewayReceiverMBean mbean = (GatewayReceiverMBean) service.getLocalGatewayReceiverMXBean(); GatewayReceiverMBeanBridge bridge = mbean.getBridge(); bridge.startServer(); Notification notification = new Notification(JMXNotificationType.GATEWAY_RECEIVER_STARTED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_RECEIVER_STARTED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); } /** * Handles Gateway receiver creation * * @param recv specific gateway receiver * @throws ManagementException */ public void handleGatewayReceiverStop(GatewayReceiver recv) throws ManagementException { if (!isServiceInitialised("handleGatewayReceiverStop")) { return; } GatewayReceiverMBean mbean = (GatewayReceiverMBean) service.getLocalGatewayReceiverMXBean(); GatewayReceiverMBeanBridge bridge = mbean.getBridge(); bridge.stopServer(); Notification notification = new Notification(JMXNotificationType.GATEWAY_RECEIVER_STOPPED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_RECEIVER_STOPPED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); } public void handleAsyncEventQueueCreation(AsyncEventQueue queue) throws ManagementException { if (!isServiceInitialised("handleAsyncEventQueueCreation")) { return; } AsyncEventQueueMBeanBridge bridge = new AsyncEventQueueMBeanBridge(queue); AsyncEventQueueMXBean queueMBean = new AsyncEventQueueMBean(bridge); ObjectName senderObjectName = MBeanJMXAdapter.getAsyncEventQueueMBeanName( internalCache.getDistributedSystem().getDistributedMember(), queue.getId()); ObjectName changedMBeanName = service.registerInternalMBean(queueMBean, senderObjectName); service.federate(changedMBeanName, AsyncEventQueueMXBean.class, true); Notification notification = new Notification(JMXNotificationType.ASYNC_EVENT_QUEUE_CREATED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.ASYNC_EVENT_QUEUE_CREATED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); } /** * Handles AsyncEventQueue Removal * * @param queue The AsyncEventQueue being removed */ public void handleAsyncEventQueueRemoval(AsyncEventQueue queue) throws ManagementException { if (!isServiceInitialised("handleAsyncEventQueueRemoval")) { return; } ObjectName asycnEventQueueMBeanName = MBeanJMXAdapter.getAsyncEventQueueMBeanName( internalCache.getDistributedSystem().getDistributedMember(), queue.getId()); AsyncEventQueueMBean bean; try { bean = (AsyncEventQueueMBean) service.getLocalAsyncEventQueueMXBean(queue.getId()); if (bean == null) { return; } } catch (ManagementException e) { // If no bean found its a NO-OP if (logger.isDebugEnabled()) { logger.debug(e.getMessage(), e); } return; } bean.stopMonitor(); service.unregisterMBean(asycnEventQueueMBeanName); Notification notification = new Notification(JMXNotificationType.ASYNC_EVENT_QUEUE_CLOSED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.ASYNC_EVENT_QUEUE_CLOSED_PREFIX + queue.getId()); memberLevelNotifEmitter.sendNotification(notification); } /** * Sends the alert with the Object source as member. This notification will get filtered out for * particular alert level * * @param details */ public void handleSystemNotification(AlertDetails details) { if (!isServiceInitialised("handleSystemNotification")) { return; } if (service.isManager()) { String systemSource = "DistributedSystem(" + service.getDistributedSystemMXBean().getDistributedSystemId() + ")"; Map<String, String> userData = prepareUserData(details); Notification notification = new Notification(JMXNotificationType.SYSTEM_ALERT, systemSource, SequenceNumber.next(), details.getMsgTime().getTime(), details.getMsg()); notification.setUserData(userData); service.handleNotification(notification); } } private Map<String, String> prepareUserData(AlertDetails details) { Map<String, String> userData = new HashMap<>(); userData.put(JMXNotificationUserData.ALERT_LEVEL, AlertDetails.getAlertLevelAsString(details.getAlertLevel())); String source = details.getSource(); userData.put(JMXNotificationUserData.THREAD, source); InternalDistributedMember sender = details.getSender(); String nameOrId = memberSource; if (sender != null) { nameOrId = sender.getName(); nameOrId = StringUtils.isNotBlank(nameOrId) ? nameOrId : sender.getId(); } userData.put(JMXNotificationUserData.MEMBER, nameOrId); return userData; } /** * Assumption is its a cache server instance. For Gateway receiver there will be a separate method * * @param cacheServer cache server instance */ public void handleCacheServerStart(CacheServer cacheServer) { if (!isServiceInitialised("handleCacheServerStart")) { return; } CacheServerBridge cacheServerBridge = new CacheServerBridge(internalCache, cacheServer); cacheServerBridge.setMemberMBeanBridge(memberMBeanBridge); CacheServerMBean cacheServerMBean = new CacheServerMBean(cacheServerBridge); ObjectName cacheServerMBeanName = MBeanJMXAdapter.getClientServiceMBeanName(cacheServer.getPort(), internalCache.getDistributedSystem().getDistributedMember()); ObjectName changedMBeanName = service.registerInternalMBean(cacheServerMBean, cacheServerMBeanName); ClientMembershipListener managementClientListener = new CacheServerMembershipListenerAdapter( cacheServerMBean, memberLevelNotifEmitter, changedMBeanName); ClientMembership.registerClientMembershipListener(managementClientListener); cacheServerBridge.setClientMembershipListener(managementClientListener); service.federate(changedMBeanName, CacheServerMXBean.class, true); Notification notification = new Notification(JMXNotificationType.CACHE_SERVER_STARTED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.CACHE_SERVER_STARTED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); memberMBeanBridge.setCacheServer(true); } /** * Assumption is its a cache server instance. For Gateway receiver there will be a separate method * * @param server cache server instance */ public void handleCacheServerStop(CacheServer server) { if (!isServiceInitialised("handleCacheServerStop")) { return; } CacheServerMBean mbean = (CacheServerMBean) service.getLocalCacheServerMXBean(server.getPort()); ClientMembershipListener listener = mbean.getBridge().getClientMembershipListener(); if (listener != null) { ClientMembership.unregisterClientMembershipListener(listener); } mbean.stopMonitor(); ObjectName cacheServerMBeanName = MBeanJMXAdapter.getClientServiceMBeanName(server.getPort(), internalCache.getDistributedSystem().getDistributedMember()); service.unregisterMBean(cacheServerMBeanName); Notification notification = new Notification(JMXNotificationType.CACHE_SERVER_STOPPED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.CACHE_SERVER_STOPPED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); memberMBeanBridge.setCacheServer(false); } /** * Handles Cache removal. It will automatically remove all MBeans from GemFire Domain * * @param cache GemFire Cache instance. For now client cache is not supported */ public void handleCacheRemoval(Cache cache) throws ManagementException { if (!isServiceInitialised("handleCacheRemoval")) { return; } this.serviceInitialised = false; try { cleanUpMonitors(); cleanBridgeResources(); } catch (Exception e) { if (logger.isDebugEnabled()) { logger.debug(e.getMessage(), e); } } try { service.close(); } catch (Exception e) { logger.warn(e.getMessage(), e); } finally { this.internalCache = null; this.service = null; this.memberMBeanBridge = null; this.memberBean = null; this.memberLevelNotifEmitter = null; } } private void cleanUpMonitors() { MemberMBean bean = (MemberMBean) service.getMemberMXBean(); if (bean != null) { bean.stopMonitor(); } Set<GatewaySender> senders = internalCache.getGatewaySenders(); if (senders != null && senders.size() > 0) { for (GatewaySender sender : senders) { GatewaySenderMBean senderMBean = (GatewaySenderMBean) service .getLocalGatewaySenderMXBean(sender.getId()); if (senderMBean != null) { senderMBean.stopMonitor(); } } } GatewayReceiverMBean receiver = (GatewayReceiverMBean) service.getLocalGatewayReceiverMXBean(); if (receiver != null) { receiver.stopMonitor(); } } private void cleanBridgeResources() { List<CacheServer> servers = internalCache.getCacheServers(); if (servers != null && servers.size() > 0) { for (CacheServer server : servers) { CacheServerMBean mbean = (CacheServerMBean) service.getLocalCacheServerMXBean(server.getPort()); if (mbean != null) { ClientMembershipListener listener = mbean.getBridge().getClientMembershipListener(); if (listener != null) { ClientMembership.unregisterClientMembershipListener(listener); } } } } } /** * Handles particular region destroy or close operation it will remove the corresponding MBean * * @param region */ public void handleRegionRemoval(Region region) throws ManagementException { if (!isServiceInitialised("handleRegionRemoval")) { return; } /* * Moved region remove operation to a guarded block. If a region is getting created it wont * allow it to destroy any region. */ synchronized (regionOpLock) { ObjectName regionMBeanName = MBeanJMXAdapter.getRegionMBeanName( internalCache.getDistributedSystem().getDistributedMember(), region.getFullPath()); RegionMBean bean; try { bean = (RegionMBean) service.getLocalRegionMBean(region.getFullPath()); } catch (ManagementException e) { // If no bean found its a NO-OP // Mostly for situation like DiskAccessException while creating region // which does a compensatory close region if (logger.isDebugEnabled()) { logger.debug(e.getMessage(), e); } return; } if (bean != null) { bean.stopMonitor(); } service.unregisterMBean(regionMBeanName); Notification notification = new Notification(JMXNotificationType.REGION_CLOSED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.REGION_CLOSED_PREFIX + region.getFullPath()); memberLevelNotifEmitter.sendNotification(notification); memberMBeanBridge.removeRegion(region); } } /** * Handles DiskStore Removal * * @param disk */ public void handleDiskRemoval(DiskStore disk) throws ManagementException { if (!isServiceInitialised("handleDiskRemoval")) { return; } ObjectName diskStoreMBeanName = MBeanJMXAdapter .getDiskStoreMBeanName(internalCache.getDistributedSystem().getDistributedMember(), disk.getName()); DiskStoreMBean bean; try { bean = (DiskStoreMBean) service.getLocalDiskStoreMBean(disk.getName()); if (bean == null) { return; } } catch (ManagementException e) { // If no bean found its a NO-OP if (logger.isDebugEnabled()) { logger.debug(e.getMessage(), e); } return; } bean.stopMonitor(); service.unregisterMBean(diskStoreMBeanName); Notification notification = new Notification(JMXNotificationType.DISK_STORE_CLOSED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.DISK_STORE_CLOSED_PREFIX + disk.getName()); memberLevelNotifEmitter.sendNotification(notification); memberMBeanBridge.removeDiskStore(disk); } /** * Handles Lock Service Removal * * @param lockService lock service instance */ public void handleLockServiceRemoval(DLockService lockService) throws ManagementException { if (!isServiceInitialised("handleLockServiceRemoval")) { return; } ObjectName lockServiceMBeanName = MBeanJMXAdapter.getLockServiceMBeanName( internalCache.getDistributedSystem().getDistributedMember(), lockService.getName()); LockServiceMXBean bean = service.getLocalLockServiceMBean(lockService.getName()); service.unregisterMBean(lockServiceMBeanName); Notification notification = new Notification(JMXNotificationType.LOCK_SERVICE_CLOSED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.LOCK_SERVICE_CLOSED_PREFIX + lockService.getName()); memberLevelNotifEmitter.sendNotification(notification); } /** * Handles management side call backs for a locator creation and start. Assumption is a cache will * be created before hand. * * There is no corresponding handleStopLocator() method. Locator will close the cache whenever its * stopped and it should also shutdown all the management services by closing the cache. * * @param locator instance of locator which is getting started * @throws ManagementException */ public void handleLocatorStart(Locator locator) throws ManagementException { if (!isServiceInitialised("handleLocatorCreation")) { return; } ObjectName locatorMBeanName = MBeanJMXAdapter .getLocatorMBeanName(internalCache.getDistributedSystem().getDistributedMember()); LocatorMBeanBridge bridge = new LocatorMBeanBridge(locator); LocatorMBean locatorMBean = new LocatorMBean(bridge); ObjectName changedMBeanName = service.registerInternalMBean(locatorMBean, locatorMBeanName); service.federate(changedMBeanName, LocatorMXBean.class, true); Notification notification = new Notification(JMXNotificationType.LOCATOR_STARTED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.LOCATOR_STARTED_PREFIX); memberLevelNotifEmitter.sendNotification(notification); } public void handleGatewaySenderStart(GatewaySender sender) throws ManagementException { if (!isServiceInitialised("handleGatewaySenderStart")) { return; } if ((sender.getRemoteDSId() < 0)) { return; } GatewaySenderMBean bean = (GatewaySenderMBean) service.getLocalGatewaySenderMXBean(sender.getId()); bean.getBridge().setDispatcher(); Notification notification = new Notification(JMXNotificationType.GATEWAY_SENDER_STARTED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_SENDER_STARTED_PREFIX + sender.getId()); memberLevelNotifEmitter.sendNotification(notification); } public void handleGatewaySenderStop(GatewaySender sender) throws ManagementException { if (!isServiceInitialised("handleGatewaySenderStop")) { return; } Notification notification = new Notification(JMXNotificationType.GATEWAY_SENDER_STOPPED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_SENDER_STOPPED_PREFIX + sender.getId()); memberLevelNotifEmitter.sendNotification(notification); } public void handleGatewaySenderPaused(GatewaySender sender) throws ManagementException { if (!isServiceInitialised("handleGatewaySenderPaused")) { return; } Notification notification = new Notification(JMXNotificationType.GATEWAY_SENDER_PAUSED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_SENDER_PAUSED_PREFIX + sender.getId()); memberLevelNotifEmitter.sendNotification(notification); } public void handleGatewaySenderResumed(GatewaySender sender) throws ManagementException { if (!isServiceInitialised("handleGatewaySenderResumed")) { return; } Notification notification = new Notification(JMXNotificationType.GATEWAY_SENDER_RESUMED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.GATEWAY_SENDER_RESUMED_PREFIX + sender.getId()); memberLevelNotifEmitter.sendNotification(notification); } public void handleCacheServiceCreation(CacheService cacheService) throws ManagementException { if (!isServiceInitialised("handleCacheServiceCreation")) { return; } // Don't register the CacheServices in the Locator InternalDistributedMember member = internalCache.getInternalDistributedSystem().getDistributedMember(); if (member.getVmKind() == DistributionManager.LOCATOR_DM_TYPE) { return; } CacheServiceMBeanBase mbean = cacheService.getMBean(); if (mbean != null) { String id = mbean.getId(); ObjectName cacheServiceObjectName = MBeanJMXAdapter.getCacheServiceMBeanName(member, id); ObjectName changedMBeanName = service.registerInternalMBean(mbean, cacheServiceObjectName); service.federate(changedMBeanName, mbean.getInterfaceClass(), true); Notification notification = new Notification(JMXNotificationType.CACHE_SERVICE_CREATED, memberSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.CACHE_SERVICE_CREATED_PREFIX + id); memberLevelNotifEmitter.sendNotification(notification); } } /** * Private class which acts as a ClientMembershipListener to propagate client joined/left * notifications */ private static class CacheServerMembershipListenerAdapter extends ClientMembershipListenerAdapter { private NotificationBroadcasterSupport serverLevelNotifEmitter; private NotificationBroadcasterSupport memberLevelNotifEmitter; private String serverSource; public CacheServerMembershipListenerAdapter(NotificationBroadcasterSupport serverLevelNotifEmitter, NotificationBroadcasterSupport memberLevelNotifEmitter, ObjectName serverSource) { this.serverLevelNotifEmitter = serverLevelNotifEmitter; this.memberLevelNotifEmitter = memberLevelNotifEmitter; this.serverSource = serverSource.toString(); } /** * Invoked when a client has connected to this process or when this process has connected to a * CacheServer. */ public void memberJoined(ClientMembershipEvent event) { Notification notification = new Notification(JMXNotificationType.CLIENT_JOINED, serverSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.CLIENT_JOINED_PREFIX + event.getMemberId()); serverLevelNotifEmitter.sendNotification(notification); memberLevelNotifEmitter.sendNotification(notification); } /** * Invoked when a client has gracefully disconnected from this process or when this process has * gracefully disconnected from a CacheServer. */ public void memberLeft(ClientMembershipEvent event) { Notification notification = new Notification(JMXNotificationType.CLIENT_LEFT, serverSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.CLIENT_LEFT_PREFIX + event.getMemberId()); serverLevelNotifEmitter.sendNotification(notification); memberLevelNotifEmitter.sendNotification(notification); } /** * Invoked when a client has unexpectedly disconnected from this process or when this process * has unexpectedly disconnected from a CacheServer. */ public void memberCrashed(ClientMembershipEvent event) { Notification notification = new Notification(JMXNotificationType.CLIENT_CRASHED, serverSource, SequenceNumber.next(), System.currentTimeMillis(), ManagementConstants.CLIENT_CRASHED_PREFIX + event.getMemberId()); serverLevelNotifEmitter.sendNotification(notification); memberLevelNotifEmitter.sendNotification(notification); } } private boolean isServiceInitialised(String method) { if (!serviceInitialised) { if (logger.isDebugEnabled()) { logger.debug("Management Service is not initialised hence returning from {}", method); } return false; } return true; } }