public synchronized void noMoreDrivers() { if (closed) { return; } if (encounteredLifespans.size() != closedLifespans.size()) { Sets.difference(encounteredLifespans, closedLifespans).forEach(this::noMoreDrivers); verify(encounteredLifespans.size() == closedLifespans.size()); } closed = true; for (OperatorFactory operatorFactory : operatorFactories) { operatorFactory.noMoreOperators(); } } }
private void assertMemoryRevokingRequestedFor(OperatorContext... operatorContexts) { ImmutableSet<OperatorContext> operatorContextsSet = ImmutableSet.copyOf(operatorContexts); operatorContextsSet.forEach( operatorContext -> assertTrue(operatorContext.isMemoryRevokingRequested(), "expected memory requested for operator " + operatorContext.getOperatorId())); Sets.difference(allOperatorContexts, operatorContextsSet).forEach( operatorContext -> assertFalse(operatorContext.isMemoryRevokingRequested(), "expected memory not requested for operator " + operatorContext.getOperatorId())); }
private void updateRelatedAlarms(OnmsAlarm alarm, Event event) { // Retrieve the related alarms as given by the event parameters final Set<OnmsAlarm> relatedAlarms = getRelatedAlarms(event.getParmCollection()); // Index these by id final Map<Integer, OnmsAlarm> relatedAlarmsByIds = relatedAlarms.stream() .collect(Collectors.toMap(OnmsAlarm::getId, a -> a)); // Build sets of the related alarm ids for easy comparison final Set<Integer> relatedAlarmIdsFromEvent = ImmutableSet.copyOf(relatedAlarmsByIds.keySet()); final Set<Integer> relatedAlarmIdsFromExistingAlarm = ImmutableSet.copyOf(alarm.getRelatedAlarmIds()); // Remove alarms that are not referenced in the event - we treat the event as an // authoritative source of the related alarms rather than using the union of the previously known related alarms // and the event's related alarms Sets.difference(relatedAlarmIdsFromExistingAlarm, relatedAlarmIdsFromEvent) .forEach(alarm::removeRelatedAlarmWithId); // Add new alarms that are referenced in the event, but are not already associated Sets.difference(relatedAlarmIdsFromEvent, relatedAlarmIdsFromExistingAlarm) .forEach(relatedAlarmIdToAdd -> { final OnmsAlarm related = relatedAlarmsByIds.get(relatedAlarmIdToAdd); if (related != null) { if (!formingCyclicGraph(alarm, related)) { alarm.addRelatedAlarm(related); } else { LOG.warn("Alarm with id '{}' , reductionKey '{}' is not added as related alarm for id '{}' as it is forming cyclic graph ", related.getId(), related.getReductionKey(), alarm.getId()); } } }); }
public User addOrUpdateUser(Long id, User user) { user.setId(id); user.setTimestamp(System.currentTimeMillis()); validateUser(user); this.dao.addOrUpdate(user); // update user - role association if (user.getRoles() != null) { List<QueryParam> qps = QueryParam.params(UserRole.USER_ID, String.valueOf(user.getId())); Set<Long> existing = listUserRoles(qps).stream().map(UserRole::getRoleId).collect(Collectors.toSet()); Set<Long> newRoles = user.getRoles().stream().map(this::getRole).filter(Optional::isPresent) .map(role -> role.get().getId()).collect(Collectors.toSet()); Sets.difference(existing, newRoles).forEach(roleId -> removeUserRole(id, roleId)); Sets.difference(newRoles, existing).forEach(roleId -> { if (getRole(roleId) == null) { throw new IllegalArgumentException("No role with id: " + roleId); } addUserRole(id, roleId); }); } return user; }
@PUT @Path("/roles/{parentRoleName}/children") @Timed public Response addOrUpdateChildRoles(@PathParam("parentRoleName") String parentRoleName, Set<String> childRoleNames, @Context SecurityContext securityContext) throws Exception { SecurityUtil.checkRole(authorizer, securityContext, ROLE_SECURITY_ADMIN); Long parentId = getIdFromRoleName(parentRoleName); Set<Long> currentChildIds = new HashSet<>(); catalogService.getChildRoles(parentId).forEach(role -> currentChildIds.add(role.getId())); Set<Long> updatedChildIds = new HashSet<>(); childRoleNames.forEach(childRoleName -> { if (childRoleName.equals(parentRoleName)) { throw new IllegalArgumentException("Child role(s) contain parent role"); } updatedChildIds.add(getIdFromRoleName(childRoleName)); }); Set<Long> childIdsToAdd = Sets.difference(updatedChildIds, currentChildIds); Set<Long> childIdsToRemove = Sets.difference(currentChildIds, updatedChildIds); childIdsToRemove.forEach(childId -> catalogService.removeChildRole(parentId, childId)); Set<RoleHierarchy> res = new HashSet<>(); Sets.intersection(currentChildIds, updatedChildIds).forEach(childId -> res.add(new RoleHierarchy(parentId, childId))); childIdsToAdd.forEach(childId -> res.add(catalogService.addChildRole(parentId, childId))); return WSUtils.respondEntities(res, OK); }
private void updateDeprecatedKeys(RegisterRulesContext context, RulesDefinition.Rule ruleDef, RuleDefinitionDto rule, DbSession dbSession) { Set<SingleDeprecatedRuleKey> deprecatedRuleKeysFromDefinition = SingleDeprecatedRuleKey.from(ruleDef); Set<SingleDeprecatedRuleKey> deprecatedRuleKeysFromDB = context.getDBDeprecatedKeysFor(rule); // DeprecatedKeys that must be deleted List<String> uuidsToBeDeleted = difference(deprecatedRuleKeysFromDB, deprecatedRuleKeysFromDefinition).stream() .map(SingleDeprecatedRuleKey::getUuid) .collect(toList()); dbClient.ruleDao().deleteDeprecatedRuleKeys(dbSession, uuidsToBeDeleted); // DeprecatedKeys that must be created Sets.SetView<SingleDeprecatedRuleKey> deprecatedRuleKeysToBeCreated = difference(deprecatedRuleKeysFromDefinition, deprecatedRuleKeysFromDB); deprecatedRuleKeysToBeCreated .forEach(r -> dbClient.ruleDao().insert(dbSession, new DeprecatedRuleKeyDto() .setUuid(uuidFactory.create()) .setRuleId(rule.getId()) .setOldRepositoryKey(r.getOldRepositoryKey()) .setOldRuleKey(r.getOldRuleKey()) .setCreatedAt(system2.now()))); }
@Test public void testPutAll() { Map<String, Set<Integer>> map1 = new HashMap<String, Set<Integer>>(); int count1 = Random.getScaleCount(); for (int i = 0; i < count1; i++) { map1.put(Random.getString(), randomValueSet()); } int count2 = Random.getScaleCount(); for (int i = 0; i < count2; i++) { map.put(Random.getString(), randomValueSet()); } Assert.assertTrue(map.size() == count2); Map<String, Set<Integer>> map0 = map; map.putAll(map1); Sets.union(map1.keySet(), map0.keySet()).forEach(key -> { Assert.assertEquals(Sets.union( MoreObjects.firstNonNull(map0.get(key), Sets.newHashSet()), MoreObjects.firstNonNull(map1.get(key), Sets.newHashSet())), map.get(key)); }); }
public void update() { for (Map.Entry<String, PlayerItemTankState> entry : tankStates.entrySet()) { entry.getValue().update(client); } if (client) { Sets.SetView<Frequency> new_visible = Sets.difference(a_visible, b_visible); Sets.SetView<Frequency> old_visible = Sets.difference(b_visible, a_visible); if (!new_visible.isEmpty() || !old_visible.isEmpty()) { PacketCustom packet = new PacketCustom(EnderStorageCPH.channel, 1); packet.writeShort(new_visible.size()); new_visible.forEach(freq -> freq.writeToPacket(packet)); packet.writeShort(old_visible.size()); old_visible.forEach(freq -> freq.writeToPacket(packet)); packet.sendToServer(); } HashSet<Frequency> temp = b_visible; temp.clear(); b_visible = a_visible; a_visible = temp; } }
@VisibleForTesting Set<Long> discoverAndInitializeTablesToOrganize() { Set<Long> enabledTableIds = metadataDao.getOrganizationEligibleTables(); Set<TableOrganizationInfo> tableOrganizationInfo = organizerDao.getNodeTableOrganizationInfo(currentNodeIdentifier); Map<Long, TableOrganizationInfo> organizationInfos = Maps.uniqueIndex(tableOrganizationInfo, TableOrganizationInfo::getTableId); // If this is the first time organizing a table, initialize the organization info for it difference(enabledTableIds, organizationInfos.keySet()) .forEach(tableId -> organizerDao.insertNode(currentNodeIdentifier, tableId)); ImmutableSet.Builder<Long> tableIds = ImmutableSet.builder(); for (Long tableId : enabledTableIds) { TableOrganizationInfo info = organizationInfos.get(tableId); if (info == null || shouldRunOrganization(info)) { tableIds.add(tableId); } } return tableIds.build(); }
@VisibleForTesting Set<Long> discoverAndInitializeTablesToOrganize() { Set<Long> enabledTableIds = metadataDao.getOrganizationEligibleTables(); Set<TableOrganizationInfo> tableOrganizationInfo = organizerDao.getNodeTableOrganizationInfo(currentNodeIdentifier); Map<Long, TableOrganizationInfo> organizationInfos = Maps.uniqueIndex(tableOrganizationInfo, TableOrganizationInfo::getTableId); // If this is the first time organizing a table, initialize the organization info for it difference(enabledTableIds, organizationInfos.keySet()) .forEach(tableId -> organizerDao.insertNode(currentNodeIdentifier, tableId)); ImmutableSet.Builder<Long> tableIds = ImmutableSet.builder(); for (Long tableId : enabledTableIds) { TableOrganizationInfo info = organizationInfos.get(tableId); if (info == null || shouldRunOrganization(info)) { tableIds.add(tableId); } } return tableIds.build(); }
public synchronized void noMoreDrivers() { if (closed) { return; } if (encounteredLifespans.size() != closedLifespans.size()) { Sets.difference(encounteredLifespans, closedLifespans).forEach(this::noMoreDrivers); verify(encounteredLifespans.size() == closedLifespans.size()); } closed = true; for (OperatorFactory operatorFactory : operatorFactories) { operatorFactory.noMoreOperators(); } } }
private Response addOrUpdateRoleUsers(Long roleId, Set<Long> userIds) { List<UserRole> userRoles = new ArrayList<>(); Role roleToQuery = catalogService.getRole(roleId); Set<Long> currentUserIds = catalogService.listUsers(roleToQuery).stream().map(User::getId).collect(Collectors.toSet()); Set<Long> userIdsToAdd = Sets.difference(userIds, currentUserIds); Set<Long> userIdsToRemove = Sets.difference(currentUserIds, userIds); Sets.intersection(currentUserIds, userIds).forEach(userId -> { userRoles.add(new UserRole(userId, roleId)); }); userIdsToRemove.forEach(userId -> catalogService.removeUserRole(userId, roleId)); userIdsToAdd.forEach(userId -> { userRoles.add(catalogService.addUserRole(userId, roleId)); }); return WSUtils.respondEntities(userRoles, OK); }
private static PathTokens mergeTokens(PathTokens thisTokens, PathTokens parentTokens) { if (parentTokens.isEmpty()) { return thisTokens; } else if (thisTokens.isEmpty()) { return parentTokens; } else { ImmutableMap.Builder<String, String> builder = ImmutableMap.builder(); Sets.difference(parentTokens.keySet(), thisTokens.keySet()).forEach(t -> builder.put(t, parentTokens.get(t)) ); builder.putAll(thisTokens); return DefaultPathTokens.of(builder.build()); } }
public synchronized void noMoreDrivers() { if (closed) { return; } if (encounteredLifespans.size() != closedLifespans.size()) { Sets.difference(encounteredLifespans, closedLifespans).forEach(this::noMoreDrivers); verify(encounteredLifespans.size() == closedLifespans.size()); } closed = true; for (OperatorFactory operatorFactory : operatorFactories) { operatorFactory.noMoreOperators(); } } }
private void updateResourceStats(Map<String, Resource> resources, Map<String, Long> currentResourceUsage) { resources.values().forEach(r -> stats.recordResourceConfigured(r.id(), r.concurrency())); currentResourceUsage.forEach(stats::recordResourceUsed); Sets.difference(resources.keySet(), currentResourceUsage.keySet()) .forEach(r -> stats.recordResourceUsed(r, 0)); }
private void assertMemoryRevokingRequestedFor(OperatorContext... operatorContexts) { ImmutableSet<OperatorContext> operatorContextsSet = ImmutableSet.copyOf(operatorContexts); operatorContextsSet.forEach( operatorContext -> assertTrue(operatorContext.isMemoryRevokingRequested(), "expected memory requested for operator " + operatorContext.getOperatorId())); Sets.difference(allOperatorContexts, operatorContextsSet).forEach( operatorContext -> assertFalse(operatorContext.isMemoryRevokingRequested(), "expected memory not requested for operator " + operatorContext.getOperatorId())); }
private void assertMemoryRevokingRequestedFor(OperatorContext... operatorContexts) { ImmutableSet<OperatorContext> operatorContextsSet = ImmutableSet.copyOf(operatorContexts); operatorContextsSet.forEach( operatorContext -> assertTrue(operatorContext.isMemoryRevokingRequested(), "expected memory requested for operator " + operatorContext.getOperatorId())); Sets.difference(allOperatorContexts, operatorContextsSet).forEach( operatorContext -> assertFalse(operatorContext.isMemoryRevokingRequested(), "expected memory not requested for operator " + operatorContext.getOperatorId())); }
private boolean primedMapValuesAreContainedWithinOtherMap(Map<String, ?> primedParams, Map<String, ?> otherParams) { final Set<String> primedParamsKeys = primedParams.keySet(); final Set<String> otherParamsKeys = otherParams.keySet(); if(!otherParamsKeys.containsAll(primedParamsKeys)) return false; final HashMap<String, ?> copy = new HashMap<>(otherParams); Sets.difference(otherParamsKeys, primedParamsKeys).forEach(copy::remove); return mapValuesMatchWithRegex(primedParams, copy); } }
private void updateDeprecatedKeys(RegisterRulesContext context, RulesDefinition.Rule ruleDef, RuleDefinitionDto rule, DbSession dbSession) { Set<SingleDeprecatedRuleKey> deprecatedRuleKeysFromDefinition = SingleDeprecatedRuleKey.from(ruleDef); Set<SingleDeprecatedRuleKey> deprecatedRuleKeysFromDB = context.getDBDeprecatedKeysFor(rule); // DeprecatedKeys that must be deleted List<String> uuidsToBeDeleted = difference(deprecatedRuleKeysFromDB, deprecatedRuleKeysFromDefinition).stream() .map(SingleDeprecatedRuleKey::getUuid) .collect(toList()); dbClient.ruleDao().deleteDeprecatedRuleKeys(dbSession, uuidsToBeDeleted); // DeprecatedKeys that must be created Sets.SetView<SingleDeprecatedRuleKey> deprecatedRuleKeysToBeCreated = difference(deprecatedRuleKeysFromDefinition, deprecatedRuleKeysFromDB); deprecatedRuleKeysToBeCreated .forEach(r -> dbClient.ruleDao().insert(dbSession, new DeprecatedRuleKeyDto() .setUuid(uuidFactory.create()) .setRuleId(rule.getId()) .setOldRepositoryKey(r.getOldRepositoryKey()) .setOldRuleKey(r.getOldRuleKey()) .setCreatedAt(system2.now()))); }