protected ResponseConvertHandler getConvertHandler(String id, String provider) { ResponseConvertHandler convertHandler = convertHandlerMap.get("serverId:" + id); if (convertHandler == null) { convertHandler = convertHandlerMap.getOrDefault("provider:" + provider, defaultConvertHandler); } return convertHandler; }
void add(T t) { int count = map.getOrDefault(t, 0); map.put(t, count + 1); }
private static int mergeMaps(Map<String, Integer> map, Map<String, Integer> other) { int deltaSize = 0; for (Map.Entry<String, Integer> entry : other.entrySet()) { if (!map.containsKey(entry.getKey())) { deltaSize += entry.getKey().getBytes().length + SIZE_OF_INT; } map.put(entry.getKey(), map.getOrDefault(entry.getKey(), 0) + other.getOrDefault(entry.getKey(), 0)); } return deltaSize; }
public void taskStart(int stageId, long taskId) { if (!stages.containsKey(stageId)) { logger.warning(String.format("Spark stage %d could not be found for task progress reporting.", stageId)); return; } removeTask(stageId, taskId); List<Long> at = activeTasks.getOrDefault(stageId, new ArrayList<Long>()); at.add(taskId); activeTasks.put(stageId, at); }
Map<String, Long> latestNotifications = Maps.newHashMap(); for (ReleaseMessage releaseMessage : latestReleaseMessages) { latestNotifications.put(releaseMessage.getMessage(), releaseMessage.getId()); long clientSideId = clientSideNotifications.get(namespace); long latestId = ConfigConsts.NOTIFICATION_ID_PLACEHOLDER; Collection<String> namespaceWatchedKeys = watchedKeysMap.get(namespace); for (String namespaceWatchedKey : namespaceWatchedKeys) { long namespaceNotificationId = latestNotifications.getOrDefault(namespaceWatchedKey, ConfigConsts.NOTIFICATION_ID_PLACEHOLDER); if (namespaceNotificationId > latestId) { latestId = namespaceNotificationId; ApolloConfigNotification notification = new ApolloConfigNotification(namespace, latestId); namespaceWatchedKeys.stream().filter(latestNotifications::containsKey).forEach(namespaceWatchedKey -> notification.addMessage(namespaceWatchedKey, latestNotifications.get(namespaceWatchedKey))); newNotifications.add(notification);
private Map<String, Double> mkSupervisorCapacities(Map<String, Object> conf) { Map<String, Double> ret = new HashMap<String, Double>(); // Put in legacy values Double mem = ObjectReader.getDouble(conf.get(Config.SUPERVISOR_MEMORY_CAPACITY_MB), 4096.0); ret.put(Config.SUPERVISOR_MEMORY_CAPACITY_MB, mem); Double cpu = ObjectReader.getDouble(conf.get(Config.SUPERVISOR_CPU_CAPACITY), 400.0); ret.put(Config.SUPERVISOR_CPU_CAPACITY, cpu); // If configs are present in Generic map and legacy - the legacy values will be overwritten Map<String, Number> rawResourcesMap = (Map<String, Number>) conf.getOrDefault( Config.SUPERVISOR_RESOURCES_MAP, Collections.emptyMap() ); for (Map.Entry<String, Number> stringNumberEntry : rawResourcesMap.entrySet()) { ret.put(stringNumberEntry.getKey(), stringNumberEntry.getValue().doubleValue()); } return NormalizedResources.RESOURCE_NAME_NORMALIZER.normalizedResourceMap(ret); }
int increaseExpectedFetchCount(int level, int count) { expectedFetchCountPerLevel.put(level, expectedFetchCountPerLevel.getOrDefault(level, 0) + count); return expectedFetchCountPerLevel.get(level); }
@VisibleForTesting void prepare(Cluster cluster) { this.cluster = cluster; nodes = new RAS_Nodes(cluster); networkTopography = cluster.getNetworkTopography(); Map<String, String> hostToRack = new HashMap<>(); for (Map.Entry<String, List<String>> entry : networkTopography.entrySet()) { String rackId = entry.getKey(); for (String hostName: entry.getValue()) { hostToRack.put(hostName, rackId); } } for (RAS_Node node: nodes.getNodes()) { String superId = node.getId(); String hostName = node.getHostname(); String rackId = hostToRack.getOrDefault(hostName, DNSToSwitchMapping.DEFAULT_RACK); superIdToHostname.put(superId, hostName); superIdToRack.put(superId, rackId); hostnameToNodes.computeIfAbsent(hostName, (hn) -> new ArrayList<>()).add(node); rackIdToNodes.computeIfAbsent(rackId, (hn) -> new ArrayList<>()).add(node); } logClusterInfo(); }
List<Transfer> getTransfersFromStop(String fromStopId, String fromRouteId) { final List<Transfer> allOutboundTransfers = transfersFromStop.getOrDefault(fromStopId, Collections.emptyList()); final Map<String, List<Transfer>> byToStop = allOutboundTransfers.stream() .filter(t -> t.transfer_type == 0 || t.transfer_type == 2) .filter(t -> t.from_route_id == null || fromRouteId.equals(t.from_route_id)) .collect(Collectors.groupingBy(t -> t.to_stop_id)); final List<Transfer> result = new ArrayList<>(); byToStop.forEach((toStop, transfers) -> { routesByStop.getOrDefault(toStop, Collections.emptySet()).forEach(toRouteId -> { final Transfer mostSpecificRule = findMostSpecificRule(transfers, fromRouteId, toRouteId); final Transfer myRule = new Transfer(); myRule.to_route_id = toRouteId; myRule.from_route_id = fromRouteId; myRule.to_stop_id = mostSpecificRule.to_stop_id; myRule.from_stop_id = mostSpecificRule.from_stop_id; myRule.transfer_type = mostSpecificRule.transfer_type; myRule.min_transfer_time = mostSpecificRule.min_transfer_time; myRule.from_trip_id = mostSpecificRule.from_trip_id; myRule.to_trip_id = mostSpecificRule.to_trip_id; result.add(myRule); }); }); return result; }
public ColumnsFileReporter(String path, Map<String, String> query, Map<String, MetricExtractor> extractorsMap, String defaultPreceision) throws FileNotFoundException { super(path, query, extractorsMap); targetUnit = UNIT_MAP.get(query.getOrDefault("time", "MILLISECONDS").toUpperCase()); if (targetUnit == null) { throw new IllegalArgumentException(query.get("time") + " is not a supported time unit"); List<String> extractors = handleExtractorCleanup(Arrays.asList(query.get("columns").split("\\s*,\\s*"))); extractors.add(extractor); String strPrecision = query.getOrDefault("precision", defaultPreceision); if (strPrecision == null) { precision = -1;
private Map<String, Long> getDeltaValues(Map<String, Long> total, Map<String, Long> prev) { return total.entrySet() .stream() .collect(Collectors.toMap(Map.Entry::getKey, e -> e.getValue() - prev.getOrDefault(e.getKey(), 0L))); }
/** * Constructs a {@link DefaultStateSerializer} instance with the given list of classes registered in kryo. * * @param classesToRegister the classes to register. */ public DefaultStateSerializer(Map<String, Object> topoConf, TopologyContext context, List<Class<?>> classesToRegister) { this.context = context; this.topoConf = topoConf; registrations.addAll(classesToRegister.stream().map(Class::getName).collect(Collectors.toSet())); // other classes from config registrations.addAll((List<String>) topoConf.getOrDefault(Config.TOPOLOGY_STATE_KRYO_REGISTER, Collections.emptyList())); // defaults registrations.add(Optional.class.getName()); }
/** * Attach an output consumer at container startup, enabling stdout and stderr to be followed, waited on, etc. * <p> * More than one consumer may be registered. * * @param serviceName the name of the service as set in the docker-compose.yml file * @param consumer consumer that output frames should be sent to * @return this instance, for chaining */ public SELF withLogConsumer(String serviceName, Consumer<OutputFrame> consumer) { String serviceInstanceName = getServiceInstanceName(serviceName); final List<Consumer<OutputFrame>> consumers = this.logConsumers.getOrDefault(serviceInstanceName, new ArrayList<>()); consumers.add(consumer); this.logConsumers.putIfAbsent(serviceInstanceName, consumers); return self(); }
@Override public final RecordCursor cursor(ConnectorTransactionHandle transactionHandle, ConnectorSession session, TupleDomain<Integer> constraint) { TransactionId transactionId = ((GlobalSystemTransactionHandle) transactionHandle).getTransactionId(); InMemoryRecordSet.Builder table = InMemoryRecordSet.builder(tableMetadata); Map<ConnectorId, Map<String, PropertyMetadata<?>>> connectorProperties = propertySupplier.get(); for (Entry<String, ConnectorId> entry : new TreeMap<>(transactionManager.getCatalogNames(transactionId)).entrySet()) { String catalog = entry.getKey(); Map<String, PropertyMetadata<?>> properties = new TreeMap<>(connectorProperties.getOrDefault(entry.getValue(), ImmutableMap.of())); for (PropertyMetadata<?> propertyMetadata : properties.values()) { table.addRow( catalog, propertyMetadata.getName(), firstNonNull(propertyMetadata.getDefaultValue(), "").toString(), propertyMetadata.getSqlType().toString(), propertyMetadata.getDescription()); } } return table.build().cursor(); } }
@Override public void prepare(Map<String, Object> topoConf, TopologyContext context, OutputCollector collector) { List<String> registrations = (List<String>) topoConf.getOrDefault(Config.TOPOLOGY_STATE_KRYO_REGISTER, new ArrayList<>()); registrations.add(ConcurrentLinkedQueue.class.getName()); registrations.add(LinkedList.class.getName()); registrations.add(AtomicInteger.class.getName()); registrations.add(EventImpl.class.getName()); registrations.add(WindowPartition.class.getName()); registrations.add(DefaultEvictionContext.class.getName()); topoConf.put(Config.TOPOLOGY_STATE_KRYO_REGISTER, registrations); prepare(topoConf, context, collector, getWindowState(topoConf, context), getPartitionState(topoConf, context), getWindowSystemState(topoConf, context)); }
@SuppressWarnings("unchecked") private static Map<String, Object> normalizeConf(Map<String, Object> conf, Map<String, Object> topoConf, StormTopology topology) { //ensure that serializations are same for all tasks no matter what's on // the supervisors. this also allows you to declare the serializations as a sequence List<Map<String, Object>> allConfs = new ArrayList<>(); for (Object comp : StormCommon.allComponents(topology).values()) { allConfs.add(StormCommon.componentConf(comp)); } Set<String> decorators = new HashSet<>(); //Yes we are putting in a config that is not the same type we pulled out. Map<String, String> serializers = new HashMap<>(); for (Map<String, Object> c : allConfs) { addToDecorators(decorators, (List<String>) c.get(Config.TOPOLOGY_KRYO_DECORATORS)); addToSerializers(serializers, (List<Object>) c.get(Config.TOPOLOGY_KRYO_REGISTER)); } addToDecorators(decorators, (List<String>) topoConf.getOrDefault(Config.TOPOLOGY_KRYO_DECORATORS, conf.get(Config.TOPOLOGY_KRYO_DECORATORS))); addToSerializers(serializers, (List<Object>) topoConf.getOrDefault(Config.TOPOLOGY_KRYO_REGISTER, conf.get(Config.TOPOLOGY_KRYO_REGISTER))); Map<String, Object> mergedConf = Utils.merge(conf, topoConf); Map<String, Object> ret = new HashMap<>(topoConf); ret.put(Config.TOPOLOGY_KRYO_REGISTER, serializers); ret.put(Config.TOPOLOGY_KRYO_DECORATORS, new ArrayList<>(decorators)); ret.put(Config.TOPOLOGY_ACKER_EXECUTORS, mergedConf.get(Config.TOPOLOGY_ACKER_EXECUTORS)); ret.put(Config.TOPOLOGY_EVENTLOGGER_EXECUTORS, mergedConf.get(Config.TOPOLOGY_EVENTLOGGER_EXECUTORS)); ret.put(Config.TOPOLOGY_MAX_TASK_PARALLELISM, mergedConf.get(Config.TOPOLOGY_MAX_TASK_PARALLELISM)); return ret; }
private Set<Map<String, Object>> recentGoalViolations(boolean useDateFormat) { Map<Long, Anomaly> goalViolationsByTime = _recentAnomaliesByType.get(AnomalyType.GOAL_VIOLATION); Set<Map<String, Object>> recentAnomalies = new HashSet<>(_numCachedRecentAnomalyStates); for (Map.Entry<Long, Anomaly> entry: goalViolationsByTime.entrySet()) { GoalViolations goalViolations = (GoalViolations) entry.getValue(); Map<Boolean, List<String>> violatedGoalsByFixability = goalViolations.violatedGoalsByFixability(); Map<String, Object> anomalyDetails = new HashMap<>(3); anomalyDetails.put(useDateFormat ? DETECTION_DATE : DETECTION_MS, useDateFormat ? getDateFormat(entry.getKey()) : entry.getKey()); anomalyDetails.put(FIXABLE_VIOLATED_GOALS, violatedGoalsByFixability.getOrDefault(true, Collections.emptyList())); anomalyDetails.put(UNFIXABLE_VIOLATED_GOALS, violatedGoalsByFixability.getOrDefault(false, Collections.emptyList())); recentAnomalies.add(anomalyDetails); } return recentAnomalies; }
protected ResponseJudge getResponseJudge(String id, String provider) { ResponseJudge judge = judgeMap.get("serverId:" + id); if (judge == null) { judge = judgeMap.getOrDefault("provider:" + provider, defaultResponseJudge); } return judge; }
/** * Chooses one of the incoming tasks and selects the one that has been selected the fewest times so far. */ public Integer chooseTask(int[] assignedTasks) { Integer taskIdWithMinLoad = null; Long minTaskLoad = Long.MAX_VALUE; for (Integer currentTaskId : assignedTasks) { final Long currentTaskLoad = targetTaskStats.getOrDefault(currentTaskId, 0L); if (currentTaskLoad < minTaskLoad) { minTaskLoad = currentTaskLoad; taskIdWithMinLoad = currentTaskId; } } targetTaskStats.put(taskIdWithMinLoad, targetTaskStats.getOrDefault(taskIdWithMinLoad, 0L) + 1); return taskIdWithMinLoad; } }
/** {@inheritDoc} */ @Override public Double apply(double[] estimations) { A.notEmpty(estimations, "estimations vector"); Map<Double, Integer> cntrsByCls = new HashMap<>(); for (Double predictedValue : estimations) { Integer cntrVal = cntrsByCls.getOrDefault(predictedValue, 0) + 1; cntrsByCls.put(predictedValue, cntrVal); } return cntrsByCls.entrySet().stream() .max(Comparator.comparing(Map.Entry::getValue)) .get().getKey(); } }