/** Normalizes all shard routings to the same version. */ public IndexShardRoutingTable normalizeVersions() { if (shards.isEmpty()) { return this; } if (shards.size() == 1) { return this; } long highestVersion = shards.get(0).version(); boolean requiresNormalization = false; for (int i = 1; i < shards.size(); i++) { if (shards.get(i).version() != highestVersion) { requiresNormalization = true; } if (shards.get(i).version() > highestVersion) { highestVersion = shards.get(i).version(); } } if (!requiresNormalization) { return this; } List<ShardRouting> shardRoutings = new ArrayList<>(shards.size()); for (int i = 0; i < shards.size(); i++) { if (shards.get(i).version() == highestVersion) { shardRoutings.add(shards.get(i)); } else { shardRoutings.add(new ShardRouting(shards.get(i), highestVersion)); } } return new IndexShardRoutingTable( shardId, ImmutableList.copyOf(shardRoutings), primaryAllocatedPostApi); }
public ServiceManager(Iterable<? extends Service> services) { ImmutableList<Service> copy = ImmutableList.copyOf(services); if (copy.isEmpty()) { logger.log( Level.WARNING, "ServiceManager configured with no services. Is your application configured properly?", new EmptyServiceManagerWarning(null)); copy = ImmutableList.of(new NoOpService(null)); } this.state = new ServiceManagerState(copy); this.services = copy; WeakReference<ServiceManagerState> stateReference = new WeakReference(this.state); Executor sameThreadExecutor = MoreExecutors.sameThreadExecutor(); for (Service service : copy) { service.addListener(new ServiceListener(service, stateReference), sameThreadExecutor); Preconditions.checkArgument( service.state() == Service.State.NEW, "Can only manage NEW services, %s", new Object[] {service}); } this.state.markReady(); }
public Result createBuildableForAndroidResources( BuildRuleResolver ruleResolver, boolean createBuildableIfEmptyDeps) { ImmutableSortedSet<BuildRule> originalDeps = originalBuildRuleParams.getDeps(); ImmutableList<HasAndroidResourceDeps> androidResourceDeps = UberRDotJavaUtil.getAndroidResourceDeps(originalDeps); if (androidResourceDeps.isEmpty() && !createBuildableIfEmptyDeps) { return new Result(originalBuildRuleParams, Optional.<DummyRDotJava>absent()); } BuildRule dummyRDotJavaBuildRule = ruleResolver.buildAndAddToIndex( DummyRDotJava.newDummyRDotJavaBuildableBuilder(buildRuleBuilderParams) .setBuildTarget(dummyRDotJavaBuildTarget) .setAndroidResourceDeps(androidResourceDeps)); final DummyRDotJava dummyRDotJava = (DummyRDotJava) dummyRDotJavaBuildRule.getBuildable(); ImmutableSortedSet<BuildRule> totalDeps = ImmutableSortedSet.<BuildRule>naturalOrder() .addAll(originalDeps) .add(dummyRDotJavaBuildRule) .build(); BuildRuleParams newBuildRuleParams = originalBuildRuleParams.copyWithChangedDeps(totalDeps); return new Result(newBuildRuleParams, Optional.of(dummyRDotJava)); }
public ArtifactCache createArtifactCache( Optional<String> currentWifiSsid, BuckEventBus buckEventBus) { ImmutableList<String> modes = getArtifactCacheModes(); if (modes.isEmpty()) { return new NoopArtifactCache(); } ImmutableList.Builder<ArtifactCache> builder = ImmutableList.builder(); boolean useDistributedCache = isWifiUsableForDistributedCache(currentWifiSsid); try { for (String mode : modes) { switch (ArtifactCacheNames.valueOf(mode)) { case dir: ArtifactCache dirArtifactCache = createDirArtifactCache(); buckEventBus.register(dirArtifactCache); builder.add(dirArtifactCache); break; case http: if (useDistributedCache) { ArtifactCache httpArtifactCache = createHttpArtifactCache(buckEventBus); builder.add(httpArtifactCache); } break; } } } catch (IllegalArgumentException e) { throw new HumanReadableException("Unusable cache.mode: '%s'", modes.toString()); } ImmutableList<ArtifactCache> artifactCaches = builder.build(); if (artifactCaches.size() == 1) { // Don't bother wrapping a single artifact cache in MultiArtifactCache. return artifactCaches.get(0); } else { return new MultiArtifactCache(artifactCaches); } }
@Override public Object readFrom( Class<Object> type, Type genericType, Annotation[] annotations, MediaType mediaType, MultivaluedMap<String, String> httpHeaders, InputStream entityStream) throws IOException, WebApplicationException { boolean validating = false; for (Annotation annotation : annotations) { validating = validating || (annotation.annotationType() == Valid.class); } final Object value = json.readValue(entityStream, genericType); if (validating) { final ImmutableList<String> errors = VALIDATOR.validate(value); if (!errors.isEmpty()) { final StringBuilder msg = new StringBuilder("The request entity had the following errors:\n"); for (String error : errors) { msg.append(" * ").append(error).append('\n'); } throw new WebApplicationException( Response.status(UNPROCESSABLE_ENTITY) .entity(msg.toString()) .type(MediaType.TEXT_PLAIN_TYPE) .build()); } } return value; }
private void ensureNodesAreAvailable(ImmutableList<DiscoveryNode> nodes) { if (nodes.isEmpty()) { String message = String.format(Locale.ROOT, "None of the configured nodes are available: %s", nodes); throw new NoNodeAvailableException(message); } }
/** Returns an object of the same type as {@code o}, or null if it is not retained. */ private Object retainAll(Schema schema, MarkSet markSet, ProtoType type, Object o) { if (!markSet.contains(type)) { return null; // Prune this type. } else if (o instanceof Map) { ImmutableMap.Builder<ProtoMember, Object> builder = ImmutableMap.builder(); for (Map.Entry<?, ?> entry : ((Map<?, ?>) o).entrySet()) { ProtoMember protoMember = (ProtoMember) entry.getKey(); if (!markSet.contains(protoMember)) continue; // Prune this field. Field field = schema.getField(protoMember); Object retainedValue = retainAll(schema, markSet, field.type(), entry.getValue()); if (retainedValue != null) { builder.put(protoMember, retainedValue); // This retained field is non-empty. } } ImmutableMap<ProtoMember, Object> map = builder.build(); return !map.isEmpty() ? map : null; } else if (o instanceof List) { ImmutableList.Builder<Object> builder = ImmutableList.builder(); for (Object value : ((List) o)) { Object retainedValue = retainAll(schema, markSet, type, value); if (retainedValue != null) { builder.add(retainedValue); // This retained value is non-empty. } } ImmutableList<Object> list = builder.build(); return !list.isEmpty() ? list : null; } else { return o; } }
/** * Scans {@code action_listeners} associated with this build to see if any {@code extra_actions} * should be added to this configured target. If any action_listeners are present, a partial visit * of the artifact/action graph is performed (for as long as actions found are owned by this * {@link ConfiguredTarget}). Any actions that match the {@code action_listener} get an {@code * extra_action} associated. The output artifacts of the extra_action are reported to the {@link * AnalysisEnvironment} for bookkeeping. */ private ExtraActionArtifactsProvider initializeExtraActions() { BuildConfiguration configuration = ruleContext.getConfiguration(); if (configuration.isHostConfiguration()) { return ExtraActionArtifactsProvider.EMPTY; } ImmutableList<Artifact> extraActionArtifacts = ImmutableList.of(); NestedSetBuilder<ExtraArtifactSet> builder = NestedSetBuilder.stableOrder(); List<Label> actionListenerLabels = configuration.getActionListeners(); if (!actionListenerLabels.isEmpty() && ruleContext.getRule().getAttributeDefinition(":action_listener") != null) { ExtraActionsVisitor visitor = new ExtraActionsVisitor(ruleContext, computeMnemonicsToExtraActionMap()); // The action list is modified within the body of the loop by the addExtraAction() call, // thus the copy for (Action action : ImmutableList.copyOf(ruleContext.getAnalysisEnvironment().getRegisteredActions())) { if (!actionsWithoutExtraAction.contains(action)) { visitor.addExtraAction(action); } } extraActionArtifacts = visitor.getAndResetExtraArtifacts(); if (!extraActionArtifacts.isEmpty()) { builder.add(ExtraArtifactSet.of(ruleContext.getLabel(), extraActionArtifacts)); } } // Add extra action artifacts from dependencies for (TransitiveInfoCollection dep : ruleContext.getConfiguredTargetMap().values()) { ExtraActionArtifactsProvider provider = dep.getProvider(ExtraActionArtifactsProvider.class); if (provider != null) { builder.addTransitive(provider.getTransitiveExtraActionArtifacts()); } } if (mandatoryStampFiles != null && !mandatoryStampFiles.isEmpty()) { builder.add(ExtraArtifactSet.of(ruleContext.getLabel(), mandatoryStampFiles)); } if (extraActionArtifacts.isEmpty() && builder.isEmpty()) { return ExtraActionArtifactsProvider.EMPTY; } return new ExtraActionArtifactsProvider(extraActionArtifacts, builder.build()); }
void isNotValidGlobal() { FormattingErrorReporter errorReporter = new FormattingErrorReporter(); ExprNode expr = expressionParser(errorReporter).parseExpression(); ImmutableList<String> errorMessages = errorReporter.getErrorMessages(); if (expr instanceof GlobalNode && errorMessages.isEmpty()) { fail("is an invalid global"); } }
@Override public int hashCode() { int baseHash = super.hashCode(); if (templateTypes.isEmpty()) { return baseHash; } return Objects.hash(templateTypes, baseHash); }
/** * Return a manifest of what finalized edit logs are available. All available edit logs are * returned starting from the transaction id passed. * * @param fromTxId Starting transaction id to read the logs. * @return RemoteEditLogManifest object. */ public synchronized RemoteEditLogManifest getEditLogManifest(long fromTxId) { // Collect RemoteEditLogs available from each FileJournalManager List<RemoteEditLog> allLogs = Lists.newArrayList(); for (JournalAndStream j : journals) { if (j.getManager() instanceof FileJournalManager) { FileJournalManager fjm = (FileJournalManager) j.getManager(); try { allLogs.addAll(fjm.getRemoteEditLogs(fromTxId)); } catch (Throwable t) { LOG.warn("Cannot list edit logs in " + fjm, t); } } } // Group logs by their starting txid ImmutableListMultimap<Long, RemoteEditLog> logsByStartTxId = Multimaps.index(allLogs, RemoteEditLog.GET_START_TXID); long curStartTxId = fromTxId; List<RemoteEditLog> logs = Lists.newArrayList(); while (true) { ImmutableList<RemoteEditLog> logGroup = logsByStartTxId.get(curStartTxId); if (logGroup.isEmpty()) { // we have a gap in logs - for example because we recovered some old // storage directory with ancient logs. Clear out any logs we've // accumulated so far, and then skip to the next segment of logs // after the gap. SortedSet<Long> startTxIds = Sets.newTreeSet(logsByStartTxId.keySet()); startTxIds = startTxIds.tailSet(curStartTxId); if (startTxIds.isEmpty()) { break; } else { if (LOG.isDebugEnabled()) { LOG.debug( "Found gap in logs at " + curStartTxId + ": " + "not returning previous logs in manifest."); } logs.clear(); curStartTxId = startTxIds.first(); continue; } } // Find the one that extends the farthest forward RemoteEditLog bestLog = Collections.max(logGroup); logs.add(bestLog); // And then start looking from after that point curStartTxId = bestLog.getEndTxId() + 1; } RemoteEditLogManifest ret = new RemoteEditLogManifest(logs); if (LOG.isDebugEnabled()) { LOG.debug("Generated manifest for logs since " + fromTxId + ":" + ret); } return ret; }
/** * Returns the list of proto files that were added directly into the deps attributes. This way * of specifying the protos is deprecated, and displays a warning when the target does so. */ private ImmutableList<Artifact> getProtoDepsFiles() { PrerequisiteArtifacts prerequisiteArtifacts = ruleContext.getPrerequisiteArtifacts("deps", Mode.TARGET); ImmutableList<Artifact> protos = prerequisiteArtifacts.filter(FileType.of(".proto")).list(); if (!protos.isEmpty()) { ruleContext.attributeWarning("deps", FILES_DEPRECATED_WARNING); } return protos; }
public ShardIterator primaryActiveInitializingShardIt() { if (!primaryAsList.isEmpty() && !primaryAsList.get(0).active() && !primaryAsList.get(0).initializing()) { List<ShardRouting> primaryList = ImmutableList.of(); return new PlainShardIterator(shardId, primaryList); } return primaryShardIt(); }
@Override protected void masterOperation( final SnapshotsStatusRequest request, final ClusterState state, final ActionListener<SnapshotsStatusResponse> listener) throws Exception { ImmutableList<SnapshotMetaData.Entry> currentSnapshots = snapshotsService.currentSnapshots(request.repository(), request.snapshots()); if (currentSnapshots.isEmpty()) { listener.onResponse(buildResponse(request, currentSnapshots, null)); return; } Set<String> nodesIds = newHashSet(); for (SnapshotMetaData.Entry entry : currentSnapshots) { for (SnapshotMetaData.ShardSnapshotStatus status : entry.shards().values()) { if (status.nodeId() != null) { nodesIds.add(status.nodeId()); } } } if (!nodesIds.isEmpty()) { // There are still some snapshots running - check their progress SnapshotId[] snapshotIds = new SnapshotId[currentSnapshots.size()]; for (int i = 0; i < currentSnapshots.size(); i++) { snapshotIds[i] = currentSnapshots.get(i).snapshotId(); } transportNodesSnapshotsStatus.status( nodesIds.toArray(new String[nodesIds.size()]), snapshotIds, request.masterNodeTimeout(), new ActionListener<TransportNodesSnapshotsStatus.NodesSnapshotStatus>() { @Override public void onResponse( TransportNodesSnapshotsStatus.NodesSnapshotStatus nodeSnapshotStatuses) { try { ImmutableList<SnapshotMetaData.Entry> currentSnapshots = snapshotsService.currentSnapshots(request.repository(), request.snapshots()); listener.onResponse(buildResponse(request, currentSnapshots, nodeSnapshotStatuses)); } catch (Throwable e) { listener.onFailure(e); } } @Override public void onFailure(Throwable e) { listener.onFailure(e); } }); } else { // We don't have any in-progress shards, just return current stats listener.onResponse(buildResponse(request, currentSnapshots, null)); } }
private void incrementalBuild(IProgressMonitor monitor) throws CoreException { IProject project = this.getProject(); IResourceDelta delta = this.getDelta(project); ImmutableList<FileDelta> fileDeltas = ResourceDeltaVisitor.getFileDeltas(delta, project); if (!fileDeltas.isEmpty()) { this.clean(fileDeltas, monitor); this.build(fileDeltas, monitor); } }
/** * Returns an iterator over active and initializing shards. Making sure though that its random * within the active shards, and initializing shards are the last to iterate through. */ public ShardIterator activeInitializingShardsIt(int seed) { if (allInitializingShards.isEmpty()) { return new PlainShardIterator(shardId, shuffler.shuffle(activeShards, seed)); } ArrayList<ShardRouting> ordered = new ArrayList<>(activeShards.size() + allInitializingShards.size()); ordered.addAll(shuffler.shuffle(activeShards, seed)); ordered.addAll(allInitializingShards); return new PlainShardIterator(shardId, ordered); }
public boolean hasImplementedInterfaces() { if (!implementedInterfaces.isEmpty()) { return true; } FunctionType superCtor = isConstructor() ? getSuperClassConstructor() : null; if (superCtor != null) { return superCtor.hasImplementedInterfaces(); } return false; }
/** * Skontroluj deserializaciu a stiahnutie eventov v ramci obdobia * * @throws Exception */ public void testGetEvents() throws Exception { Configuration.getInstance(); EventsRequest request = new EventsRequest(); Date start = DateUtils.fromString("2014-01-01T00:00:00.000Z"); Date end = DateUtils.fromString("2014-03-01T00:00:00.000Z"); request.setTime(start, end); ImmutableList<EventDto> response = ActivityService.getInstance().getEvents(request); Assert.assertNotNull(response); Assert.assertFalse(response.isEmpty()); }
protected boolean hasSelfArgument() { Class<?> clazz = getObjectType(); if (clazz == null) { return false; } List<SkylarkType> types = signature.getTypes(); ImmutableList<String> names = signature.getSignature().getNames(); return (!types.isEmpty() && types.get(0).canBeCastTo(clazz)) || (!names.isEmpty() && names.get(0).equals("self")); }
private static ImmutableSortedSet copyOfInternal(Comparator comparator1, Iterable iterable) { if (SortedIterables.hasSameComparator(comparator1, iterable) && (iterable instanceof ImmutableSortedSet)) { ImmutableSortedSet immutablesortedset = (ImmutableSortedSet) iterable; if (!immutablesortedset.isPartialView()) return immutablesortedset; } ImmutableList immutablelist = ImmutableList.copyOf(SortedIterables.sortedUnique(comparator1, iterable)); Object obj; if (immutablelist.isEmpty()) obj = emptySet(comparator1); else obj = new RegularImmutableSortedSet(immutablelist, comparator1); return ((ImmutableSortedSet) (obj)); }
public String getExplainString(TExplainLevel explainLevel) { StringBuilder str = new StringBuilder(); str.append(type.toString()); if (!partitionExprs.isEmpty()) { List<String> strings = Lists.newArrayList(); for (Expr expr : partitionExprs) { strings.add(expr.toSql()); } str.append(": " + Joiner.on(", ").join(strings)); } str.append("\n"); return str.toString(); }
public Schema load() throws IOException { ImmutableList<Path> directories = this.directories.build(); if (directories.isEmpty()) { throw new IllegalStateException("No directories added."); } Deque<Path> protos = new ArrayDeque<>(this.protos.build()); if (protos.isEmpty()) { // TODO traverse all files in every directory. } Map<Path, ProtoFile> loaded = new LinkedHashMap<>(); while (!protos.isEmpty()) { Path proto = protos.removeFirst(); if (loaded.containsKey(proto)) { continue; } ProtoFileElement element = null; for (Path directory : directories) { if (proto.isAbsolute() && !proto.startsWith(directory)) { continue; } Path resolvedPath = directory.resolve(proto); if (Files.exists(resolvedPath)) { Location location = Location.get(directory.toString(), proto.toString()); try (Source source = Okio.source(resolvedPath)) { String data = Okio.buffer(source).readUtf8(); element = ProtoParser.parse(location, data); } catch (IOException e) { throw new IOException("Failed to load " + proto, e); } break; } } if (element == null) { throw new FileNotFoundException("Failed to locate " + proto + " in " + directories); } ProtoFile protoFile = ProtoFile.get(element); loaded.put(proto, protoFile); // Queue dependencies to be loaded. FileSystem fs = proto.getFileSystem(); for (String importPath : element.imports()) { protos.addLast(fs.getPath(importPath)); } } return new Linker(loaded.values()).link(); }
private void printMatchingTestRules(Console console, Iterable<TestRule> testRules) { PrintStream out = console.getStdOut(); ImmutableList<TestRule> list = ImmutableList.copyOf(testRules); out.println(String.format("MATCHING TEST RULES (%d):", list.size())); out.println(""); if (list.isEmpty()) { out.println(" (none)"); } else { for (TestRule testRule : testRules) { out.println(" " + testRule.getBuildTarget()); } } out.println(""); }
public final ImmutableList<ModelEntryT> getModelsByIds( final ImmutableList<ModelIdT> ids, final Logger logger, final Marker logMarker, final ModelFactory<ModelEntryT> modelFactory) throws IoExceptionT { if (ids.isEmpty()) { logger.info(logMarker, "no model ids requested from index {}", indexName); return ImmutableList.of(); } logger.debug(logMarker, "getting models {} from index {}", ids, indexName); try { final MultiGetRequestBuilder requestBuilder = client.prepareMultiGet(); for (final ModelId id : ids) { requestBuilder.add(indexName, documentType, id.toString()); } final MultiGetResponse responses = requestBuilder.execute().actionGet(); final ImmutableList.Builder<ModelEntryT> modelsBuilder = ImmutableList.builder(); for (final MultiGetItemResponse response : responses.getResponses()) { if (response.isFailed()) { continue; } BytesReference sourceAsBytesRef; try { sourceAsBytesRef = response.getResponse().getSourceAsBytesRef(); } catch (final NullPointerException e) { logger.debug( logMarker, "model {} actually missing, but hipsters don't know that", response.getId()); continue; } try { modelsBuilder.add(modelFactory.createModelEntry(response.getId(), sourceAsBytesRef)); } catch (final InvalidModelException e) { logger.error(logMarker, "invalid model {} from index, ignoring: ", response.getId(), e); continue; } } return modelsBuilder.build(); } catch (final IndexNotFoundException e) { logger.warn(logMarker, "tried to get models {} from missing index {}", ids, indexName); return ImmutableList.of(); } catch (final ElasticsearchException e) { throw exceptionFactory.newIoException( e, String.format("error getting models %s from index %s", ids, indexName)); } }
/** * Returns a {@link CommandLine} that is constructed by prepending the {@code executableArgs} to * {@code commandLine}. */ static CommandLine ofMixed( final ImmutableList<String> executableArgs, final CommandLine commandLine, final boolean isShellCommand) { Preconditions.checkState(!executableArgs.isEmpty()); return new CommandLine() { @Override public Iterable<String> arguments() { return Iterables.concat(executableArgs, commandLine.arguments()); } @Override public boolean isShellCommand() { return isShellCommand; } }; }
private Bitmap getElementAt(final int position) { ImmutableList<File> collection = ImmutableList.copyOf( Collections2.filter( pictures, new Predicate<File>() { @Override public boolean apply(File input) { return input.getName().endsWith(position + 1 + ".jpeg"); } })); if (!collection.isEmpty()) { return BitmapFactory.decodeFile(collection.get(0).getAbsolutePath()); } throw new IllegalArgumentException( String.format("Cant find %d th element in the map", position)); }
public final void putModels( final Logger logger, final Marker logMarker, final ImmutableList<ModelEntryT> models) throws IoExceptionT { if (models.isEmpty()) { return; } logger.debug(logMarker, "putting {} models to index {}", models.size(), indexName); final BulkRequestBuilder bulkRequest = client.prepareBulk(); for (final ModelEntryT modelEntry : models) { bulkRequest.add(__prepareIndex(modelEntry)); } try { bulkRequest.execute().actionGet(); } catch (final ElasticsearchException e) { throw exceptionFactory.newIoException(e, "error executing bulk request"); } }
public ShardIterator preferNodeActiveInitializingShardsIt(String nodeId) { ArrayList<ShardRouting> ordered = new ArrayList<>(activeShards.size() + allInitializingShards.size()); // fill it in a randomized fashion for (ShardRouting shardRouting : shuffler.shuffle(activeShards)) { ordered.add(shardRouting); if (nodeId.equals(shardRouting.currentNodeId())) { // switch, its the matching node id ordered.set(ordered.size() - 1, ordered.get(0)); ordered.set(0, shardRouting); } } if (!allInitializingShards.isEmpty()) { ordered.addAll(allInitializingShards); } return new PlainShardIterator(shardId, ordered); }
/** * Adds a submenu containing a given list of actions. The menu is only added if there is at least * one visible action in the list. * * @param imageDescriptor */ private void addSubmenu( IMenuManager parent, String label, ImageDescriptor imageDescriptor, ImmutableList<IAction> actions) { if (actions != null && !actions.isEmpty()) { boolean notEmpty = false; MenuManager submenu = new MenuManager(label); for (IAction a : actions) { notEmpty |= addVisible(submenu, a); } if (notEmpty) { submenu.setImageDescriptor(imageDescriptor); parent.add(submenu); } } }
private StageSpec( int stageNum, StageFormat format, ImmutableList<RoundSpec> rounds, int playerLimit, ImmutableSet<TPlayer> excludedPlayers) { Preconditions.checkArgument(stageNum >= 0); Preconditions.checkNotNull(format); Preconditions.checkArgument(!rounds.isEmpty()); Preconditions.checkArgument(playerLimit > 0, "Player cutoff must be positive if present"); format.validateRounds(rounds); this.stageNum = stageNum; this.format = format; this.rounds = rounds; this.playerLimit = playerLimit; this.excludedPlayers = excludedPlayers; }