public InternalDistributedMember getLeadMember() { for (InternalDistributedMember mbr : this.members) { if (mbr.getVmKind() == ClusterDistributionManager.NORMAL_DM_TYPE) { return mbr; } } return null; }
/** * Keeps track of which members depart unexpectedly */ @Override public void memberDeparted(DistributionManager distributionManager, InternalDistributedMember id, boolean crashed) { if (!crashed) return; synchronized (this) { int kind = id.getVmKind(); switch (kind) { case ClusterDistributionManager.LOCATOR_DM_TYPE: case ClusterDistributionManager.NORMAL_DM_TYPE: this.crashedApplications++; break; default: break; } } // synchronized }
/** test method to get the member IDs of all locators in the distributed system */ public Set<InternalDistributedMember> getLocatorDistributionManagerIds() { // access to members synchronized under membersLock in order to // ensure serialization synchronized (this.membersLock) { HashSet<InternalDistributedMember> result = new HashSet<>(); for (InternalDistributedMember m : this.members.keySet()) { if (m.getVmKind() == ClusterDistributionManager.LOCATOR_DM_TYPE) { result.add(m); } } return result; } }
@Override public Set<InternalDistributedMember> getNormalDistributionManagerIds() { // access to members synchronized under membersLock in order to // ensure serialization synchronized (this.membersLock) { HashSet<InternalDistributedMember> result = new HashSet<>(); for (InternalDistributedMember m : this.members.keySet()) { if (m.getVmKind() != ClusterDistributionManager.LOCATOR_DM_TYPE) { result.add(m); } } return result; } }
/** * returns the members of this views crashedMembers collection that were members of the given * view. Admin-only members are not counted */ public Set<InternalDistributedMember> getActualCrashedMembers(NetView oldView) { Set<InternalDistributedMember> result = new HashSet<>(this.crashedMembers.size()); result.addAll(this.crashedMembers.stream() .filter(mbr -> (mbr.getVmKind() != ClusterDistributionManager.ADMIN_ONLY_DM_TYPE)) .filter(mbr -> oldView == null || oldView.contains(mbr)).collect(Collectors.toList())); return result; }
List<InternalDistributedMember> getElderCandidates() { List<InternalDistributedMember> theMembers = clusterDistributionManager.getViewMembers(); return theMembers.stream() .filter(member -> member.getVmKind() != ClusterDistributionManager.ADMIN_ONLY_DM_TYPE) .filter( member -> !clusterDistributionManager.getMembershipManager().isSurpriseMember(member)) .collect(Collectors.toList()); }
private String[] listStandAloneLocatorMembers() { String[] locatorMembers = ManagementConstants.NO_DATA_STRING; Set<DistributedMember> members = new HashSet<>(); members.add(system.getDistributedMember()); members.addAll(system.getAllOtherMembers()); if (!members.isEmpty()) { Set<String> locatorMemberSet = new TreeSet<>(); for (DistributedMember member : members) { if (ClusterDistributionManager.LOCATOR_DM_TYPE == ((InternalDistributedMember) member) .getVmKind()) { String name = member.getName(); name = StringUtils.isNotBlank(name) ? name : member.getId(); locatorMemberSet.add(name); } } locatorMembers = locatorMemberSet.toArray(locatorMembers); members.clear(); locatorMemberSet.clear(); } return locatorMembers; }
/** * Makes note of a new distribution manager that has started up in the distributed cache. Invokes * the appropriately listeners. * * @param theId The id of the distribution manager starting up * */ private void handleManagerStartup(InternalDistributedMember theId) { HashMap<InternalDistributedMember, InternalDistributedMember> tmp = null; synchronized (this.membersLock) { // Note test is under membersLock if (members.containsKey(theId)) { return; // already accounted for } // Note we don't modify in place. This allows reader to get snapshots // without locking. tmp = new HashMap<>(this.members); tmp.put(theId, theId); this.members = Collections.unmodifiableMap(tmp); Set<InternalDistributedMember> stmp = new HashSet<>(this.membersAndAdmin); stmp.add(theId); this.membersAndAdmin = Collections.unmodifiableSet(stmp); } // synchronized if (theId.getVmKind() != ClusterDistributionManager.LOCATOR_DM_TYPE) { this.stats.incNodes(1); } logger.info("Admitting member <{}>. Now there are {} non-admin member(s).", theId, tmp.size()); addMemberEvent(new MemberJoinedEvent(theId)); }
private void addNewMember(InternalDistributedMember member) { // This is the place to cleanup the zombieMembers int vmType = member.getVmKind(); switch (vmType) { case ADMIN_ONLY_DM_TYPE: handleConsoleStartup(member); break; case LOCATOR_DM_TYPE: case NORMAL_DM_TYPE: handleManagerStartup(member); break; default: throw new InternalGemFireError(String.format("Unknown member type: %s", Integer.valueOf(vmType))); } }
/** * returns the weight of the members in this membership view */ public int memberWeight() { int result = 0; InternalDistributedMember lead = getLeadMember(); for (InternalDistributedMember mbr : this.members) { result += mbr.getNetMember().getMemberWeight(); switch (mbr.getVmKind()) { case ClusterDistributionManager.NORMAL_DM_TYPE: result += 10; if (lead != null && mbr.equals(lead)) { result += 5; } break; case ClusterDistributionManager.LOCATOR_DM_TYPE: result += 3; break; case ClusterDistributionManager.ADMIN_ONLY_DM_TYPE: break; default: throw new IllegalStateException("Unknown member type: " + mbr.getVmKind()); } } return result; }
private void handleManagerSuspect(InternalDistributedMember suspect, InternalDistributedMember whoSuspected, String reason) { if (!isCurrentMember(suspect)) { return; // fault tolerance } int vmType = suspect.getVmKind(); if (vmType == ADMIN_ONLY_DM_TYPE) { return; } addMemberEvent(new MemberSuspectEvent(suspect, whoSuspected, reason)); }
/** * logs the weight of failed members wrt the given previous view */ public void logCrashedMemberWeights(NetView oldView, Logger log) { InternalDistributedMember lead = oldView.getLeadMember(); for (InternalDistributedMember mbr : this.crashedMembers) { if (!oldView.contains(mbr)) { continue; } int mbrWeight = mbr.getNetMember().getMemberWeight(); switch (mbr.getVmKind()) { case ClusterDistributionManager.NORMAL_DM_TYPE: if (lead != null && mbr.equals(lead)) { mbrWeight += 15; } else { mbrWeight += 10; } break; case ClusterDistributionManager.LOCATOR_DM_TYPE: mbrWeight += 3; break; case ClusterDistributionManager.ADMIN_ONLY_DM_TYPE: break; default: throw new IllegalStateException("Unknown member type: " + mbr.getVmKind()); } log.info(" " + mbr + " had a weight of " + mbrWeight); } }
/** * returns the weight of crashed members in this membership view with respect to the given * previous view */ public int getCrashedMemberWeight(NetView oldView) { int result = 0; InternalDistributedMember lead = oldView.getLeadMember(); for (InternalDistributedMember mbr : this.crashedMembers) { if (!oldView.contains(mbr)) { continue; } result += mbr.getNetMember().getMemberWeight(); switch (mbr.getVmKind()) { case ClusterDistributionManager.NORMAL_DM_TYPE: result += 10; if (lead != null && mbr.equals(lead)) { result += 5; } break; case ClusterDistributionManager.LOCATOR_DM_TYPE: result += 3; break; case ClusterDistributionManager.ADMIN_ONLY_DM_TYPE: break; default: throw new IllegalStateException("Unknown member type: " + mbr.getVmKind()); } } return result; }
@Override public synchronized void initializePdxRegistry() { if (this.pdxRegistry == null) { // The member with locator is initialized with a NullTypePdxRegistration if (this.getMyId().getVmKind() == ClusterDistributionManager.LOCATOR_DM_TYPE) { this.pdxRegistry = new TypeRegistry(this, true); } else { this.pdxRegistry = new TypeRegistry(this, false); } this.pdxRegistry.initialize(); } }
@Test public void getElderIdIgnoresAdminMembers() { ClusterElderManager clusterElderManager = new ClusterElderManager(clusterDistributionManager); when(member1.getVmKind()).thenReturn(ClusterDistributionManager.ADMIN_ONLY_DM_TYPE); when(clusterDistributionManager.getViewMembers()).thenReturn(Arrays.asList(member1, member2)); assertThat(clusterElderManager.getElderId()).isEqualTo(member2); }
/** * Asserts that distributionManagerType is LOCAL, GEMFIRE, or ADMIN_ONLY. Also asserts that the * distributionManagerId (jgroups DistributedMember) has a VmKind that matches. */ private void assertDistributionManagerType() { // Assert that dmType is one of the three DM types... int theDmType = getDMType(); switch (theDmType) { case NORMAL_DM_TYPE: case LONER_DM_TYPE: case ADMIN_ONLY_DM_TYPE: case LOCATOR_DM_TYPE: break; default: Assert.assertTrue(false, "unknown distribution manager type"); } // Assert InternalDistributedMember VmKind matches this DistributionManagerType... final InternalDistributedMember theId = getDistributionManagerId(); final int vmKind = theId.getVmKind(); if (theDmType != vmKind) { Assert.assertTrue(false, "InternalDistributedMember has a vmKind of " + vmKind + " instead of " + theDmType); } }
private int getWeight(Collection<InternalDistributedMember> idms, InternalDistributedMember leader) { int weight = 0; for (InternalDistributedMember mbr : idms) { int thisWeight = mbr.getNetMember().getMemberWeight(); if (mbr.getVmKind() == 10 /* NORMAL_DM_KIND */) { thisWeight += 10; if (leader != null && mbr.equals(leader)) { thisWeight += 5; } } else if (mbr.getNetMember().preferredForCoordinator()) { thisWeight += 3; } weight += thisWeight; } return weight; }
@Override public void started() { this.localAddress = services.getMessenger().getMemberID(); GMSMember mbr = (GMSMember) this.localAddress.getNetMember(); if (services.getConfig().areLocatorsPreferredAsCoordinators()) { boolean preferred = false; if (services.getLocator() != null || Locator.hasLocator() || !services.getConfig().getDistributionConfig().getStartLocator().isEmpty() || localAddress.getVmKind() == ClusterDistributionManager.LOCATOR_DM_TYPE) { logger .info("This member is hosting a locator will be preferred as a membership coordinator"); preferred = true; } mbr.setPreferredForCoordinator(preferred); } else { mbr.setPreferredForCoordinator(true); } }
protected 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() == ClusterDistributionManager.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); } }