src/master/registry_operations.hpp

// Licensed to the Apache Software Foundation (ASF) under one
// or more contributor license agreements.  See the NOTICE file
// distributed with this work for additional information
// regarding copyright ownership.  The ASF licenses this file
// to you under the Apache License, Version 2.0 (the
// "License"); you may not use this file except in compliance
// with the License.  You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

#ifndef __MASTER_REGISTRY_OPERATIONS_HPP__
#define __MASTER_REGISTRY_OPERATIONS_HPP__

#include <mesos/mesos.hpp>
#include <mesos/type_utils.hpp>

#include "master/registrar.hpp"


namespace mesos {
namespace internal {
namespace master {

// Add a new slave to the list of admitted slaves.
class AdmitSlave : public RegistryOperation
{
public:
  explicit AdmitSlave(const SlaveInfo& _info);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  SlaveInfo info;
};


// Update the SlaveInfo of an existing admitted slave.
class UpdateSlave : public RegistryOperation
{
public:
  explicit UpdateSlave(const SlaveInfo& _info);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  SlaveInfo info;
};


// Move a slave from the list of admitted slaves to the list of
// unreachable slaves.
class MarkSlaveUnreachable : public RegistryOperation
{
public:
  MarkSlaveUnreachable(
      const SlaveInfo& _info,
      const TimeInfo& _unreachableTime);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  const SlaveInfo info;
  const TimeInfo unreachableTime;
};


// Add a slave back to the list of admitted slaves. The slave will
// typically be in the "unreachable" list; if so, it is removed from
// that list. The slave might also be in the "admitted" list already.
// Finally, the slave might be in neither the "unreachable" or
// "admitted" lists, if its metadata has been garbage collected from
// the registry.
class MarkSlaveReachable : public RegistryOperation
{
public:
  explicit MarkSlaveReachable(const SlaveInfo& _info);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  SlaveInfo info;
};


class Prune : public RegistryOperation
{
public:
  explicit Prune(
      const hashset<SlaveID>& _toRemoveUnreachable,
      const hashset<SlaveID>& _toRemoveGone);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* /*slaveIDs*/)
    override;

private:
  const hashset<SlaveID> toRemoveUnreachable;
  const hashset<SlaveID> toRemoveGone;
};


class RemoveSlave : public RegistryOperation
{
public:
  explicit RemoveSlave(const SlaveInfo& _info);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  const SlaveInfo info;
};


// Move a slave from the list of admitted/unreachable slaves
// to the list of gone slaves.
class MarkSlaveGone : public RegistryOperation
{
public:
  MarkSlaveGone(const SlaveID& _id, const TimeInfo& _goneTime);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  const SlaveID id;
  const TimeInfo goneTime;
};


// Marks an existing agent for draining.
// Also adds a minimum capability to the master for AGENT_DRAINING.
class DrainAgent : public RegistryOperation
{
public:
  DrainAgent(
      const SlaveID& _slaveId,
      const Option<DurationInfo>& _maxGracePeriod,
      const bool _markGone);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  const SlaveID slaveId;
  const Option<DurationInfo> maxGracePeriod;
  const bool markGone;
};


// Transitions a DRAINING agent into the DRAINED state.
class MarkAgentDrained : public RegistryOperation
{
public:
  MarkAgentDrained(const SlaveID& _slaveId);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  const SlaveID slaveId;
};


// Marks an existing agent as deactivated.
// Also adds a minimum capability to the master for AGENT_DRAINING.
class DeactivateAgent : public RegistryOperation
{
public:
  DeactivateAgent(const SlaveID& _slaveId);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  const SlaveID slaveId;
};


// Clears draining or deactivation from an existing agent.
// If there are no remaining draining or deactivated agents,
// this also clears the minimum capability for AGENT_DRAINING.
class ReactivateAgent : public RegistryOperation
{
public:
  ReactivateAgent(const SlaveID& _slaveId);

protected:
  Try<bool> perform(Registry* registry, hashset<SlaveID>* slaveIDs) override;

private:
  const SlaveID slaveId;
};

} // namespace master {
} // namespace internal {
} // namespace mesos {

#endif // __MASTER_REGISTRY_OPERATIONS_HPP__