public ServerSelector( DataSegment segment, TierSelectorStrategy strategy ) { this.segment = new AtomicReference<>(segment); this.strategy = strategy; this.historicalServers = new Int2ObjectRBTreeMap<>(strategy.getComparator()); this.realtimeServers = new Int2ObjectRBTreeMap<>(strategy.getComparator()); }
public boolean removeServer(QueryableDruidServer server) { synchronized (this) { Int2ObjectRBTreeMap<Set<QueryableDruidServer>> servers; Set<QueryableDruidServer> priorityServers; int priority = server.getServer().getPriority(); if (server.getServer().getType() == ServerType.HISTORICAL) { servers = historicalServers; priorityServers = historicalServers.get(priority); } else { servers = realtimeServers; priorityServers = realtimeServers.get(priority); } if (priorityServers == null) { return false; } boolean result = priorityServers.remove(server); if (priorityServers.isEmpty()) { servers.remove(priority); } return result; } }
public void addServerAndUpdateSegment(QueryableDruidServer server, DataSegment segment) { synchronized (this) { this.segment.set(segment); Set<QueryableDruidServer> priorityServers; if (server.getServer().getType() == ServerType.HISTORICAL) { priorityServers = historicalServers.computeIfAbsent( server.getServer().getPriority(), p -> new HashSet<>() ); } else { priorityServers = realtimeServers.computeIfAbsent( server.getServer().getPriority(), p -> new HashSet<>() ); } priorityServers.add(server); } }
public void push(final int intVal) { if (this.size == 0) { this.data.put(intVal, new MutableInteger(1)); // Add newVal to Top K this.cutoff = intVal; this.size = 1; final MutableInteger counter = this.data.get(intVal); if (counter != null) { //Already in Top K, increase count. Size, cutoff do not change final int count = counter.get() + 1; counter.set(count); } else { // Add a new key to Top K this.data.put(intVal, new MutableInteger(1)); if (this.size >= this.maxSize) { // Remove the largest key, compute the new largest key this.data.remove(this.cutoff); this.cutoff = this.data.lastIntKey(); } else { this.size += 1; if (this.size < this.maxSize) { // Only case where newVal needs to be added this.size += 1; this.data.put(intVal, new MutableInteger(1)); // Add newVal to Top K this.cutoff = intVal; // It is now the largest value
@Override public List<QueryableDruidServer> pick( Int2ObjectRBTreeMap<Set<QueryableDruidServer>> prioritizedServers, DataSegment segment, int numServersToPick ) { List<QueryableDruidServer> result = new ArrayList<>(numServersToPick); for (Set<QueryableDruidServer> priorityServers : prioritizedServers.values()) { result.addAll(serverSelectorStrategy.pick(priorityServers, segment, numServersToPick - result.size())); if (result.size() == numServersToPick) { break; } } return result; } }
/** * Creates a new tree map using the elements of two parallel arrays and the * given comparator. * * @param k * the array of keys of the new tree map. * @param v * the array of corresponding values in the new tree map. * @param c * a (possibly type-specific) comparator. * @throws IllegalArgumentException * if {@code k} and {@code v} have different lengths. */ public Int2ObjectRBTreeMap(final int[] k, final V v[], final Comparator<? super Integer> c) { this(c); if (k.length != v.length) throw new IllegalArgumentException( "The key array and the value array have different lengths (" + k.length + " and " + v.length + ")"); for (int i = 0; i < k.length; i++) this.put(k[i], v[i]); } /**
public List<DruidServerMetadata> getAllServers() { List<DruidServerMetadata> servers = new ArrayList<>(); historicalServers.values() .stream() .flatMap(Collection::stream) .map(server -> server.getServer().getMetadata()) .forEach(servers::add); realtimeServers.values() .stream() .flatMap(Collection::stream) .map(server -> server.getServer().getMetadata()) .forEach(servers::add); return servers; }
@Nullable @Override public QueryableDruidServer pick() { synchronized (this) { if (!historicalServers.isEmpty()) { return strategy.pick(historicalServers, segment.get()); } return strategy.pick(realtimeServers, segment.get()); } } }
public boolean removeServer(QueryableDruidServer server) { synchronized (this) { int priority = server.getServer().getPriority(); Set<QueryableDruidServer> priorityServers = servers.get(priority); if (priorityServers == null) { return false; } boolean result = priorityServers.remove(server); if (priorityServers.isEmpty()) { servers.remove(priority); } return result; } }
public IntTreeTopK(final int maxSize, final IntComparator greater) { this.maxSize = maxSize; this.size = 0; this.greater = greater; this.data = new Int2ObjectRBTreeMap<MutableInteger>(this.greater); }
@Override public List<QueryableDruidServer> pick( Int2ObjectRBTreeMap<Set<QueryableDruidServer>> prioritizedServers, DataSegment segment, int numServersToPick ) { List<QueryableDruidServer> result = new ArrayList<>(numServersToPick); for (Set<QueryableDruidServer> priorityServers : prioritizedServers.values()) { result.addAll(serverSelectorStrategy.pick(priorityServers, segment, numServersToPick - result.size())); if (result.size() == numServersToPick) { break; } } return result; } }
public boolean isEmpty() { synchronized (this) { return servers.isEmpty(); } }
public void addServerAndUpdateSegment( QueryableDruidServer server, DataSegment segment ) { synchronized (this) { this.segment.set(segment); int priority = server.getServer().getPriority(); Set<QueryableDruidServer> priorityServers = servers.computeIfAbsent(priority, p -> new HashSet<>()); priorityServers.add(server); } }
public boolean removeServer(QueryableDruidServer server) { synchronized (this) { Int2ObjectRBTreeMap<Set<QueryableDruidServer>> servers; Set<QueryableDruidServer> priorityServers; int priority = server.getServer().getPriority(); if (server.getServer().getType() == ServerType.HISTORICAL) { servers = historicalServers; priorityServers = historicalServers.get(priority); } else { servers = realtimeServers; priorityServers = realtimeServers.get(priority); } if (priorityServers == null) { return false; } boolean result = priorityServers.remove(server); if (priorityServers.isEmpty()) { servers.remove(priority); } return result; } }
public ServerSelector( DataSegment segment, TierSelectorStrategy strategy ) { this.segment = new AtomicReference<>(segment); this.strategy = strategy; this.historicalServers = new Int2ObjectRBTreeMap<>(strategy.getComparator()); this.realtimeServers = new Int2ObjectRBTreeMap<>(strategy.getComparator()); }
@Override public List<QueryableDruidServer> pick( Int2ObjectRBTreeMap<Set<QueryableDruidServer>> prioritizedServers, DataSegment segment, int numServersToPick ) { List<QueryableDruidServer> result = new ArrayList<>(numServersToPick); for (Set<QueryableDruidServer> priorityServers : prioritizedServers.values()) { result.addAll(serverSelectorStrategy.pick(priorityServers, segment, numServersToPick - result.size())); if (result.size() == numServersToPick) { break; } } return result; } }
public void addServerAndUpdateSegment( QueryableDruidServer server, DataSegment segment ) { synchronized (this) { this.segment.set(segment); Set<QueryableDruidServer> priorityServers; if (server.getServer().getType() == ServerType.HISTORICAL) { priorityServers = historicalServers.computeIfAbsent( server.getServer().getPriority(), p -> new HashSet<>() ); } else { priorityServers = realtimeServers.computeIfAbsent( server.getServer().getPriority(), p -> new HashSet<>() ); } priorityServers.add(server); } }
public ServerSelector( DataSegment segment, TierSelectorStrategy strategy ) { this.segment = new AtomicReference<>(segment); this.strategy = strategy; this.servers = new Int2ObjectRBTreeMap<>(strategy.getComparator()); }