protected DomainGroupData getDomainGroupData(DomainGroup domainGroup) throws IOException { DomainGroupData data = new DomainGroupData(); data.name = domainGroup.getName(); Map<String, Integer> versionsMap = new HashMap<String, Integer>(); for (DomainAndVersion v : domainGroup.getDomainVersions()) { versionsMap.put(v.getDomain().getName(), v.getVersionNumber()); } data.domainVersions = versionsMap; return data; }
public static boolean isUpToDate(Host host, DomainGroup domainGroup, Domain domain) throws IOException { if (domain == null || domain.getVersions() == null) { return false; } Set<DomainAndVersion> domainAndVersion = new HashSet<>(); domainAndVersion.add(domainGroup.getDomainVersion(domain)); return isUpToDateOrMoreRecent(host, domainAndVersion); }
protected void doUpdateDomainVersions(HttpServletRequest req, HttpServletResponse resp) throws IOException { String dgName = URLEnc.decode(req.getParameter("name")); DomainGroup dg = coordinator.getDomainGroup(dgName); Map<Domain, Integer> domainVersions = new HashMap<Domain, Integer>(); for (Domain domain : coordinator.getDomains()) { String version = req.getParameter(domain.getName() + "_version"); if (version == null) { continue; } domainVersions.put(domain, Integer.parseInt(version)); } dg.setDomainVersions(domainVersions); resp.sendRedirect("/domain_group.jsp?n=" + dgName); } }
@Override public Set<RingGroup> getRingGroupsForDomainGroup(DomainGroup domainGroup) { String domainGroupName = domainGroup.getName(); Set<RingGroup> groups = new HashSet<RingGroup>(); for (RingGroup group : ringGroups.values()) { if (group.getDomainGroup().getName().equals(domainGroupName)) { groups.add(group); } } return groups; }
public static boolean isUpToDate(Host host, DomainGroup domainGroup) throws IOException { if (domainGroup == null || domainGroup.getDomainVersions() == null) { return false; } if (!allPartitionsUpToDate(host, domainGroup.getDomainVersions(), false)) { return false; } if (isAssignedDeletablePartition(host)) { return false; } return true; }
g1Versions.put(d0, 1); g1Versions.put(d1, 1); g1.setDomainVersions(g1Versions); g2.setDomainVersions(g2Versions); RingGroup rg0 = coordinator.addRingGroup(RING_GROUP_0, g1.getName()); Ring r1 = rg0.addRing(1); r1.addHost(addy("alpha-1-1"), Collections.<String>emptyList()); RingGroup rg1 = coordinator.addRingGroup(RING_GROUP_1, g1.getName()); r1 = rg1.addRing(1); r1.addHost(addy("beta-1-1"), Collections.<String>emptyList()); r4.addHost(addy("beta-4-4"), Collections.<String>emptyList()); RingGroup rg2 = coordinator.addRingGroup(RING_GROUP_2, g2.getName()); r1 = rg2.addRing(1); r1.addHost(addy("gamma-1-1"), Collections.<String>emptyList());
protected void addDomainsToRingGroup(Coordinator coordinator, RingGroup ringGroup) throws IOException { // for each configured domain for (RingGroupConfiguredDomain configuredDomain : configuredDomains) { Domain domain = coordinator.getDomain(configuredDomain.getName()); DomainAndVersion version = ringGroup.getDomainGroup().getDomainVersion(domain); if (version == null) { // either there are no versions, which is fine DomainVersion latestClosedVersion = Domains.getLatestVersionNotOpenNotDefunct(domain); if (latestClosedVersion != null) { int versionToAdd = latestClosedVersion.getVersionNumber(); LOG.info("Adding domain " + domain.getName() + " version " + versionToAdd + " to domain group: " + ringGroup.getName()); ringGroup.getDomainGroup().setDomainVersion(domain, versionToAdd); } } } }
public static void fastForwardAllDomains(DomainGroup domainGroup) throws IOException { fastForwardDomains(domainGroup, domainGroup.getDomains()); } }
public static void fastForwardDomain(DomainGroup domainGroup, Domain domain) throws IOException { DomainVersion version = Domains.getLatestVersionNotOpenNotDefunct(domain); domainGroup.setDomainVersion(domain, version.getVersionNumber()); }
public RingGroupMonitor(RingGroup ringGroup, List<Notifier> notifiers) throws IOException { this.notifiers = notifiers; this.ringGroup = ringGroup; for (Ring ring : ringGroup.getRings()) { ringMonitors.add(new RingMonitor(ringGroup, ring, notifiers)); } this.ringGroupConductorStatusMonitor = new RingGroupConductorModeMonitor(); this.domainGroupMetadataMonitor = new DomainGroupMetadataMonitor(); ringGroup.addRingGroupConductorModeListener(ringGroupConductorStatusMonitor); ringGroup.getDomainGroup().addListener(domainGroupMetadataMonitor); }
@Override public int compareTo(DomainGroup o) { return getName().compareTo(o.getName()); }
private boolean removeHostIfReplicated(int totalRings, DomainGroup domainGroup, Map<Domain, Map<Integer, Set<Host>>> domainToPartitionToHostsFullyServing, ThreeNestedMap<Domain, Integer, String, Long> domainPartitionBucketHostCounts, Ring ring, Host host) throws IOException { LiveReplicaStatus status = PartitionUtils.computeDataReplicationStatus( totalRings, domainToPartitionToHostsFullyServing, domainPartitionBucketHostCounts, domainGroup.getDomainVersions(), this.status, host ); if (PartitionUtils.isFullyServing(host, false, this.status) && status == LiveReplicaStatus.OVER_REPLICATED) { removeHost(ring, host); // just to be safe, only remove one host per iteration. otherwise we have to carefully update the various // partition maps. I don't think this will delay things significantly. return true; } return false; }
private boolean isInUse(Domain domain) throws IOException { String domainName = domain.getName(); for (RingGroup rg : coordinator.getRingGroups()) { for (Ring ring : rg.getRings()) { for (Host host : ring.getHosts()) { for (HostDomain hostDomain : host.getAssignedDomains()) { if(hostDomain.getDomain().getName().equals(domainName)){ return true; } } } } DomainGroup dg = rg.getDomainGroup(); for (Domain dgd : dg.getDomains()) { if(dgd.getName().equals(domainName)){ return true; } } } return false; }
private void addDomainGroupDeployStatusToResponse(Map<String, Object> requestData, Map<String, Object> responseData) throws IOException { DomainGroup domainGroup = coordinator.getDomainGroup((String) requestData.get(Params.DEPLOY_STATUS_FOR_DOMAIN_GROUP)); if (domainGroup != null) { responseData.put(domainGroup.getName(), apiHelper.getDomainGroupDeployStatus(domainGroup).asMap()); } }
@Test public void testAddDomainGroup() throws Exception { // keep a second coordinator aside final ZooKeeperCoordinator coord2 = getCoord(); coord.addDomainGroup("myDomainGroup2"); DomainGroup c = coord.getDomainGroup("myDomainGroup2"); assertNotNull(c); assertEquals("myDomainGroup2", c.getName()); assertEquals(0, c.getDomainVersions().size()); // repeat the assertions with the other coord instance to ensure changes are // visible WaitUntil.orDie(() -> coord2.getDomainGroup("myDomainGroup2") != null); assertNotNull("myDomainGroup2 should be found", c); assertEquals("myDomainGroup2", c.getName()); assertEquals(0, c.getDomainVersions().size()); coord2.close(); }
public ServingStatus computeUniquePartitionsServingStatus(DomainGroup domainGroup) throws IOException { ServingStatus result = new ServingStatus(); for (DomainAndVersion dgvdv : domainGroup.getDomainVersions()) { Domain domain = dgvdv.getDomain(); Map<Integer, ServingStatus> partitionToServingStatus = domainToPartitionToPartitionServingStatus.get(domain); int partitionsServedAndUpToDate = 0; if (partitionToServingStatus != null) { for (ServingStatus servingStatus : partitionToServingStatus.values()) { // A unique partition is served and up to date if all host corresponding domain partitions are // served and up to date if (servingStatus.getNumPartitionsServedAndUpToDate() == servingStatus.getNumPartitions()) { partitionsServedAndUpToDate += 1; } } } result.aggregate(domain.getNumParts(), partitionToServingStatus == null ? 0 : partitionsServedAndUpToDate); } return result; } }
public static boolean isCurrentlyServed(Domain domain, DomainVersion domainVersion, Coordinator coord) throws IOException { for (DomainGroup domainGroup : coord.getDomainGroups()) { DomainAndVersion version = domainGroup.getDomainVersion(domain); if (version != null) { if (version.getVersionNumber() == domainVersion.getVersionNumber()) { return true; } } } return false; }
@Test public void testAddRingGroup() throws Exception { DomainGroup dg = coord.addDomainGroup("myDomainGroup2"); Map<Domain, Integer> domainIdToVersion = new HashMap<>(); dg.setDomainVersions(domainIdToVersion); RingGroup rg = coord.addRingGroup("superDuperRingGroup", "myDomainGroup2"); assertEquals("superDuperRingGroup", rg.getName()); assertEquals(0, rg.getRings().size()); }
private void addDomainGroupDataToResponse(Map<String, Object> requestData, Map<String, Object> responseData) throws IOException { DomainGroup domainGroup = coordinator.getDomainGroup((String) requestData.get(Params.DOMAIN_GROUP)); if (domainGroup != null) { HankApiHelper.DomainGroupData data = apiHelper.getDomainGroupData(domainGroup); responseData.put(domainGroup.getName(), data.asMap()); } }
@Override public void manageTransitions(Coordinator coordinator, RingGroup ringGroup) throws IOException { DomainGroup domainGroup = ringGroup.getDomainGroup(); if (domainGroup == null) { // Nothing to do LOG.info("Domain group not found. Nothing to do."); return; } Map<Domain, Map<Integer, Set<Host>>> domainToPartitionToHostsFullyServing = PartitionUtils.domainToPartitionToHostsServing(ringGroup, status); ThreeNestedMap<Domain, Integer, String, Long> domainPartitionBucketHostCounts = PartitionUtils.domainToPartitionToHostsServingInBucket(domainToPartitionToHostsFullyServing, status); SortedSet<Ring> rings = ringGroup.getRingsSorted(); int ringCount = rings.size(); for (Ring ring : rings) { partitionAssigner.prepare(ring, domainGroup.getDomainVersions(), ringGroup.getRingGroupConductorMode()); for (Host host : ring.getHostsSorted()) { manageTransitions(ringCount, host, domainGroup, domainToPartitionToHostsFullyServing, domainPartitionBucketHostCounts); } } }