/// <summary>
 /// Initializes a new instance of the
 /// Iok8sapiextensionsv1beta1NetworkPolicyPeer class.
 /// </summary>
 /// <param name="ipBlock">IPBlock defines policy on a particular
 /// IPBlock</param>
 /// <param name="namespaceSelector">Selects Namespaces using cluster
 /// scoped-labels.  This matches all pods in all namespaces selected by
 /// this label selector. This field follows standard label selector
 /// semantics. If present but empty, this selector selects all
 /// namespaces.</param>
 /// <param name="podSelector">This is a label selector which selects
 /// Pods in this namespace. This field follows standard label selector
 /// semantics. If present but empty, this selector selects all pods in
 /// this namespace.</param>
 public Iok8sapiextensionsv1beta1NetworkPolicyPeer(Iok8sapiextensionsv1beta1IPBlock ipBlock = default(Iok8sapiextensionsv1beta1IPBlock), Iok8sapimachinerypkgapismetav1LabelSelector namespaceSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector), Iok8sapimachinerypkgapismetav1LabelSelector podSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector))
 {
     IpBlock           = ipBlock;
     NamespaceSelector = namespaceSelector;
     PodSelector       = podSelector;
     CustomInit();
 }
Пример #2
0
 /// <summary>
 /// Initializes a new instance of the
 /// Iok8sapipolicyv1beta1PodDisruptionBudgetSpec class.
 /// </summary>
 /// <param name="maxUnavailable">An eviction is allowed if at most
 /// "maxUnavailable" pods selected by "selector" are unavailable after
 /// the eviction, i.e. even in absence of the evicted pod. For example,
 /// one can prevent all voluntary evictions by specifying 0. This is a
 /// mutually exclusive setting with "minAvailable".</param>
 /// <param name="minAvailable">An eviction is allowed if at least
 /// "minAvailable" pods selected by "selector" will still be available
 /// after the eviction, i.e. even in the absence of the evicted pod.
 /// So for example you can prevent all voluntary evictions by
 /// specifying "100%".</param>
 /// <param name="selector">Label query over pods whose evictions are
 /// managed by the disruption budget.</param>
 public Iok8sapipolicyv1beta1PodDisruptionBudgetSpec(string maxUnavailable = default(string), string minAvailable = default(string), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector))
 {
     MaxUnavailable = maxUnavailable;
     MinAvailable   = minAvailable;
     Selector       = selector;
     CustomInit();
 }
 /// <summary>
 /// Initializes a new instance of the Iok8sapicorev1PodAffinityTerm
 /// class.
 /// </summary>
 /// <param name="labelSelector">A label query over a set of resources,
 /// in this case pods.</param>
 /// <param name="namespaces">namespaces specifies which namespaces the
 /// labelSelector applies to (matches against); null or empty list
 /// means "this pod's namespace"</param>
 /// <param name="topologyKey">This pod should be co-located (affinity)
 /// or not co-located (anti-affinity) with the pods matching the
 /// labelSelector in the specified namespaces, where co-located is
 /// defined as running on a node whose value of the label with key
 /// topologyKey matches that of any node on which any of the selected
 /// pods is running. For PreferredDuringScheduling pod anti-affinity,
 /// empty topologyKey is interpreted as "all topologies" ("all
 /// topologies" here means all the topologyKeys indicated by scheduler
 /// command-line argument --failure-domains); for affinity and for
 /// RequiredDuringScheduling pod anti-affinity, empty topologyKey is
 /// not allowed.</param>
 public Iok8sapicorev1PodAffinityTerm(Iok8sapimachinerypkgapismetav1LabelSelector labelSelector = default(Iok8sapimachinerypkgapismetav1LabelSelector), IList <string> namespaces = default(IList <string>), string topologyKey = default(string))
 {
     LabelSelector = labelSelector;
     Namespaces    = namespaces;
     TopologyKey   = topologyKey;
     CustomInit();
 }
 /// <summary>
 /// Initializes a new instance of the
 /// Iok8sapiextensionsv1beta1ReplicaSetSpec class.
 /// </summary>
 /// <param name="minReadySeconds">Minimum number of seconds for which a
 /// newly created pod should be ready without any of its container
 /// crashing, for it to be considered available. Defaults to 0 (pod
 /// will be considered available as soon as it is ready)</param>
 /// <param name="replicas">Replicas is the number of desired replicas.
 /// This is a pointer to distinguish between explicit zero and
 /// unspecified. Defaults to 1. More info:
 /// https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller/#what-is-a-replicationcontroller</param>
 /// <param name="selector">Selector is a label query over pods that
 /// should match the replica count. If the selector is empty, it is
 /// defaulted to the labels present on the pod template. Label keys and
 /// values that must match in order to be controlled by this replica
 /// set. More info:
 /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param>
 /// <param name="template">Template is the object that describes the
 /// pod that will be created if insufficient replicas are detected.
 /// More info:
 /// https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template</param>
 public Iok8sapiextensionsv1beta1ReplicaSetSpec(int?minReadySeconds = default(int?), int?replicas = default(int?), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), Iok8sapicorev1PodTemplateSpec template = default(Iok8sapicorev1PodTemplateSpec))
 {
     MinReadySeconds = minReadySeconds;
     Replicas        = replicas;
     Selector        = selector;
     Template        = template;
     CustomInit();
 }
Пример #5
0
 /// <summary>
 /// Initializes a new instance of the
 /// Iok8sapiextensionsv1beta1NetworkPolicySpec class.
 /// </summary>
 /// <param name="podSelector">Selects the pods to which this
 /// NetworkPolicy object applies.  The array of ingress rules is
 /// applied to any pods selected by this field. Multiple network
 /// policies can select the same set of pods.  In this case, the
 /// ingress rules for each are combined additively. This field is NOT
 /// optional and follows standard label selector semantics. An empty
 /// podSelector matches all pods in this namespace.</param>
 /// <param name="egress">List of egress rules to be applied to the
 /// selected pods. Outgoing traffic is allowed if there are no
 /// NetworkPolicies selecting the pod (and cluster policy otherwise
 /// allows the traffic), OR if the traffic matches at least one egress
 /// rule across all of the NetworkPolicy objects whose podSelector
 /// matches the pod. If this field is empty then this NetworkPolicy
 /// limits all outgoing traffic (and serves solely to ensure that the
 /// pods it selects are isolated by default). This field is beta-level
 /// in 1.8</param>
 /// <param name="ingress">List of ingress rules to be applied to the
 /// selected pods. Traffic is allowed to a pod if there are no
 /// NetworkPolicies selecting the pod OR if the traffic source is the
 /// pod's local node, OR if the traffic matches at least one ingress
 /// rule across all of the NetworkPolicy objects whose podSelector
 /// matches the pod. If this field is empty then this NetworkPolicy
 /// does not allow any traffic (and serves solely to ensure that the
 /// pods it selects are isolated by default).</param>
 /// <param name="policyTypes">List of rule types that the NetworkPolicy
 /// relates to. Valid options are Ingress, Egress, or Ingress,Egress.
 /// If this field is not specified, it will default based on the
 /// existence of Ingress or Egress rules; policies that contain an
 /// Egress section are assumed to affect Egress, and all policies
 /// (whether or not they contain an Ingress section) are assumed to
 /// affect Ingress. If you want to write an egress-only policy, you
 /// must explicitly specify policyTypes [ "Egress" ]. Likewise, if you
 /// want to write a policy that specifies that no egress is allowed,
 /// you must specify a policyTypes value that include "Egress" (since
 /// such a policy would not include an Egress section and would
 /// otherwise default to just [ "Ingress" ]). This field is beta-level
 /// in 1.8</param>
 public Iok8sapiextensionsv1beta1NetworkPolicySpec(Iok8sapimachinerypkgapismetav1LabelSelector podSelector, IList <Iok8sapiextensionsv1beta1NetworkPolicyEgressRule> egress = default(IList <Iok8sapiextensionsv1beta1NetworkPolicyEgressRule>), IList <Iok8sapiextensionsv1beta1NetworkPolicyIngressRule> ingress = default(IList <Iok8sapiextensionsv1beta1NetworkPolicyIngressRule>), IList <string> policyTypes = default(IList <string>))
 {
     Egress      = egress;
     Ingress     = ingress;
     PodSelector = podSelector;
     PolicyTypes = policyTypes;
     CustomInit();
 }
 /// <summary>
 /// Initializes a new instance of the Iok8sapiappsv1beta2DaemonSetSpec
 /// class.
 /// </summary>
 /// <param name="template">An object that describes the pod that will
 /// be created. The DaemonSet will create exactly one copy of this pod
 /// on every node that matches the template's node selector (or on
 /// every node if no node selector is specified). More info:
 /// https://kubernetes.io/docs/concepts/workloads/controllers/replicationcontroller#pod-template</param>
 /// <param name="minReadySeconds">The minimum number of seconds for
 /// which a newly created DaemonSet pod should be ready without any of
 /// its container crashing, for it to be considered available. Defaults
 /// to 0 (pod will be considered available as soon as it is
 /// ready).</param>
 /// <param name="revisionHistoryLimit">The number of old history to
 /// retain to allow rollback. This is a pointer to distinguish between
 /// explicit zero and not specified. Defaults to 10.</param>
 /// <param name="selector">A label query over pods that are managed by
 /// the daemon set. Must match in order to be controlled. If empty,
 /// defaulted to labels on Pod template. More info:
 /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param>
 /// <param name="updateStrategy">An update strategy to replace existing
 /// DaemonSet pods with new pods.</param>
 public Iok8sapiappsv1beta2DaemonSetSpec(Iok8sapicorev1PodTemplateSpec template, int?minReadySeconds = default(int?), int?revisionHistoryLimit = default(int?), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), Iok8sapiappsv1beta2DaemonSetUpdateStrategy updateStrategy = default(Iok8sapiappsv1beta2DaemonSetUpdateStrategy))
 {
     MinReadySeconds      = minReadySeconds;
     RevisionHistoryLimit = revisionHistoryLimit;
     Selector             = selector;
     Template             = template;
     UpdateStrategy       = updateStrategy;
     CustomInit();
 }
Пример #7
0
 /// <summary>
 /// Initializes a new instance of the
 /// Iok8sapicorev1PersistentVolumeClaimSpec class.
 /// </summary>
 /// <param name="accessModes">AccessModes contains the desired access
 /// modes the volume should have. More info:
 /// https://kubernetes.io/docs/concepts/storage/persistent-volumes#access-modes-1</param>
 /// <param name="resources">Resources represents the minimum resources
 /// the volume should have. More info:
 /// https://kubernetes.io/docs/concepts/storage/persistent-volumes#resources</param>
 /// <param name="selector">A label query over volumes to consider for
 /// binding.</param>
 /// <param name="storageClassName">Name of the StorageClass required by
 /// the claim. More info:
 /// https://kubernetes.io/docs/concepts/storage/persistent-volumes#class-1</param>
 /// <param name="volumeName">VolumeName is the binding reference to the
 /// PersistentVolume backing this claim.</param>
 public Iok8sapicorev1PersistentVolumeClaimSpec(IList <string> accessModes = default(IList <string>), Iok8sapicorev1ResourceRequirements resources = default(Iok8sapicorev1ResourceRequirements), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), string storageClassName = default(string), string volumeName = default(string))
 {
     AccessModes      = accessModes;
     Resources        = resources;
     Selector         = selector;
     StorageClassName = storageClassName;
     VolumeName       = volumeName;
     CustomInit();
 }
Пример #8
0
 /// <summary>
 /// Initializes a new instance of the
 /// Iok8sapisettingsv1alpha1PodPresetSpec class.
 /// </summary>
 /// <param name="env">Env defines the collection of EnvVar to inject
 /// into containers.</param>
 /// <param name="envFrom">EnvFrom defines the collection of
 /// EnvFromSource to inject into containers.</param>
 /// <param name="selector">Selector is a label query over a set of
 /// resources, in this case pods. Required.</param>
 /// <param name="volumeMounts">VolumeMounts defines the collection of
 /// VolumeMount to inject into containers.</param>
 /// <param name="volumes">Volumes defines the collection of Volume to
 /// inject into the pod.</param>
 public Iok8sapisettingsv1alpha1PodPresetSpec(IList <Iok8sapicorev1EnvVar> env = default(IList <Iok8sapicorev1EnvVar>), IList <Iok8sapicorev1EnvFromSource> envFrom = default(IList <Iok8sapicorev1EnvFromSource>), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), IList <Iok8sapicorev1VolumeMount> volumeMounts = default(IList <Iok8sapicorev1VolumeMount>), IList <Iok8sapicorev1Volume> volumes = default(IList <Iok8sapicorev1Volume>))
 {
     Env          = env;
     EnvFrom      = envFrom;
     Selector     = selector;
     VolumeMounts = volumeMounts;
     Volumes      = volumes;
     CustomInit();
 }
Пример #9
0
 /// <summary>
 /// Initializes a new instance of the Iok8sapibatchv1JobSpec class.
 /// </summary>
 /// <param name="template">Describes the pod that will be created when
 /// executing a job. More info:
 /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/</param>
 /// <param name="activeDeadlineSeconds">Specifies the duration in
 /// seconds relative to the startTime that the job may be active before
 /// the system tries to terminate it; value must be positive
 /// integer</param>
 /// <param name="backoffLimit">Specifies the number of retries before
 /// marking this job failed. Defaults to 6</param>
 /// <param name="completions">Specifies the desired number of
 /// successfully finished pods the job should be run with.  Setting to
 /// nil means that the success of any pod signals the success of all
 /// pods, and allows parallelism to have any positive value.  Setting
 /// to 1 means that parallelism is limited to 1 and the success of that
 /// pod signals the success of the job. More info:
 /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/</param>
 /// <param name="manualSelector">manualSelector controls generation of
 /// pod labels and pod selectors. Leave `manualSelector` unset unless
 /// you are certain what you are doing. When false or unset, the system
 /// pick labels unique to this job and appends those labels to the pod
 /// template.  When true, the user is responsible for picking unique
 /// labels and specifying the selector.  Failure to pick a unique label
 /// may cause this and other jobs to not function correctly.  However,
 /// You may see `manualSelector=true` in jobs that were created with
 /// the old `extensions/v1beta1` API. More info:
 /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/#specifying-your-own-pod-selector</param>
 /// <param name="parallelism">Specifies the maximum desired number of
 /// pods the job should run at any given time. The actual number of
 /// pods running in steady state will be less than this number when
 /// ((.spec.completions - .status.successful) &lt; .spec.parallelism),
 /// i.e. when the work left to do is less than max parallelism. More
 /// info:
 /// https://kubernetes.io/docs/concepts/workloads/controllers/jobs-run-to-completion/</param>
 /// <param name="selector">A label query over pods that should match
 /// the pod count. Normally, the system sets this field for you. More
 /// info:
 /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param>
 public Iok8sapibatchv1JobSpec(Iok8sapicorev1PodTemplateSpec template, long?activeDeadlineSeconds = default(long?), int?backoffLimit = default(int?), int?completions = default(int?), bool?manualSelector = default(bool?), int?parallelism = default(int?), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector))
 {
     ActiveDeadlineSeconds = activeDeadlineSeconds;
     BackoffLimit          = backoffLimit;
     Completions           = completions;
     ManualSelector        = manualSelector;
     Parallelism           = parallelism;
     Selector = selector;
     Template = template;
     CustomInit();
 }
Пример #10
0
 /// <summary>
 /// Initializes a new instance of the
 /// Iok8sapiappsv1beta2StatefulSetSpec class.
 /// </summary>
 /// <param name="serviceName">serviceName is the name of the service
 /// that governs this StatefulSet. This service must exist before the
 /// StatefulSet, and is responsible for the network identity of the
 /// set. Pods get DNS/hostnames that follow the pattern:
 /// pod-specific-string.serviceName.default.svc.cluster.local where
 /// "pod-specific-string" is managed by the StatefulSet
 /// controller.</param>
 /// <param name="template">template is the object that describes the
 /// pod that will be created if insufficient replicas are detected.
 /// Each pod stamped out by the StatefulSet will fulfill this Template,
 /// but have a unique identity from the rest of the
 /// StatefulSet.</param>
 /// <param name="podManagementPolicy">podManagementPolicy controls how
 /// pods are created during initial scale up, when replacing pods on
 /// nodes, or when scaling down. The default policy is `OrderedReady`,
 /// where pods are created in increasing order (pod-0, then pod-1, etc)
 /// and the controller will wait until each pod is ready before
 /// continuing. When scaling down, the pods are removed in the opposite
 /// order. The alternative policy is `Parallel` which will create pods
 /// in parallel to match the desired scale without waiting, and on
 /// scale down will delete all pods at once.</param>
 /// <param name="replicas">replicas is the desired number of replicas
 /// of the given Template. These are replicas in the sense that they
 /// are instantiations of the same Template, but individual replicas
 /// also have a consistent identity. If unspecified, defaults to
 /// 1.</param>
 /// <param name="revisionHistoryLimit">revisionHistoryLimit is the
 /// maximum number of revisions that will be maintained in the
 /// StatefulSet's revision history. The revision history consists of
 /// all revisions not represented by a currently applied
 /// StatefulSetSpec version. The default value is 10.</param>
 /// <param name="selector">selector is a label query over pods that
 /// should match the replica count. If empty, defaulted to labels on
 /// the pod template. More info:
 /// https://kubernetes.io/docs/concepts/overview/working-with-objects/labels/#label-selectors</param>
 /// <param name="updateStrategy">updateStrategy indicates the
 /// StatefulSetUpdateStrategy that will be employed to update Pods in
 /// the StatefulSet when a revision is made to Template.</param>
 /// <param name="volumeClaimTemplates">volumeClaimTemplates is a list
 /// of claims that pods are allowed to reference. The StatefulSet
 /// controller is responsible for mapping network identities to claims
 /// in a way that maintains the identity of a pod. Every claim in this
 /// list must have at least one matching (by name) volumeMount in one
 /// container in the template. A claim in this list takes precedence
 /// over any volumes in the template, with the same name.</param>
 public Iok8sapiappsv1beta2StatefulSetSpec(string serviceName, Iok8sapicorev1PodTemplateSpec template, string podManagementPolicy = default(string), int?replicas = default(int?), int?revisionHistoryLimit = default(int?), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), Iok8sapiappsv1beta2StatefulSetUpdateStrategy updateStrategy = default(Iok8sapiappsv1beta2StatefulSetUpdateStrategy), IList <Iok8sapicorev1PersistentVolumeClaim> volumeClaimTemplates = default(IList <Iok8sapicorev1PersistentVolumeClaim>))
 {
     PodManagementPolicy  = podManagementPolicy;
     Replicas             = replicas;
     RevisionHistoryLimit = revisionHistoryLimit;
     Selector             = selector;
     ServiceName          = serviceName;
     Template             = template;
     UpdateStrategy       = updateStrategy;
     VolumeClaimTemplates = volumeClaimTemplates;
     CustomInit();
 }
 /// <summary>
 /// Initializes a new instance of the Iok8sapiappsv1beta2DeploymentSpec
 /// class.
 /// </summary>
 /// <param name="template">Template describes the pods that will be
 /// created.</param>
 /// <param name="minReadySeconds">Minimum number of seconds for which a
 /// newly created pod should be ready without any of its container
 /// crashing, for it to be considered available. Defaults to 0 (pod
 /// will be considered available as soon as it is ready)</param>
 /// <param name="paused">Indicates that the deployment is
 /// paused.</param>
 /// <param name="progressDeadlineSeconds">The maximum time in seconds
 /// for a deployment to make progress before it is considered to be
 /// failed. The deployment controller will continue to process failed
 /// deployments and a condition with a ProgressDeadlineExceeded reason
 /// will be surfaced in the deployment status. Note that progress will
 /// not be estimated during the time a deployment is paused. Defaults
 /// to 600s.</param>
 /// <param name="replicas">Number of desired pods. This is a pointer to
 /// distinguish between explicit zero and not specified. Defaults to
 /// 1.</param>
 /// <param name="revisionHistoryLimit">The number of old ReplicaSets to
 /// retain to allow rollback. This is a pointer to distinguish between
 /// explicit zero and not specified. Defaults to 10.</param>
 /// <param name="selector">Label selector for pods. Existing
 /// ReplicaSets whose pods are selected by this will be the ones
 /// affected by this deployment.</param>
 /// <param name="strategy">The deployment strategy to use to replace
 /// existing pods with new ones.</param>
 public Iok8sapiappsv1beta2DeploymentSpec(Iok8sapicorev1PodTemplateSpec template, int?minReadySeconds = default(int?), bool?paused = default(bool?), int?progressDeadlineSeconds = default(int?), int?replicas = default(int?), int?revisionHistoryLimit = default(int?), Iok8sapimachinerypkgapismetav1LabelSelector selector = default(Iok8sapimachinerypkgapismetav1LabelSelector), Iok8sapiappsv1beta2DeploymentStrategy strategy = default(Iok8sapiappsv1beta2DeploymentStrategy))
 {
     MinReadySeconds         = minReadySeconds;
     Paused                  = paused;
     ProgressDeadlineSeconds = progressDeadlineSeconds;
     Replicas                = replicas;
     RevisionHistoryLimit    = revisionHistoryLimit;
     Selector                = selector;
     Strategy                = strategy;
     Template                = template;
     CustomInit();
 }