k8s-pb 0.1.0

Bindings for the Kubernetes Client API
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98

/// Overhead structure represents the resource overhead associated with running a pod.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Overhead {
    /// podFixed represents the fixed resource overhead associated with running a pod.
    /// +optional
    #[prost(map="string, message", tag="1")]
    pub pod_fixed: ::std::collections::HashMap<::prost::alloc::string::String, super::super::super::apimachinery::pkg::api::resource::Quantity>,
}
/// RuntimeClass defines a class of container runtime supported in the cluster.
/// The RuntimeClass is used to determine which container runtime is used to run
/// all containers in a pod. RuntimeClasses are manually defined by a
/// user or cluster provisioner, and referenced in the PodSpec. The Kubelet is
/// responsible for resolving the RuntimeClassName reference before running the
/// pod.  For more details, see
/// https://kubernetes.io/docs/concepts/containers/runtime-class/
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RuntimeClass {
    /// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
    /// +optional
    #[prost(message, optional, tag="1")]
    pub metadata: ::core::option::Option<super::super::super::apimachinery::pkg::apis::meta::v1::ObjectMeta>,
    /// handler specifies the underlying runtime and configuration that the CRI
    /// implementation will use to handle pods of this class. The possible values
    /// are specific to the node & CRI configuration.  It is assumed that all
    /// handlers are available on every node, and handlers of the same name are
    /// equivalent on every node.
    /// For example, a handler called "runc" might specify that the runc OCI
    /// runtime (using native Linux containers) will be used to run the containers
    /// in a pod.
    /// The Handler must be lowercase, conform to the DNS Label (RFC 1123) requirements,
    /// and is immutable.
    #[prost(string, optional, tag="2")]
    pub handler: ::core::option::Option<::prost::alloc::string::String>,
    /// overhead represents the resource overhead associated with running a pod for a
    /// given RuntimeClass. For more details, see
    ///  https://kubernetes.io/docs/concepts/scheduling-eviction/pod-overhead/
    /// +optional
    #[prost(message, optional, tag="3")]
    pub overhead: ::core::option::Option<Overhead>,
    /// scheduling holds the scheduling constraints to ensure that pods running
    /// with this RuntimeClass are scheduled to nodes that support it.
    /// If scheduling is nil, this RuntimeClass is assumed to be supported by all
    /// nodes.
    /// +optional
    #[prost(message, optional, tag="4")]
    pub scheduling: ::core::option::Option<Scheduling>,
}
/// RuntimeClassList is a list of RuntimeClass objects.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RuntimeClassList {
    /// Standard list metadata.
    /// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#metadata
    /// +optional
    #[prost(message, optional, tag="1")]
    pub metadata: ::core::option::Option<super::super::super::apimachinery::pkg::apis::meta::v1::ListMeta>,
    /// items is a list of schema objects.
    #[prost(message, repeated, tag="2")]
    pub items: ::prost::alloc::vec::Vec<RuntimeClass>,
}
/// Scheduling specifies the scheduling constraints for nodes supporting a
/// RuntimeClass.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct Scheduling {
    /// nodeSelector lists labels that must be present on nodes that support this
    /// RuntimeClass. Pods using this RuntimeClass can only be scheduled to a
    /// node matched by this selector. The RuntimeClass nodeSelector is merged
    /// with a pod's existing nodeSelector. Any conflicts will cause the pod to
    /// be rejected in admission.
    /// +optional
    /// +mapType=atomic
    #[prost(map="string, string", tag="1")]
    pub node_selector: ::std::collections::HashMap<::prost::alloc::string::String, ::prost::alloc::string::String>,
    /// tolerations are appended (excluding duplicates) to pods running with this
    /// RuntimeClass during admission, effectively unioning the set of nodes
    /// tolerated by the pod and the RuntimeClass.
    /// +optional
    /// +listType=atomic
    #[prost(message, repeated, tag="2")]
    pub tolerations: ::prost::alloc::vec::Vec<super::super::core::v1::Toleration>,
}

impl crate::Resource for RuntimeClass {
    const API_VERSION: &'static str = "node.k8s.io/v1";
    const GROUP: &'static str = "node.k8s.io";
    const VERSION: &'static str = "v1";
    const KIND: &'static str = "RuntimeClass";
    const NAME: &'static str = "runtimeclasses";
}
impl crate::HasMetadata for RuntimeClass {
    type Metadata = crate::apimachinery::pkg::apis::meta::v1::ObjectMeta;
    fn metadata(&self) -> Option<&<Self as crate::HasMetadata>::Metadata> {
        self.metadata.as_ref()
    }
    fn metadata_mut(&mut self) -> Option<&mut <Self as crate::HasMetadata>::Metadata> {
        self.metadata.as_mut()
    }
}