Java Code Examples for build.bazel.remote.execution.v2.Platform#Property

private static String dockerContainer(Command cmd) throws StatusException {
  String result = null;
  for (Platform.Property property : cmd.getPlatform().getPropertiesList()) {
    if (property.getName().equals(CONTAINER_IMAGE_ENTRY_NAME)) {
      if (result != null) {
        // Multiple container name entries
        throw StatusUtils.invalidArgumentError(
            "platform", // Field name.
            String.format(
                "Multiple entries for %s in action.Platform", CONTAINER_IMAGE_ENTRY_NAME));
      }
      result = property.getValue();
      if (!result.startsWith(DOCKER_IMAGE_PREFIX)) {
        throw StatusUtils.invalidArgumentError(
            "platform", // Field name.
            String.format(
                "%s: Docker images must be stored in gcr.io with an image spec in the form "
                    + "'docker://gcr.io/{IMAGE_NAME}'",
                CONTAINER_IMAGE_ENTRY_NAME));
      }
      result = result.substring(DOCKER_IMAGE_PREFIX.length());
    }
  }
  return result;
}
 

@VisibleForTesting
public QueueEntry dispatchOperation(MatchListener listener)
    throws IOException, InterruptedException {
  while (!backplane.isStopped()) {
    listener.onWaitStart();
    try {

      List<Platform.Property> provisions = new ArrayList<>();
      QueueEntry queueEntry = backplane.dispatchOperation(provisions);
      if (queueEntry != null) {
        return queueEntry;
      }
    } catch (IOException e) {
      Status status = Status.fromThrowable(e);
      if (status.getCode() != Code.UNAVAILABLE && status.getCode() != Code.DEADLINE_EXCEEDED) {
        throw e;
      }
    }
    listener.onWaitEnd();
  }
  throw new IOException(Status.UNAVAILABLE.withDescription("backplane is stopped").asException());
}
 

@Override
public QueueEntry dispatchOperation(List<Platform.Property> provisions)
    throws IOException, InterruptedException {
  return client.blockingCall(
      jedis -> {
        return dispatchOperation(jedis, provisions);
      });
}
 

private static void sortPlatformProperties(Platform.Builder builder) {
  List<Platform.Property> properties =
      Ordering.from(Comparator.comparing(Platform.Property::getName))
          .sortedCopy(builder.getPropertiesList());
  builder.clearProperties();
  builder.addAllProperties(properties);
}
 

private static Protos.Platform buildPlatform(Platform platform) {
  Protos.Platform.Builder platformBuilder = Protos.Platform.newBuilder();
  for (Platform.Property p : platform.getPropertiesList()) {
    platformBuilder.addPropertiesBuilder().setName(p.getName()).setValue(p.getValue());
  }
  return platformBuilder.build();
}
 

static SetMultimap<String, String> getMatchProvisions(
    Platform platform, Iterable<ExecutionPolicy> policyNames, int executeStageWidth) {
  ImmutableSetMultimap.Builder<String, String> provisions = ImmutableSetMultimap.builder();
  for (Platform.Property property : platform.getPropertiesList()) {
    provisions.put(property.getName(), property.getValue());
  }
  for (ExecutionPolicy policy : policyNames) {
    String name = policy.getName();
    if (!name.isEmpty()) {
      provisions.put("execution-policy", name);
    }
  }
  provisions.put("cores", String.format("%d", executeStageWidth));
  return provisions.build();
}
 

public static boolean satisfiesRequirements(
    SetMultimap<String, String> provisions, Platform requirements) {
  for (Platform.Property property : requirements.getPropertiesList()) {
    if (!satisfiesRequirement(provisions, property.getName(), property.getValue())) {
      return false;
    }
  }
  return true;
}
 

static SetMultimap<String, String> createProvisions(Platform platform) {
  ImmutableSetMultimap.Builder<String, String> provisions = ImmutableSetMultimap.builder();
  for (Platform.Property property : platform.getPropertiesList()) {
    provisions.put(property.getName(), property.getValue());
  }
  return provisions.build();
}
 

private void queue(
    JedisCluster jedis,
    String operationName,
    List<Platform.Property> provisions,
    String queueEntryJson) {
  if (jedis.hdel(config.getDispatchedOperationsHashName(), operationName) == 1) {
    logger.log(Level.WARNING, format("removed dispatched operation %s", operationName));
  }
  operationQueue.push(jedis, provisions, queueEntryJson);
}
 

private SetMultimap<String, String> toMultimap(List<Platform.Property> provisions) {
  SetMultimap<String, String> set = LinkedHashMultimap.create();
  for (Platform.Property property : provisions) {
    set.put(property.getName(), property.getValue());
  }
  return set;
}
 

private SetMultimap<String, String> toMultimap(List<Platform.Property> provisions) {
  SetMultimap<String, String> set = LinkedHashMultimap.create();
  for (Platform.Property property : provisions) {
    set.put(property.getName(), property.getValue());
  }
  return set;
}
 

private BalancedRedisQueue chooseEligibleQueue(List<Platform.Property> provisions) {
  for (ProvisionedRedisQueue provisionedQueue : queues) {
    if (provisionedQueue.isEligible(toMultimap(provisions))) {
      return provisionedQueue.queue();
    }
  }
  throw new RuntimeException(
      "there are no eligible queues for the provided execution requirements.  One solution to is to configure a provision queue with no requirements which would be eligible to all operations.");
}
 

public Boolean validProperties(List<Platform.Property> provisions) {
  for (ProvisionedRedisQueue provisionedQueue : queues) {
    if (provisionedQueue.isEligible(toMultimap(provisions))) {
      return true;
    }
  }
  return false;
}
 

@Override
public Boolean validQueueProperties(List<Platform.Property> provisions) {
  return operationQueue.validProperties(provisions);
}
 

@ThreadSafe
Boolean validQueueProperties(List<Platform.Property> provisions);
 

public QueueStatus status(JedisCluster jedis, List<Platform.Property> provisions) {
  BalancedRedisQueue queue = chooseEligibleQueue(provisions);
  return queue.status(jedis);
}
 

public String dequeue(JedisCluster jedis, List<Platform.Property> provisions)
    throws InterruptedException {
  BalancedRedisQueue queue = chooseEligibleQueue(provisions);
  return queue.dequeue(jedis);
}
 

public void push(JedisCluster jedis, List<Platform.Property> provisions, String val) {
  BalancedRedisQueue queue = chooseEligibleQueue(provisions);
  queue.push(jedis, val);
}
 

public String getDequeueName(List<Platform.Property> provisions) {
  BalancedRedisQueue queue = chooseEligibleQueue(provisions);
  return queue.getDequeueName();
}
 

/**
 * The state of operations is tracked in a series of lists representing the order in which the
 * work is to be processed (queued, dispatched, and completed).
 *
 * <p>Moves an operation from the list of queued operations to the list of dispatched operations.
 */
@ThreadSafe
QueueEntry dispatchOperation(List<Platform.Property> provisions)
    throws IOException, InterruptedException;