Method foreach

src/examples/inverse_offer_framework.cpp:260–369

    }

    foreach (const Offer& offer, offers) {
      const Resources taskResources = [this]() {
        Resources resources = Resources::parse(
            "cpus:" + stringify(CPUS_PER_TASK) +
            ";mem:" + stringify(MEM_PER_TASK)).get();
        resources.allocate(framework.role());
        return resources;
      }();

      // Are there already `num_task` sleep tasks running?
      // Having `num_task` sleeps running takes priority over dealing
      // with maintenance.
      bool needMoreSleep = sleepers.size() < num_tasks;

      // Is the agent in the offer less risky than our riskiest agent?
      // i.e. The offered agent's planned downtime is farther away.
      bool offeredAgentIsLessRisky = riskiestAgent.isSome() &&
          (!offer.has_unavailability() ||
            offer.unavailability().start().nanoseconds() >
            sleepers[riskiestAgent.get()].unavailability.nanoseconds());

      // Are we already running a task on this agent?
      // This scheduler will only launch one task per agent.
      bool offeredAgentIsOccupied = sleepers.contains(offer.agent_id());

      // We only need to accept an offer if we do not have enough sleep
      // tasks active, or the offer provides a better agent.
      bool needToLaunchTask = !offeredAgentIsOccupied &&
        (needMoreSleep || offeredAgentIsLessRisky);

      Resources resources(offer.resources());

      // Check if this offer is big enough and if we need to launch anything.
      if (!resources.toUnreserved().contains(taskResources) ||
          !needToLaunchTask) {
        Call call;
        call.mutable_framework_id()->CopyFrom(framework.id());
        call.set_type(Call::DECLINE);

        Call::Decline* decline = call.mutable_decline();
        decline->add_offer_ids()->CopyFrom(offer.id());
        decline->mutable_filters()->set_refuse_seconds(600);

        mesos->send(call);
        continue;
      }

      // Keeping `num_tasks` running has higher priority than migrating tasks.
      // We only migrate tasks if there are enough running tasks.
      if (!needMoreSleep && offeredAgentIsLessRisky) {
        LOG(INFO) << "Migrating task " << sleepers[riskiestAgent.get()].taskId
                  << " from " << riskiestAgent.get();

        Call call;
        call.mutable_framework_id()->CopyFrom(framework.id());
        call.set_type(Call::KILL);

        Call::Kill* kill = call.mutable_kill();