Job.hpp

/*
 * Job.hpp
 *
 * Copyright (C) 2020 by RStudio, PBC
 *
 * Unless you have received this program directly from RStudio pursuant to the terms of a commercial license agreement
 * with RStudio, then this program is licensed to you under the following terms:
 *
 * Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated
 * documentation files (the "Software"), to deal in the Software without restriction, including without limitation the
 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to
 * permit persons to whom the Software is furnished to do so, subject to the following conditions:
 *
 * The above copyright notice and this permission notice shall be included in all copies or substantial portions of the
 * Software.
 *
 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
 * WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
 * COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
 *
 */
 
#ifndef LAUNCHER_PLUGINS_JOB_HPP
#define LAUNCHER_PLUGINS_JOB_HPP
 
#include <ctime>
#include <set>
#include <string>
#include <vector>
 
#include <Noncopyable.hpp>
#include <Optional.hpp>
#include <PImpl.hpp>
#include <json/Json.hpp>
#include <system/DateTime.hpp>
#include <system/User.hpp>
#include <utils/MutexUtils.hpp>
 
namespace rstudio {
namespace launcher_plugins {
 
class Error;
 
} // namespace launcher_plugins
} // namespace rstudio
 
namespace rstudio {
namespace launcher_plugins {
namespace api {
 
 
// Forward Declarations
struct AzureFileMountSource;
struct CephFsMountSource;
struct Container;
struct ExposedPort;
struct GlusterFsMountSource;
struct HostMountSource;
struct Job;
struct JobConfig;
class JobLock;
struct Mount;
struct MountSource;
struct NfsMountSource;
struct ResourceLimit;
struct PlacementConstraint;
 
// Convenience Typedefs
typedef std::shared_ptr<Job> JobPtr;
typedef std::shared_ptr<const Job> ConstJobPtr;
 
typedef std::pair<std::string, std::string> EnvVariable;
typedef std::vector<EnvVariable> EnvironmentList;
typedef std::vector<ExposedPort> ExposedPortList;
typedef std::vector<JobConfig> JobConfigList;
typedef std::vector<JobPtr> JobList;
typedef std::vector<Mount> MountList;
typedef std::vector<PlacementConstraint> PlacementConstraintList;
typedef std::vector<ResourceLimit> ResourceLimitList;
 
struct Container
{
   static Error fromJson(const json::Object& in_json, Container& out_container);
 
   json::Object toJson() const;
 
   std::string Image;
 
   Optional<int> RunAsUserId;
 
   Optional<int> RunAsGroupId;
 
   std::vector<int> SupplementalGroupIds;
};
 
struct ExposedPort
{
   static Error fromJson(const json::Object& in_json, ExposedPort& out_exposedPort);
 
   json::Object toJson() const;
 
   Optional<int> PublishedPort;
 
   std::string Protocol;
 
   int TargetPort;
};
 
struct Job
{
   enum class State
   {
      CANCELED,
 
      FAILED,
 
      FINISHED,
 
      KILLED,
 
      PENDING,
 
      RUNNING,
 
      SUSPENDED,
 
      UNKNOWN
   };
 
   Job();
 
   Job(const Job& in_other);
 
   Job(Job&& in_other) noexcept;
 
   static Error fromJson(const json::Object& in_json, Job& out_job);
 
   static Error stateFromString(const std::string& in_statusString, State& out_status);
 
   static std::string stateToString(State in_status);
 
   Job& operator=(const Job& in_other);
 
   Job& operator=(Job&& in_other) noexcept;
 
   Optional<std::string> getJobConfigValue(const std::string& in_name) const;
 
   bool isCompleted() const;
 
   bool matchesTags(const std::set<std::string>& in_tags) const;
 
   json::Object toJson() const;
 
   std::vector<std::string> Arguments;
 
   std::string Cluster;
 
   std::string Command;
 
   JobConfigList Config;
 
   Optional<Container> ContainerDetails;
 
   EnvironmentList Environment;
 
   std::string Exe;
 
   Optional<int> ExitCode;
 
   ExposedPortList ExposedPorts;
 
   std::string Host;
 
   std::string Id;
 
   Optional<system::DateTime> LastUpdateTime;
 
   MountList Mounts;
 
   std::string Name;
 
   Optional<pid_t> Pid;
 
   PlacementConstraintList PlacementConstraints;
 
   std::set<std::string> Queues;
 
   ResourceLimitList ResourceLimits;
 
   std::string StandardIn;
 
   std::string StandardErrFile;
 
   std::string StandardOutFile;
 
   State Status;
 
   std::string StatusMessage;
 
   system::DateTime SubmissionTime;
 
   std::set<std::string> Tags;
 
   system::User User;
 
   std::string WorkingDirectory;
 
private:
   friend class JobLock;
 
   // The  private implementation of a Job object.
   PRIVATE_IMPL(m_impl);
};
 
struct JobConfig
{
   enum class Type
   {
         ENUM,
 
         FLOAT,
 
         INT,
 
         STRING
   };
 
   JobConfig() = default;
 
   JobConfig(std::string in_name, Type in_type);
 
   static Error fromJson(const json::Object& in_json, JobConfig& out_jobConfig);
 
   json::Object toJson() const;
 
   std::string Name;
 
   Optional<Type> ValueType;
 
   std::string Value;
};
 
class JobLock : Noncopyable
{
public:
   explicit JobLock(JobPtr in_job);
 
   explicit JobLock(ConstJobPtr in_job);
 
private:
   // The private implementation of JobLock.
   PRIVATE_IMPL(m_impl);
};
 
struct MountSource
{
   enum class Type
   {
      AZURE_FILE,
 
      CEPH_FS,
 
      GLUSTER_FS,
 
      HOST,
 
      NFS,
 
      PASSTHROUGH
   };
   
   virtual ~MountSource() = default;
 
   static Error fromJson(const json::Object& in_json, MountSource& out_mountSource);
 
   AzureFileMountSource& asAzureFileMountSource();
 
   const AzureFileMountSource& asAzureFileMountSource() const;
 
   CephFsMountSource& asCephFsMountSource();
 
   const CephFsMountSource& asCephFsMountSource() const;
 
   GlusterFsMountSource& asGlusterFsMountSource();
 
   const GlusterFsMountSource& asGlusterFsMountSource() const;
 
   HostMountSource& asHostMountSource();
 
   const HostMountSource& asHostMountSource() const;
 
   NfsMountSource& asNfsMountSource();
 
   const NfsMountSource& asNfsMountSource() const;
 
   bool isAzureFileMountSource() const;
 
   bool isCephFsMountSource() const;
 
   bool isGlusterFsMountSource() const;
 
   bool isHostMountSource() const;
 
   bool isNfsMountSource() const;
 
   bool isPassthroughMountSource() const;
 
   json::Object toJson() const;
   std::string CustomType;
 
   json::Object SourceObject;
 
   Type SourceType;
};
 
struct AzureFileMountSource final : MountSource
{
   static Error fromJson(const json::Object& in_json, AzureFileMountSource& out_mountSource);
 
   std::string getSecretName() const;
 
   std::string getShareName() const;
 
private:
   AzureFileMountSource();
 
   friend class MountSource;
};
 
 
struct CephFsMountSource final : MountSource
{
   static Error fromJson(const json::Object& in_json, CephFsMountSource& out_mountSource);
 
   std::vector<std::string> getMonitors() const;
 
   std::string getPath() const;
 
   std::string getUser() const;
 
   std::string getSecretFile() const;
 
   std::string getSecretRef() const;
 
private:
   CephFsMountSource();
 
   friend class MountSource;
};
 
 
struct GlusterFsMountSource final : MountSource
{
   GlusterFsMountSource();
   
   static Error fromJson(const json::Object& in_json, GlusterFsMountSource& out_mountSource);
 
   std::string getEndpoints() const;
 
   std::string getPath() const;
};
 
struct HostMountSource final : MountSource
{
   static Error fromJson(const json::Object& in_json, HostMountSource& out_mountSource);
 
   std::string getPath() const;
 
private:
   HostMountSource();
   
   friend class MountSource;
};
 
struct NfsMountSource final : MountSource
{
   static Error fromJson(const json::Object& in_json, NfsMountSource& out_mountSource);
 
   std::string getHost() const;
 
   std::string getPath() const;
 
private:
   NfsMountSource();
   
   friend class MountSource;
};
 
struct Mount
{
   static Error fromJson(const json::Object& in_json, Mount& out_mount);
   json::Object toJson() const;
 
   std::string Destination;
 
   bool IsReadOnly;
 
   MountSource Source;
};
 
struct PlacementConstraint
{
   PlacementConstraint() = default;
 
   explicit PlacementConstraint(std::string in_name);
 
   PlacementConstraint(std::string in_name, std::string in_value);
 
   static Error fromJson(const json::Object& in_json, PlacementConstraint& out_placementConstraint);
 
   json::Object toJson() const;
 
   std::string Name;
 
   std::string Value;
};
 
struct ResourceLimit
{
   struct Type
   {
      static const char* const CPU_COUNT;
 
      static const char* const CPU_TIME;
 
      static const char* const MEMORY;
 
      static const char* const MEMORY_SWAP;
   };
 
   ResourceLimit() = default;
 
   explicit ResourceLimit(std::string in_limitType, std::string in_maxValue = "", std::string in_defaultValue = "");
 
   static Error fromJson(const json::Object& in_json, ResourceLimit& out_resourceLimit);
 
   json::Object toJson() const;
 
   std::string ResourceType;
 
   std::string Value;
 
   std::string MaxValue;
 
   std::string DefaultValue;
};
 
#define LOCK_JOB(in_job)                                    \
try                                                         \
{                                                           \
   rstudio::launcher_plugins::api::JobLock jobLock(in_job); \
 
 
#define LOCK_MUTEX_AND_JOB(in_lockType, in_mutexType, in_mutex, in_job)    \
try                                                                        \
{                                                                          \
   in_lockType<in_mutexType> mutexLock(in_mutex);                          \
   rstudio::launcher_plugins::api::JobLock jobLock(in_job);                \
 
 
#define END_LOCK_JOB END_LOCK_MUTEX
 
#define END_LOCK_MUTEX_AND_JOB END_LOCK_JOB 
 
} // namespace api
} // namespace launcher_plugins
} // namespace rstudio
 
#endif