ClusterNodeDetails.h

 
#pragma once
#include <aws/core/utils/DateTime.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <aws/core/utils/memory/stl/AWSVector.h>
#include <aws/sagemaker/SageMaker_EXPORTS.h>
#include <aws/sagemaker/model/ClusterCapacityType.h>
#include <aws/sagemaker/model/ClusterInstancePlacement.h>
#include <aws/sagemaker/model/ClusterInstanceStatusDetails.h>
#include <aws/sagemaker/model/ClusterInstanceStorageConfig.h>
#include <aws/sagemaker/model/ClusterInstanceType.h>
#include <aws/sagemaker/model/ClusterKubernetesConfigNodeDetails.h>
#include <aws/sagemaker/model/ClusterLifeCycleConfig.h>
#include <aws/sagemaker/model/UltraServerInfo.h>
#include <aws/sagemaker/model/VpcConfig.h>
 
#include <utility>
 
namespace Aws {
namespace Utils {
namespace Json {
class JsonValue;
class JsonView;
}  // namespace Json
}  // namespace Utils
namespace SageMaker {
namespace Model {
 
class ClusterNodeDetails {
 public:
  AWS_SAGEMAKER_API ClusterNodeDetails() = default;
  AWS_SAGEMAKER_API ClusterNodeDetails(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API ClusterNodeDetails& operator=(Aws::Utils::Json::JsonView jsonValue);
  AWS_SAGEMAKER_API Aws::Utils::Json::JsonValue Jsonize() const;
 
 
  inline const Aws::String& GetInstanceGroupName() const { return m_instanceGroupName; }
  inline bool InstanceGroupNameHasBeenSet() const { return m_instanceGroupNameHasBeenSet; }
  template <typename InstanceGroupNameT = Aws::String>
  void SetInstanceGroupName(InstanceGroupNameT&& value) {
    m_instanceGroupNameHasBeenSet = true;
    m_instanceGroupName = std::forward<InstanceGroupNameT>(value);
  }
  template <typename InstanceGroupNameT = Aws::String>
  ClusterNodeDetails& WithInstanceGroupName(InstanceGroupNameT&& value) {
    SetInstanceGroupName(std::forward<InstanceGroupNameT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetInstanceId() const { return m_instanceId; }
  inline bool InstanceIdHasBeenSet() const { return m_instanceIdHasBeenSet; }
  template <typename InstanceIdT = Aws::String>
  void SetInstanceId(InstanceIdT&& value) {
    m_instanceIdHasBeenSet = true;
    m_instanceId = std::forward<InstanceIdT>(value);
  }
  template <typename InstanceIdT = Aws::String>
  ClusterNodeDetails& WithInstanceId(InstanceIdT&& value) {
    SetInstanceId(std::forward<InstanceIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetNodeLogicalId() const { return m_nodeLogicalId; }
  inline bool NodeLogicalIdHasBeenSet() const { return m_nodeLogicalIdHasBeenSet; }
  template <typename NodeLogicalIdT = Aws::String>
  void SetNodeLogicalId(NodeLogicalIdT&& value) {
    m_nodeLogicalIdHasBeenSet = true;
    m_nodeLogicalId = std::forward<NodeLogicalIdT>(value);
  }
  template <typename NodeLogicalIdT = Aws::String>
  ClusterNodeDetails& WithNodeLogicalId(NodeLogicalIdT&& value) {
    SetNodeLogicalId(std::forward<NodeLogicalIdT>(value));
    return *this;
  }
 
 
  inline const ClusterInstanceStatusDetails& GetInstanceStatus() const { return m_instanceStatus; }
  inline bool InstanceStatusHasBeenSet() const { return m_instanceStatusHasBeenSet; }
  template <typename InstanceStatusT = ClusterInstanceStatusDetails>
  void SetInstanceStatus(InstanceStatusT&& value) {
    m_instanceStatusHasBeenSet = true;
    m_instanceStatus = std::forward<InstanceStatusT>(value);
  }
  template <typename InstanceStatusT = ClusterInstanceStatusDetails>
  ClusterNodeDetails& WithInstanceStatus(InstanceStatusT&& value) {
    SetInstanceStatus(std::forward<InstanceStatusT>(value));
    return *this;
  }
 
 
  inline ClusterInstanceType GetInstanceType() const { return m_instanceType; }
  inline bool InstanceTypeHasBeenSet() const { return m_instanceTypeHasBeenSet; }
  inline void SetInstanceType(ClusterInstanceType value) {
    m_instanceTypeHasBeenSet = true;
    m_instanceType = value;
  }
  inline ClusterNodeDetails& WithInstanceType(ClusterInstanceType value) {
    SetInstanceType(value);
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLaunchTime() const { return m_launchTime; }
  inline bool LaunchTimeHasBeenSet() const { return m_launchTimeHasBeenSet; }
  template <typename LaunchTimeT = Aws::Utils::DateTime>
  void SetLaunchTime(LaunchTimeT&& value) {
    m_launchTimeHasBeenSet = true;
    m_launchTime = std::forward<LaunchTimeT>(value);
  }
  template <typename LaunchTimeT = Aws::Utils::DateTime>
  ClusterNodeDetails& WithLaunchTime(LaunchTimeT&& value) {
    SetLaunchTime(std::forward<LaunchTimeT>(value));
    return *this;
  }
 
 
  inline const Aws::Utils::DateTime& GetLastSoftwareUpdateTime() const { return m_lastSoftwareUpdateTime; }
  inline bool LastSoftwareUpdateTimeHasBeenSet() const { return m_lastSoftwareUpdateTimeHasBeenSet; }
  template <typename LastSoftwareUpdateTimeT = Aws::Utils::DateTime>
  void SetLastSoftwareUpdateTime(LastSoftwareUpdateTimeT&& value) {
    m_lastSoftwareUpdateTimeHasBeenSet = true;
    m_lastSoftwareUpdateTime = std::forward<LastSoftwareUpdateTimeT>(value);
  }
  template <typename LastSoftwareUpdateTimeT = Aws::Utils::DateTime>
  ClusterNodeDetails& WithLastSoftwareUpdateTime(LastSoftwareUpdateTimeT&& value) {
    SetLastSoftwareUpdateTime(std::forward<LastSoftwareUpdateTimeT>(value));
    return *this;
  }
 
 
  inline const ClusterLifeCycleConfig& GetLifeCycleConfig() const { return m_lifeCycleConfig; }
  inline bool LifeCycleConfigHasBeenSet() const { return m_lifeCycleConfigHasBeenSet; }
  template <typename LifeCycleConfigT = ClusterLifeCycleConfig>
  void SetLifeCycleConfig(LifeCycleConfigT&& value) {
    m_lifeCycleConfigHasBeenSet = true;
    m_lifeCycleConfig = std::forward<LifeCycleConfigT>(value);
  }
  template <typename LifeCycleConfigT = ClusterLifeCycleConfig>
  ClusterNodeDetails& WithLifeCycleConfig(LifeCycleConfigT&& value) {
    SetLifeCycleConfig(std::forward<LifeCycleConfigT>(value));
    return *this;
  }
 
 
  inline const VpcConfig& GetOverrideVpcConfig() const { return m_overrideVpcConfig; }
  inline bool OverrideVpcConfigHasBeenSet() const { return m_overrideVpcConfigHasBeenSet; }
  template <typename OverrideVpcConfigT = VpcConfig>
  void SetOverrideVpcConfig(OverrideVpcConfigT&& value) {
    m_overrideVpcConfigHasBeenSet = true;
    m_overrideVpcConfig = std::forward<OverrideVpcConfigT>(value);
  }
  template <typename OverrideVpcConfigT = VpcConfig>
  ClusterNodeDetails& WithOverrideVpcConfig(OverrideVpcConfigT&& value) {
    SetOverrideVpcConfig(std::forward<OverrideVpcConfigT>(value));
    return *this;
  }
 
 
  inline int GetThreadsPerCore() const { return m_threadsPerCore; }
  inline bool ThreadsPerCoreHasBeenSet() const { return m_threadsPerCoreHasBeenSet; }
  inline void SetThreadsPerCore(int value) {
    m_threadsPerCoreHasBeenSet = true;
    m_threadsPerCore = value;
  }
  inline ClusterNodeDetails& WithThreadsPerCore(int value) {
    SetThreadsPerCore(value);
    return *this;
  }
 
 
  inline const Aws::Vector<ClusterInstanceStorageConfig>& GetInstanceStorageConfigs() const { return m_instanceStorageConfigs; }
  inline bool InstanceStorageConfigsHasBeenSet() const { return m_instanceStorageConfigsHasBeenSet; }
  template <typename InstanceStorageConfigsT = Aws::Vector<ClusterInstanceStorageConfig>>
  void SetInstanceStorageConfigs(InstanceStorageConfigsT&& value) {
    m_instanceStorageConfigsHasBeenSet = true;
    m_instanceStorageConfigs = std::forward<InstanceStorageConfigsT>(value);
  }
  template <typename InstanceStorageConfigsT = Aws::Vector<ClusterInstanceStorageConfig>>
  ClusterNodeDetails& WithInstanceStorageConfigs(InstanceStorageConfigsT&& value) {
    SetInstanceStorageConfigs(std::forward<InstanceStorageConfigsT>(value));
    return *this;
  }
  template <typename InstanceStorageConfigsT = ClusterInstanceStorageConfig>
  ClusterNodeDetails& AddInstanceStorageConfigs(InstanceStorageConfigsT&& value) {
    m_instanceStorageConfigsHasBeenSet = true;
    m_instanceStorageConfigs.emplace_back(std::forward<InstanceStorageConfigsT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPrivatePrimaryIp() const { return m_privatePrimaryIp; }
  inline bool PrivatePrimaryIpHasBeenSet() const { return m_privatePrimaryIpHasBeenSet; }
  template <typename PrivatePrimaryIpT = Aws::String>
  void SetPrivatePrimaryIp(PrivatePrimaryIpT&& value) {
    m_privatePrimaryIpHasBeenSet = true;
    m_privatePrimaryIp = std::forward<PrivatePrimaryIpT>(value);
  }
  template <typename PrivatePrimaryIpT = Aws::String>
  ClusterNodeDetails& WithPrivatePrimaryIp(PrivatePrimaryIpT&& value) {
    SetPrivatePrimaryIp(std::forward<PrivatePrimaryIpT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPrivatePrimaryIpv6() const { return m_privatePrimaryIpv6; }
  inline bool PrivatePrimaryIpv6HasBeenSet() const { return m_privatePrimaryIpv6HasBeenSet; }
  template <typename PrivatePrimaryIpv6T = Aws::String>
  void SetPrivatePrimaryIpv6(PrivatePrimaryIpv6T&& value) {
    m_privatePrimaryIpv6HasBeenSet = true;
    m_privatePrimaryIpv6 = std::forward<PrivatePrimaryIpv6T>(value);
  }
  template <typename PrivatePrimaryIpv6T = Aws::String>
  ClusterNodeDetails& WithPrivatePrimaryIpv6(PrivatePrimaryIpv6T&& value) {
    SetPrivatePrimaryIpv6(std::forward<PrivatePrimaryIpv6T>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetPrivateDnsHostname() const { return m_privateDnsHostname; }
  inline bool PrivateDnsHostnameHasBeenSet() const { return m_privateDnsHostnameHasBeenSet; }
  template <typename PrivateDnsHostnameT = Aws::String>
  void SetPrivateDnsHostname(PrivateDnsHostnameT&& value) {
    m_privateDnsHostnameHasBeenSet = true;
    m_privateDnsHostname = std::forward<PrivateDnsHostnameT>(value);
  }
  template <typename PrivateDnsHostnameT = Aws::String>
  ClusterNodeDetails& WithPrivateDnsHostname(PrivateDnsHostnameT&& value) {
    SetPrivateDnsHostname(std::forward<PrivateDnsHostnameT>(value));
    return *this;
  }
 
 
  inline const ClusterInstancePlacement& GetPlacement() const { return m_placement; }
  inline bool PlacementHasBeenSet() const { return m_placementHasBeenSet; }
  template <typename PlacementT = ClusterInstancePlacement>
  void SetPlacement(PlacementT&& value) {
    m_placementHasBeenSet = true;
    m_placement = std::forward<PlacementT>(value);
  }
  template <typename PlacementT = ClusterInstancePlacement>
  ClusterNodeDetails& WithPlacement(PlacementT&& value) {
    SetPlacement(std::forward<PlacementT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetCurrentImageId() const { return m_currentImageId; }
  inline bool CurrentImageIdHasBeenSet() const { return m_currentImageIdHasBeenSet; }
  template <typename CurrentImageIdT = Aws::String>
  void SetCurrentImageId(CurrentImageIdT&& value) {
    m_currentImageIdHasBeenSet = true;
    m_currentImageId = std::forward<CurrentImageIdT>(value);
  }
  template <typename CurrentImageIdT = Aws::String>
  ClusterNodeDetails& WithCurrentImageId(CurrentImageIdT&& value) {
    SetCurrentImageId(std::forward<CurrentImageIdT>(value));
    return *this;
  }
 
 
  inline const Aws::String& GetDesiredImageId() const { return m_desiredImageId; }
  inline bool DesiredImageIdHasBeenSet() const { return m_desiredImageIdHasBeenSet; }
  template <typename DesiredImageIdT = Aws::String>
  void SetDesiredImageId(DesiredImageIdT&& value) {
    m_desiredImageIdHasBeenSet = true;
    m_desiredImageId = std::forward<DesiredImageIdT>(value);
  }
  template <typename DesiredImageIdT = Aws::String>
  ClusterNodeDetails& WithDesiredImageId(DesiredImageIdT&& value) {
    SetDesiredImageId(std::forward<DesiredImageIdT>(value));
    return *this;
  }
 
 
  inline const UltraServerInfo& GetUltraServerInfo() const { return m_ultraServerInfo; }
  inline bool UltraServerInfoHasBeenSet() const { return m_ultraServerInfoHasBeenSet; }
  template <typename UltraServerInfoT = UltraServerInfo>
  void SetUltraServerInfo(UltraServerInfoT&& value) {
    m_ultraServerInfoHasBeenSet = true;
    m_ultraServerInfo = std::forward<UltraServerInfoT>(value);
  }
  template <typename UltraServerInfoT = UltraServerInfo>
  ClusterNodeDetails& WithUltraServerInfo(UltraServerInfoT&& value) {
    SetUltraServerInfo(std::forward<UltraServerInfoT>(value));
    return *this;
  }
 
 
  inline const ClusterKubernetesConfigNodeDetails& GetKubernetesConfig() const { return m_kubernetesConfig; }
  inline bool KubernetesConfigHasBeenSet() const { return m_kubernetesConfigHasBeenSet; }
  template <typename KubernetesConfigT = ClusterKubernetesConfigNodeDetails>
  void SetKubernetesConfig(KubernetesConfigT&& value) {
    m_kubernetesConfigHasBeenSet = true;
    m_kubernetesConfig = std::forward<KubernetesConfigT>(value);
  }
  template <typename KubernetesConfigT = ClusterKubernetesConfigNodeDetails>
  ClusterNodeDetails& WithKubernetesConfig(KubernetesConfigT&& value) {
    SetKubernetesConfig(std::forward<KubernetesConfigT>(value));
    return *this;
  }
 
 
  inline ClusterCapacityType GetCapacityType() const { return m_capacityType; }
  inline bool CapacityTypeHasBeenSet() const { return m_capacityTypeHasBeenSet; }
  inline void SetCapacityType(ClusterCapacityType value) {
    m_capacityTypeHasBeenSet = true;
    m_capacityType = value;
  }
  inline ClusterNodeDetails& WithCapacityType(ClusterCapacityType value) {
    SetCapacityType(value);
    return *this;
  }
 private:
  Aws::String m_instanceGroupName;
 
  Aws::String m_instanceId;
 
  Aws::String m_nodeLogicalId;
 
  ClusterInstanceStatusDetails m_instanceStatus;
 
  ClusterInstanceType m_instanceType{ClusterInstanceType::NOT_SET};
 
  Aws::Utils::DateTime m_launchTime{};
 
  Aws::Utils::DateTime m_lastSoftwareUpdateTime{};
 
  ClusterLifeCycleConfig m_lifeCycleConfig;
 
  VpcConfig m_overrideVpcConfig;
 
  int m_threadsPerCore{0};
 
  Aws::Vector<ClusterInstanceStorageConfig> m_instanceStorageConfigs;
 
  Aws::String m_privatePrimaryIp;
 
  Aws::String m_privatePrimaryIpv6;
 
  Aws::String m_privateDnsHostname;
 
  ClusterInstancePlacement m_placement;
 
  Aws::String m_currentImageId;
 
  Aws::String m_desiredImageId;
 
  UltraServerInfo m_ultraServerInfo;
 
  ClusterKubernetesConfigNodeDetails m_kubernetesConfig;
 
  ClusterCapacityType m_capacityType{ClusterCapacityType::NOT_SET};
  bool m_instanceGroupNameHasBeenSet = false;
  bool m_instanceIdHasBeenSet = false;
  bool m_nodeLogicalIdHasBeenSet = false;
  bool m_instanceStatusHasBeenSet = false;
  bool m_instanceTypeHasBeenSet = false;
  bool m_launchTimeHasBeenSet = false;
  bool m_lastSoftwareUpdateTimeHasBeenSet = false;
  bool m_lifeCycleConfigHasBeenSet = false;
  bool m_overrideVpcConfigHasBeenSet = false;
  bool m_threadsPerCoreHasBeenSet = false;
  bool m_instanceStorageConfigsHasBeenSet = false;
  bool m_privatePrimaryIpHasBeenSet = false;
  bool m_privatePrimaryIpv6HasBeenSet = false;
  bool m_privateDnsHostnameHasBeenSet = false;
  bool m_placementHasBeenSet = false;
  bool m_currentImageIdHasBeenSet = false;
  bool m_desiredImageIdHasBeenSet = false;
  bool m_ultraServerInfoHasBeenSet = false;
  bool m_kubernetesConfigHasBeenSet = false;
  bool m_capacityTypeHasBeenSet = false;
};
 
}  // namespace Model
}  // namespace SageMaker
}  // namespace Aws