docker-engine-api 0.2.1

data/rbi/docker_engine_api/models/swarm.rbi

@@ -0,0 +1,315 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class SwarmAPI < DockerEngineAPI::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(DockerEngineAPI::SwarmAPI, DockerEngineAPI::Internal::AnyHash)
+        end
+
+      # Date and time at which the swarm was initialised in
+      # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds.
+      sig { returns(T.nilable(String)) }
+      attr_reader :created_at
+
+      sig { params(created_at: String).void }
+      attr_writer :created_at
+
+      # DataPathPort specifies the data path port number for data traffic. Acceptable
+      # port range is 1024 to 49151. If no port is set or is set to 0, the default port
+      # (4789) is used.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :data_path_port
+
+      sig { params(data_path_port: Integer).void }
+      attr_writer :data_path_port
+
+      # Default Address Pool specifies default subnet pools for global scope networks.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :default_addr_pool
+
+      sig { params(default_addr_pool: T::Array[String]).void }
+      attr_writer :default_addr_pool
+
+      # The ID of the swarm.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # JoinTokens contains the tokens workers and managers need to join the swarm.
+      sig { returns(T.nilable(DockerEngineAPI::SwarmAPI::JoinTokens)) }
+      attr_reader :join_tokens
+
+      sig do
+        params(join_tokens: DockerEngineAPI::SwarmAPI::JoinTokens::OrHash).void
+      end
+      attr_writer :join_tokens
+
+      # Whether there is currently a root CA rotation in progress for the swarm
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :root_rotation_in_progress
+
+      sig { params(root_rotation_in_progress: T::Boolean).void }
+      attr_writer :root_rotation_in_progress
+
+      # User modifiable swarm configuration.
+      sig { returns(T.nilable(DockerEngineAPI::Spec)) }
+      attr_reader :spec
+
+      sig { params(spec: DockerEngineAPI::Spec::OrHash).void }
+      attr_writer :spec
+
+      # SubnetSize specifies the subnet size of the networks created from the default
+      # subnet pool.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :subnet_size
+
+      sig { params(subnet_size: Integer).void }
+      attr_writer :subnet_size
+
+      # Information about the issuer of leaf TLS certificates and the trusted root CA
+      # certificate.
+      sig { returns(T.nilable(DockerEngineAPI::SwarmAPI::TlsInfo)) }
+      attr_reader :tls_info
+
+      sig { params(tls_info: DockerEngineAPI::SwarmAPI::TlsInfo::OrHash).void }
+      attr_writer :tls_info
+
+      # Date and time at which the swarm was last updated in
+      # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds.
+      sig { returns(T.nilable(String)) }
+      attr_reader :updated_at
+
+      sig { params(updated_at: String).void }
+      attr_writer :updated_at
+
+      # The version number of the object such as node, service, etc. This is needed to
+      # avoid conflicting writes. The client must send the version number along with the
+      # modified specification when updating these objects.
+      #
+      # This approach ensures safe concurrency and determinism in that the change on the
+      # object may not be applied if the version number has changed from the last read.
+      # In other words, if two update requests specify the same base version, only one
+      # of the requests can succeed. As a result, two separate update requests that
+      # happen at the same time will not unintentionally overwrite each other.
+      sig { returns(T.nilable(DockerEngineAPI::SwarmAPI::Version)) }
+      attr_reader :version
+
+      sig { params(version: DockerEngineAPI::SwarmAPI::Version::OrHash).void }
+      attr_writer :version
+
+      sig do
+        params(
+          created_at: String,
+          data_path_port: Integer,
+          default_addr_pool: T::Array[String],
+          id: String,
+          join_tokens: DockerEngineAPI::SwarmAPI::JoinTokens::OrHash,
+          root_rotation_in_progress: T::Boolean,
+          spec: DockerEngineAPI::Spec::OrHash,
+          subnet_size: Integer,
+          tls_info: DockerEngineAPI::SwarmAPI::TlsInfo::OrHash,
+          updated_at: String,
+          version: DockerEngineAPI::SwarmAPI::Version::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Date and time at which the swarm was initialised in
+        # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds.
+        created_at: nil,
+        # DataPathPort specifies the data path port number for data traffic. Acceptable
+        # port range is 1024 to 49151. If no port is set or is set to 0, the default port
+        # (4789) is used.
+        data_path_port: nil,
+        # Default Address Pool specifies default subnet pools for global scope networks.
+        default_addr_pool: nil,
+        # The ID of the swarm.
+        id: nil,
+        # JoinTokens contains the tokens workers and managers need to join the swarm.
+        join_tokens: nil,
+        # Whether there is currently a root CA rotation in progress for the swarm
+        root_rotation_in_progress: nil,
+        # User modifiable swarm configuration.
+        spec: nil,
+        # SubnetSize specifies the subnet size of the networks created from the default
+        # subnet pool.
+        subnet_size: nil,
+        # Information about the issuer of leaf TLS certificates and the trusted root CA
+        # certificate.
+        tls_info: nil,
+        # Date and time at which the swarm was last updated in
+        # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds.
+        updated_at: nil,
+        # The version number of the object such as node, service, etc. This is needed to
+        # avoid conflicting writes. The client must send the version number along with the
+        # modified specification when updating these objects.
+        #
+        # This approach ensures safe concurrency and determinism in that the change on the
+        # object may not be applied if the version number has changed from the last read.
+        # In other words, if two update requests specify the same base version, only one
+        # of the requests can succeed. As a result, two separate update requests that
+        # happen at the same time will not unintentionally overwrite each other.
+        version: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            created_at: String,
+            data_path_port: Integer,
+            default_addr_pool: T::Array[String],
+            id: String,
+            join_tokens: DockerEngineAPI::SwarmAPI::JoinTokens,
+            root_rotation_in_progress: T::Boolean,
+            spec: DockerEngineAPI::Spec,
+            subnet_size: Integer,
+            tls_info: DockerEngineAPI::SwarmAPI::TlsInfo,
+            updated_at: String,
+            version: DockerEngineAPI::SwarmAPI::Version
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class JoinTokens < DockerEngineAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineAPI::SwarmAPI::JoinTokens,
+              DockerEngineAPI::Internal::AnyHash
+            )
+          end
+
+        # The token managers can use to join the swarm.
+        sig { returns(T.nilable(String)) }
+        attr_reader :manager
+
+        sig { params(manager: String).void }
+        attr_writer :manager
+
+        # The token workers can use to join the swarm.
+        sig { returns(T.nilable(String)) }
+        attr_reader :worker
+
+        sig { params(worker: String).void }
+        attr_writer :worker
+
+        # JoinTokens contains the tokens workers and managers need to join the swarm.
+        sig do
+          params(manager: String, worker: String).returns(T.attached_class)
+        end
+        def self.new(
+          # The token managers can use to join the swarm.
+          manager: nil,
+          # The token workers can use to join the swarm.
+          worker: nil
+        )
+        end
+
+        sig { override.returns({ manager: String, worker: String }) }
+        def to_hash
+        end
+      end
+
+      class TlsInfo < DockerEngineAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineAPI::SwarmAPI::TlsInfo,
+              DockerEngineAPI::Internal::AnyHash
+            )
+          end
+
+        # The base64-url-safe-encoded raw public key bytes of the issuer.
+        sig { returns(T.nilable(String)) }
+        attr_reader :cert_issuer_public_key
+
+        sig { params(cert_issuer_public_key: String).void }
+        attr_writer :cert_issuer_public_key
+
+        # The base64-url-safe-encoded raw subject bytes of the issuer.
+        sig { returns(T.nilable(String)) }
+        attr_reader :cert_issuer_subject
+
+        sig { params(cert_issuer_subject: String).void }
+        attr_writer :cert_issuer_subject
+
+        # The root CA certificate(s) that are used to validate leaf TLS certificates.
+        sig { returns(T.nilable(String)) }
+        attr_reader :trust_root
+
+        sig { params(trust_root: String).void }
+        attr_writer :trust_root
+
+        # Information about the issuer of leaf TLS certificates and the trusted root CA
+        # certificate.
+        sig do
+          params(
+            cert_issuer_public_key: String,
+            cert_issuer_subject: String,
+            trust_root: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # The base64-url-safe-encoded raw public key bytes of the issuer.
+          cert_issuer_public_key: nil,
+          # The base64-url-safe-encoded raw subject bytes of the issuer.
+          cert_issuer_subject: nil,
+          # The root CA certificate(s) that are used to validate leaf TLS certificates.
+          trust_root: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              cert_issuer_public_key: String,
+              cert_issuer_subject: String,
+              trust_root: String
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class Version < DockerEngineAPI::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineAPI::SwarmAPI::Version,
+              DockerEngineAPI::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :index
+
+        sig { params(index: Integer).void }
+        attr_writer :index
+
+        # The version number of the object such as node, service, etc. This is needed to
+        # avoid conflicting writes. The client must send the version number along with the
+        # modified specification when updating these objects.
+        #
+        # This approach ensures safe concurrency and determinism in that the change on the
+        # object may not be applied if the version number has changed from the last read.
+        # In other words, if two update requests specify the same base version, only one
+        # of the requests can succeed. As a result, two separate update requests that
+        # happen at the same time will not unintentionally overwrite each other.
+        sig { params(index: Integer).returns(T.attached_class) }
+        def self.new(index: nil)
+        end
+
+        sig { override.returns({ index: Integer }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/swarm_init_params.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class SwarmInitParams < DockerEngineAPI::Internal::Type::BaseModel
+      extend DockerEngineAPI::Internal::Type::RequestParameters::Converter
+      include DockerEngineAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::SwarmInitParams,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      # Externally reachable address advertised to other nodes. This can either be an
+      # address/port combination in the form `192.168.1.1:4567`, or an interface
+      # followed by a port number, like `eth0:4567`. If the port number is omitted, the
+      # port number from the listen address is used. If `AdvertiseAddr` is not
+      # specified, it will be automatically detected when possible.
+      sig { returns(T.nilable(String)) }
+      attr_reader :advertise_addr
+
+      sig { params(advertise_addr: String).void }
+      attr_writer :advertise_addr
+
+      # Address or interface to use for data path traffic (format: `<ip|interface>`),
+      # for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is
+      # unspecified, the same address as `AdvertiseAddr` is used.
+      #
+      # The `DataPathAddr` specifies the address that global scope network drivers will
+      # publish towards other nodes in order to reach the containers running on this
+      # node. Using this parameter it is possible to separate the container data traffic
+      # from the management traffic of the cluster.
+      sig { returns(T.nilable(String)) }
+      attr_reader :data_path_addr
+
+      sig { params(data_path_addr: String).void }
+      attr_writer :data_path_addr
+
+      # DataPathPort specifies the data path port number for data traffic. Acceptable
+      # port range is 1024 to 49151. if no port is set or is set to 0, default port 4789
+      # will be used.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :data_path_port
+
+      sig { params(data_path_port: Integer).void }
+      attr_writer :data_path_port
+
+      # Default Address Pool specifies default subnet pools for global scope networks.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :default_addr_pool
+
+      sig { params(default_addr_pool: T::Array[String]).void }
+      attr_writer :default_addr_pool
+
+      # Force creation of a new swarm.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :force_new_cluster
+
+      sig { params(force_new_cluster: T::Boolean).void }
+      attr_writer :force_new_cluster
+
+      # Listen address used for inter-manager communication, as well as determining the
+      # networking interface used for the VXLAN Tunnel Endpoint (VTEP). This can either
+      # be an address/port combination in the form `192.168.1.1:4567`, or an interface
+      # followed by a port number, like `eth0:4567`. If the port number is omitted, the
+      # default swarm listening port is used.
+      sig { returns(T.nilable(String)) }
+      attr_reader :listen_addr
+
+      sig { params(listen_addr: String).void }
+      attr_writer :listen_addr
+
+      # User modifiable swarm configuration.
+      sig { returns(T.nilable(DockerEngineAPI::Spec)) }
+      attr_reader :spec
+
+      sig { params(spec: DockerEngineAPI::Spec::OrHash).void }
+      attr_writer :spec
+
+      # SubnetSize specifies the subnet size of the networks created from the default
+      # subnet pool.
+      sig { returns(T.nilable(Integer)) }
+      attr_reader :subnet_size
+
+      sig { params(subnet_size: Integer).void }
+      attr_writer :subnet_size
+
+      sig do
+        params(
+          advertise_addr: String,
+          data_path_addr: String,
+          data_path_port: Integer,
+          default_addr_pool: T::Array[String],
+          force_new_cluster: T::Boolean,
+          listen_addr: String,
+          spec: DockerEngineAPI::Spec::OrHash,
+          subnet_size: Integer,
+          request_options: DockerEngineAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Externally reachable address advertised to other nodes. This can either be an
+        # address/port combination in the form `192.168.1.1:4567`, or an interface
+        # followed by a port number, like `eth0:4567`. If the port number is omitted, the
+        # port number from the listen address is used. If `AdvertiseAddr` is not
+        # specified, it will be automatically detected when possible.
+        advertise_addr: nil,
+        # Address or interface to use for data path traffic (format: `<ip|interface>`),
+        # for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is
+        # unspecified, the same address as `AdvertiseAddr` is used.
+        #
+        # The `DataPathAddr` specifies the address that global scope network drivers will
+        # publish towards other nodes in order to reach the containers running on this
+        # node. Using this parameter it is possible to separate the container data traffic
+        # from the management traffic of the cluster.
+        data_path_addr: nil,
+        # DataPathPort specifies the data path port number for data traffic. Acceptable
+        # port range is 1024 to 49151. if no port is set or is set to 0, default port 4789
+        # will be used.
+        data_path_port: nil,
+        # Default Address Pool specifies default subnet pools for global scope networks.
+        default_addr_pool: nil,
+        # Force creation of a new swarm.
+        force_new_cluster: nil,
+        # Listen address used for inter-manager communication, as well as determining the
+        # networking interface used for the VXLAN Tunnel Endpoint (VTEP). This can either
+        # be an address/port combination in the form `192.168.1.1:4567`, or an interface
+        # followed by a port number, like `eth0:4567`. If the port number is omitted, the
+        # default swarm listening port is used.
+        listen_addr: nil,
+        # User modifiable swarm configuration.
+        spec: nil,
+        # SubnetSize specifies the subnet size of the networks created from the default
+        # subnet pool.
+        subnet_size: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            advertise_addr: String,
+            data_path_addr: String,
+            data_path_port: Integer,
+            default_addr_pool: T::Array[String],
+            force_new_cluster: T::Boolean,
+            listen_addr: String,
+            spec: DockerEngineAPI::Spec,
+            subnet_size: Integer,
+            request_options: DockerEngineAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/swarm_init_response.rbi

@@ -0,0 +1,7 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    SwarmInitResponse = String
+  end
+end

data/rbi/docker_engine_api/models/swarm_inspect_params.rbi

@@ -0,0 +1,32 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class SwarmInspectParams < DockerEngineAPI::Internal::Type::BaseModel
+      extend DockerEngineAPI::Internal::Type::RequestParameters::Converter
+      include DockerEngineAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::SwarmInspectParams,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      sig do
+        params(
+          request_options: DockerEngineAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(request_options: {})
+      end
+
+      sig do
+        override.returns({ request_options: DockerEngineAPI::RequestOptions })
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/swarm_join_params.rbi

@@ -0,0 +1,119 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class SwarmJoinParams < DockerEngineAPI::Internal::Type::BaseModel
+      extend DockerEngineAPI::Internal::Type::RequestParameters::Converter
+      include DockerEngineAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::SwarmJoinParams,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      # Externally reachable address advertised to other nodes. This can either be an
+      # address/port combination in the form `192.168.1.1:4567`, or an interface
+      # followed by a port number, like `eth0:4567`. If the port number is omitted, the
+      # port number from the listen address is used. If `AdvertiseAddr` is not
+      # specified, it will be automatically detected when possible.
+      sig { returns(T.nilable(String)) }
+      attr_reader :advertise_addr
+
+      sig { params(advertise_addr: String).void }
+      attr_writer :advertise_addr
+
+      # Address or interface to use for data path traffic (format: `<ip|interface>`),
+      # for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is
+      # unspecified, the same address as `AdvertiseAddr` is used.
+      #
+      # The `DataPathAddr` specifies the address that global scope network drivers will
+      # publish towards other nodes in order to reach the containers running on this
+      # node. Using this parameter it is possible to separate the container data traffic
+      # from the management traffic of the cluster.
+      sig { returns(T.nilable(String)) }
+      attr_reader :data_path_addr
+
+      sig { params(data_path_addr: String).void }
+      attr_writer :data_path_addr
+
+      # Secret token for joining this swarm.
+      sig { returns(T.nilable(String)) }
+      attr_reader :join_token
+
+      sig { params(join_token: String).void }
+      attr_writer :join_token
+
+      # Listen address used for inter-manager communication if the node gets promoted to
+      # manager, as well as determining the networking interface used for the VXLAN
+      # Tunnel Endpoint (VTEP).
+      sig { returns(T.nilable(String)) }
+      attr_reader :listen_addr
+
+      sig { params(listen_addr: String).void }
+      attr_writer :listen_addr
+
+      # Addresses of manager nodes already participating in the swarm.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :remote_addrs
+
+      sig { params(remote_addrs: T::Array[String]).void }
+      attr_writer :remote_addrs
+
+      sig do
+        params(
+          advertise_addr: String,
+          data_path_addr: String,
+          join_token: String,
+          listen_addr: String,
+          remote_addrs: T::Array[String],
+          request_options: DockerEngineAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Externally reachable address advertised to other nodes. This can either be an
+        # address/port combination in the form `192.168.1.1:4567`, or an interface
+        # followed by a port number, like `eth0:4567`. If the port number is omitted, the
+        # port number from the listen address is used. If `AdvertiseAddr` is not
+        # specified, it will be automatically detected when possible.
+        advertise_addr: nil,
+        # Address or interface to use for data path traffic (format: `<ip|interface>`),
+        # for example, `192.168.1.1`, or an interface, like `eth0`. If `DataPathAddr` is
+        # unspecified, the same address as `AdvertiseAddr` is used.
+        #
+        # The `DataPathAddr` specifies the address that global scope network drivers will
+        # publish towards other nodes in order to reach the containers running on this
+        # node. Using this parameter it is possible to separate the container data traffic
+        # from the management traffic of the cluster.
+        data_path_addr: nil,
+        # Secret token for joining this swarm.
+        join_token: nil,
+        # Listen address used for inter-manager communication if the node gets promoted to
+        # manager, as well as determining the networking interface used for the VXLAN
+        # Tunnel Endpoint (VTEP).
+        listen_addr: nil,
+        # Addresses of manager nodes already participating in the swarm.
+        remote_addrs: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            advertise_addr: String,
+            data_path_addr: String,
+            join_token: String,
+            listen_addr: String,
+            remote_addrs: T::Array[String],
+            request_options: DockerEngineAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_api/models/swarm_leave_params.rbi

@@ -0,0 +1,51 @@
+# typed: strong
+
+module DockerEngineAPI
+  module Models
+    class SwarmLeaveParams < DockerEngineAPI::Internal::Type::BaseModel
+      extend DockerEngineAPI::Internal::Type::RequestParameters::Converter
+      include DockerEngineAPI::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineAPI::SwarmLeaveParams,
+            DockerEngineAPI::Internal::AnyHash
+          )
+        end
+
+      # Force leave swarm, even if this is the last manager or that it will break the
+      # cluster.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :force
+
+      sig { params(force: T::Boolean).void }
+      attr_writer :force
+
+      sig do
+        params(
+          force: T::Boolean,
+          request_options: DockerEngineAPI::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Force leave swarm, even if this is the last manager or that it will break the
+        # cluster.
+        force: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            force: T::Boolean,
+            request_options: DockerEngineAPI::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end