EksContainerSecurityContext.h

 
#pragma once
#include <aws/batch/Batch_EXPORTS.h>
#include <aws/batch/model/EksContainerLinuxCapabilities.h>
#include <aws/batch/model/EksSeccompProfile.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace Batch {
namespace Model {
 
class EksContainerSecurityContext {
 public:
  AWS_BATCH_API EksContainerSecurityContext() = default;
  AWS_BATCH_API EksContainerSecurityContext(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API EksContainerSecurityContext& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_BATCH_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline long long GetRunAsUser() const { return m_runAsUser; }
  inline bool RunAsUserHasBeenSet() const { return m_runAsUserHasBeenSet; }
  inline void SetRunAsUser(long long value) {
    m_runAsUserHasBeenSet = true;
    m_runAsUser = value;
  }
  inline EksContainerSecurityContext& WithRunAsUser(long long value) {
    SetRunAsUser(value);
    return *this;
  }
 
 
  inline long long GetRunAsGroup() const { return m_runAsGroup; }
  inline bool RunAsGroupHasBeenSet() const { return m_runAsGroupHasBeenSet; }
  inline void SetRunAsGroup(long long value) {
    m_runAsGroupHasBeenSet = true;
    m_runAsGroup = value;
  }
  inline EksContainerSecurityContext& WithRunAsGroup(long long value) {
    SetRunAsGroup(value);
    return *this;
  }
 
 
  inline bool GetPrivileged() const { return m_privileged; }
  inline bool PrivilegedHasBeenSet() const { return m_privilegedHasBeenSet; }
  inline void SetPrivileged(bool value) {
    m_privilegedHasBeenSet = true;
    m_privileged = value;
  }
  inline EksContainerSecurityContext& WithPrivileged(bool value) {
    SetPrivileged(value);
    return *this;
  }
 
 
  inline bool GetAllowPrivilegeEscalation() const { return m_allowPrivilegeEscalation; }
  inline bool AllowPrivilegeEscalationHasBeenSet() const { return m_allowPrivilegeEscalationHasBeenSet; }
  inline void SetAllowPrivilegeEscalation(bool value) {
    m_allowPrivilegeEscalationHasBeenSet = true;
    m_allowPrivilegeEscalation = value;
  }
  inline EksContainerSecurityContext& WithAllowPrivilegeEscalation(bool value) {
    SetAllowPrivilegeEscalation(value);
    return *this;
  }
 
 
  inline bool GetReadOnlyRootFilesystem() const { return m_readOnlyRootFilesystem; }
  inline bool ReadOnlyRootFilesystemHasBeenSet() const { return m_readOnlyRootFilesystemHasBeenSet; }
  inline void SetReadOnlyRootFilesystem(bool value) {
    m_readOnlyRootFilesystemHasBeenSet = true;
    m_readOnlyRootFilesystem = value;
  }
  inline EksContainerSecurityContext& WithReadOnlyRootFilesystem(bool value) {
    SetReadOnlyRootFilesystem(value);
    return *this;
  }
 
 
  inline bool GetRunAsNonRoot() const { return m_runAsNonRoot; }
  inline bool RunAsNonRootHasBeenSet() const { return m_runAsNonRootHasBeenSet; }
  inline void SetRunAsNonRoot(bool value) {
    m_runAsNonRootHasBeenSet = true;
    m_runAsNonRoot = value;
  }
  inline EksContainerSecurityContext& WithRunAsNonRoot(bool value) {
    SetRunAsNonRoot(value);
    return *this;
  }
 
 
  inline const EksContainerLinuxCapabilities& GetCapabilities() const { return m_capabilities; }
  inline bool CapabilitiesHasBeenSet() const { return m_capabilitiesHasBeenSet; }
  template <typename CapabilitiesT = EksContainerLinuxCapabilities>
  void SetCapabilities(CapabilitiesT&& value) {
    m_capabilitiesHasBeenSet = true;
    m_capabilities = std::forward<CapabilitiesT>(value);
  }
  template <typename CapabilitiesT = EksContainerLinuxCapabilities>
  EksContainerSecurityContext& WithCapabilities(CapabilitiesT&& value) {
    SetCapabilities(std::forward<CapabilitiesT>(value));
    return *this;
  }
 
 
  inline const EksSeccompProfile& GetSeccompProfile() const { return m_seccompProfile; }
  inline bool SeccompProfileHasBeenSet() const { return m_seccompProfileHasBeenSet; }
  template <typename SeccompProfileT = EksSeccompProfile>
  void SetSeccompProfile(SeccompProfileT&& value) {
    m_seccompProfileHasBeenSet = true;
    m_seccompProfile = std::forward<SeccompProfileT>(value);
  }
  template <typename SeccompProfileT = EksSeccompProfile>
  EksContainerSecurityContext& WithSeccompProfile(SeccompProfileT&& value) {
    SetSeccompProfile(std::forward<SeccompProfileT>(value));
    return *this;
  }
 private:
  long long m_runAsUser{0};
 
  long long m_runAsGroup{0};
 
  bool m_privileged{false};
 
  bool m_allowPrivilegeEscalation{false};
 
  bool m_readOnlyRootFilesystem{false};
 
  bool m_runAsNonRoot{false};
 
  EksContainerLinuxCapabilities m_capabilities;
 
  EksSeccompProfile m_seccompProfile;
  bool m_runAsUserHasBeenSet = false;
  bool m_runAsGroupHasBeenSet = false;
  bool m_privilegedHasBeenSet = false;
  bool m_allowPrivilegeEscalationHasBeenSet = false;
  bool m_readOnlyRootFilesystemHasBeenSet = false;
  bool m_runAsNonRootHasBeenSet = false;
  bool m_capabilitiesHasBeenSet = false;
  bool m_seccompProfileHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace Batch
}  // namespace Aws