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

/// 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 (currently) 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://git.k8s.io/enhancements/keps/sig-node/585-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>,
    /// spec represents specification of the RuntimeClass
    /// More info: https://git.k8s.io/community/contributors/devel/sig-architecture/api-conventions.md#spec-and-status
    #[prost(message, optional, tag="2")]
    pub spec: ::core::option::Option<RuntimeClassSpec>,
}
/// 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>,
}
/// RuntimeClassSpec is a specification of a RuntimeClass. It contains parameters
/// that are required to describe the RuntimeClass to the Container Runtime
/// Interface (CRI) implementation, as well as any other components that need to
/// understand how the pod will be run. The RuntimeClassSpec is immutable.
#[derive(Clone, PartialEq, ::prost::Message)]
pub struct RuntimeClassSpec {
    /// runtimeHandler 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 runtimeHandler must be lowercase, conform to the DNS Label (RFC 1123)
    /// requirements, and is immutable.
    #[prost(string, optional, tag="1")]
    pub runtime_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://git.k8s.io/enhancements/keps/sig-node/688-pod-overhead/README.md
    /// +optional
    #[prost(message, optional, tag="2")]
    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="3")]
    pub scheduling: ::core::option::Option<Scheduling>,
}
/// 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>,
}