ImmutableList<JavaFileObject> getGeneratedSources() {
   ImmutableList.Builder<JavaFileObject> result = ImmutableList.builder();
   for (Entry<URI, JavaFileObject> entry : inMemoryFileObjects.asMap().entrySet()) {
     if (entry.getKey().getPath().startsWith("/" + StandardLocation.SOURCE_OUTPUT.name())
         && (entry.getValue().getKind() == Kind.SOURCE)) {
       result.add(entry.getValue());
     }
   }
   return result.build();
 }
 @Override
 public Map<Subject, Boolean> getAllWithPermission(Set<Context> contexts, String permission) {
   final ImmutableMap.Builder<Subject, Boolean> ret = ImmutableMap.builder();
   for (PEXSubject subject : subjectCache.asMap().values()) {
     Tristate permissionValue =
         subject.getPermissionValue(
             contexts == null ? subject.getActiveContexts() : contexts, permission);
     if (permissionValue != Tristate.UNDEFINED) {
       ret.put(subject, permissionValue.asBoolean());
     }
   }
   return ret.build();
 }
Example #3
0
  @Override
  public void close() {
    if (state.equals(ReaderWriterState.OPEN)) {

      LOG.debug("Closing all cached writers for view:{}", view);

      for (DatasetWriter<E> writer : cachedWriters.asMap().values()) {
        LOG.debug("Closing partition writer:{}", writer);
        writer.close();
      }

      state = ReaderWriterState.CLOSED;
    }
  }
 public static void updateRates(String type, long rate) {
   LOGGER.debug("updateRates : type={}, rate={}", type, rate);
   Iterator<RateLimiterDescriptor> iterator = rateLimiterMap.asMap().keySet().iterator();
   while (iterator.hasNext()) {
     RateLimiterDescriptor oldRateDesc = iterator.next();
     if (type.equals(oldRateDesc.getType())) {
       LOGGER.trace("updateRates : invalidated rate={}", oldRateDesc);
       rateLimiterMap.invalidate(oldRateDesc);
       RateLimiterDescriptor newRateDesc =
           new RateLimiterDescriptor(oldRateDesc.getType(), oldRateDesc.getAppId(), rate);
       LOGGER.trace("updateRates : updating rate desc={}, rate={}", newRateDesc, rate);
       rateLimiterMap.put(newRateDesc, RateLimiter.create(rate));
       rateLimiterMap.refresh(newRateDesc);
     }
   }
 }
Example #5
0
  /**
   * Computes arbitrary resource aggregates based on a query, a filter, and a grouping function.
   *
   * @param query Query to select tasks for aggregation.
   * @param filter Filter to apply on query result tasks.
   * @param keyFunction Function to define aggregation groupings.
   * @param <K> Key type.
   * @return A map from the keys to their aggregates based on the tasks fetched.
   * @throws StorageException if there was a problem fetching tasks from storage.
   */
  public <K> Map<K, Metric> computeAggregates(
      Query.Builder query, Predicate<ITaskConfig> filter, Function<ITaskConfig, K> keyFunction)
      throws StorageException {

    LoadingCache<K, Metric> metrics =
        CacheBuilder.newBuilder()
            .build(
                new CacheLoader<K, Metric>() {
                  @Override
                  public Metric load(K key) {
                    return new Metric();
                  }
                });
    for (ITaskConfig task : Iterables.filter(getTasks(query), filter)) {
      metrics.getUnchecked(keyFunction.apply(task)).accumulate(task);
    }
    return metrics.asMap();
  }
 ImmutableList<JavaFileObject> getOutputFiles() {
   return ImmutableList.copyOf(inMemoryFileObjects.asMap().values());
 }
Example #7
0
 public Collection<WorkerData> values() {
   return workerCache.asMap().values();
 }
 Iterable<PEXSubject> getActiveSubjects() {
   return subjectCache.asMap().values();
 }
Example #9
0
 boolean remove(K key) {
   return delegate.asMap().remove(key) != null;
 }
 @Override
 public Set<DefinitionKey> getAllKeys() {
   return localCache.asMap().keySet();
 }