Java Code Examples for org.apache.mesos.v1.Protos#OfferID

@Timed("offer_manager_launch_task")
@Override
public void launchTask(Protos.OfferID offerId, Protos.TaskInfo task) throws LaunchException {
  // Guard against an offer being removed after we grabbed it from the iterator.
  // If that happens, the offer will not exist in hostOffers, and we can immediately
  // send it back to LOST for quick reschedule.
  // Removing while iterating counts on the use of a weakly-consistent iterator being used,
  // which is a feature of ConcurrentSkipListSet.
  if (hostOffers.remove(offerId)) {
    try {
      Protos.Offer.Operation launch = Protos.Offer.Operation.newBuilder()
          .setType(Protos.Offer.Operation.Type.LAUNCH)
          .setLaunch(Protos.Offer.Operation.Launch.newBuilder().addTaskInfos(task))
          .build();
      driver.acceptOffers(offerId, ImmutableList.of(launch), getOfferFilter());
    } catch (IllegalStateException e) {
      // TODO(William Farner): Catch only the checked exception produced by Driver
      // once it changes from throwing IllegalStateException when the driver is not yet
      // registered.
      throw new LaunchException("Failed to launch task.", e);
    }
  } else {
    offerRaces.incrementAndGet();
    throw new LaunchException("Offer no longer exists in offer queue, likely data race.");
  }
}
 

/**
 * Utility method to more succinctly construct a {@link Call Call} of type {@link Type#DECLINE DECLINE}.
 * <p>
 *
 * @param frameworkId    The {@link Protos.FrameworkID FrameworkID} to be set on the {@link Call}
 * @param offerIds       A list of {@link Protos.OfferID OfferID} from the
 *                       {@link Protos.Offer}s received from Mesos.
 * @return  A {@link Call} with a configured {@link Decline}.
 */
@NotNull
public static Call decline(@NotNull final Protos.FrameworkID frameworkId, @NotNull final List<Protos.OfferID> offerIds) {
    return newBuilder()
        .setFrameworkId(frameworkId)
        .setType(Type.DECLINE)
        .setDecline(
            Decline.newBuilder()
                .addAllOfferIds(offerIds)
        )
        .build();
}
 

@Override
public void acceptOffers(
    Protos.OfferID offerId,
    Collection<Protos.Offer.Operation> operations,
    Protos.Filters filter) {
  ensureRunning();

  OfferID convertedOfferId = ProtosConversion.convert(offerId);
  Collection<Operation> convertedOperations =
      Collections2.transform(operations, ProtosConversion::convert);
  Filters convertedFilter = ProtosConversion.convert(filter);

  Futures.getUnchecked(driverFuture)
      .acceptOffers(ImmutableList.of(convertedOfferId), convertedOperations, convertedFilter);
}
 

@Override
public void declineOffer(Protos.OfferID offerId, Protos.Filters filter) {
  ensureRunning();

  OfferID convertedOfferId = ProtosConversion.convert(offerId);
  Filters convertedFilter = ProtosConversion.convert(filter);

  Futures.getUnchecked(driverFuture).declineOffer(convertedOfferId, convertedFilter);
}
 

synchronized boolean remove(Protos.OfferID id) {
  HostOffer removed = offersById.remove(id);
  if (removed != null) {
    offers.remove(removed);
    offersBySlave.remove(removed.getOffer().getAgentId());
    offersByHost.remove(removed.getOffer().getHostname());
  }
  globallyBannedOffers.remove(id);
  return removed != null;
}
 

@Override
public boolean cancel(final Protos.OfferID offerId) {
  boolean success = removeFromHostOffers(offerId);
  if (!success) {
    // This will happen rarely when we race to process this rescind against accepting the offer
    // to launch a task.
    // If it happens frequently, we are likely processing rescinds before the offer itself.
    LOG.warn("Failed to cancel offer: {}.", offerId.getValue());
    this.offerCancelFailures.incrementAndGet();
  }
  return success;
}
 

private boolean removeFromHostOffers(final Protos.OfferID offerId) {
  requireNonNull(offerId);

  // The small risk of inconsistency is acceptable here - if we have an accept/remove race
  // on an offer, the master will mark the task as LOST and it will be retried.
  return hostOffers.remove(offerId);
}
 

@Override
public void acceptOffers(Protos.OfferID offerId, Collection<Protos.Offer.Operation> operations,
    Protos.Filters filter) {
  // no-op
}
 

@VisibleForTesting
synchronized Set<Pair<Protos.OfferID, TaskGroupKey>> getStaticBans() {
  return staticallyBannedOffers.asMap().keySet();
}
 

@VisibleForTesting
synchronized void addStaticGroupBan(Protos.OfferID offerId, TaskGroupKey groupKey) {
  if (offersById.containsKey(offerId)) {
    staticallyBannedOffers.put(Pair.of(offerId, groupKey), true);
  }
}
 

@Override
public void ban(Protos.OfferID offerId) {
  // no-op
}
 

/**
 * Exclude an offer that results in a static mismatch from further attempts to match against all
 * tasks from the same group.
 */
@VisibleForTesting
void banForTaskGroup(Protos.OfferID offerId, TaskGroupKey groupKey) {
  hostOffers.addStaticGroupBan(offerId, groupKey);
}
 

/**
 * Get all static bans.
 */
@VisibleForTesting
Set<Pair<Protos.OfferID, TaskGroupKey>> getStaticBans() {
  return hostOffers.getStaticBans();
}
 

@Override
public void ban(Protos.OfferID offerId) {
  hostOffers.addGlobalBan(offerId);
}
 

private void decline(Protos.OfferID id) {
  LOG.debug("Declining offer {}", id);
  driver.declineOffer(id, getOfferFilter());
}
 

@Override
public boolean cancel(Protos.OfferID offerId) {
  return false;
}
 

@Override
public void acceptInverseOffer(Protos.OfferID offerID, Protos.Filters filter) {
  throw new UnsupportedOperationException("SchedulerDriver does not support inverse offers");
}
 

@Override
public void declineOffer(Protos.OfferID offerId, Protos.Filters filters) {
  // no-op
}
 

public static org.apache.mesos.Protos.OfferID convert(Protos.OfferID id) {
  return convert(id, org.apache.mesos.Protos.OfferID.newBuilder());
}
 

public static Protos.OfferID convert(org.apache.mesos.Protos.OfferID id) {
  return convert(id, Protos.OfferID.newBuilder());
}