docker-engine 0.1.1 → 0.2.0

data/rbi/docker_engine/models/connect_request.rbi

@@ -0,0 +1,334 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class ConnectRequest < DockerEngine::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(DockerEngine::ConnectRequest, DockerEngine::Internal::AnyHash)
+        end
+
+      # The ID or name of the container to connect to the network.
+      sig { returns(String) }
+      attr_accessor :container
+
+      # Configuration for a network endpoint.
+      sig { returns(T.nilable(DockerEngine::ConnectRequest::EndpointConfig)) }
+      attr_reader :endpoint_config
+
+      sig do
+        params(
+          endpoint_config: DockerEngine::ConnectRequest::EndpointConfig::OrHash
+        ).void
+      end
+      attr_writer :endpoint_config
+
+      # NetworkConnectRequest represents the data to be used to connect a container to a
+      # network.
+      sig do
+        params(
+          container: String,
+          endpoint_config: DockerEngine::ConnectRequest::EndpointConfig::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # The ID or name of the container to connect to the network.
+        container:,
+        # Configuration for a network endpoint.
+        endpoint_config: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            container: String,
+            endpoint_config: DockerEngine::ConnectRequest::EndpointConfig
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class EndpointConfig < DockerEngine::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngine::ConnectRequest::EndpointConfig,
+              DockerEngine::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :aliases
+
+        sig { params(aliases: T::Array[String]).void }
+        attr_writer :aliases
+
+        # List of all DNS names an endpoint has on a specific network. This list is based
+        # on the container name, network aliases, container short ID, and hostname.
+        #
+        # These DNS names are non-fully qualified but can contain several dots. You can
+        # get fully qualified DNS names by appending `.<network-name>`. For instance, if
+        # container name is `my.ctr` and the network is named `testnet`, `DNSNames` will
+        # contain `my.ctr` and the FQDN will be `my.ctr.testnet`.
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :dns_names
+
+        sig { params(dns_names: T::Array[String]).void }
+        attr_writer :dns_names
+
+        # DriverOpts is a mapping of driver options and values. These options are passed
+        # directly to the driver and are driver specific.
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_accessor :driver_opts
+
+        # Unique ID for the service endpoint in a Sandbox.
+        sig { returns(T.nilable(String)) }
+        attr_reader :endpoint_id
+
+        sig { params(endpoint_id: String).void }
+        attr_writer :endpoint_id
+
+        # Gateway address for this network.
+        sig { returns(T.nilable(String)) }
+        attr_reader :gateway
+
+        sig { params(gateway: String).void }
+        attr_writer :gateway
+
+        # Global IPv6 address.
+        sig { returns(T.nilable(String)) }
+        attr_reader :global_i_pv6_address
+
+        sig { params(global_i_pv6_address: String).void }
+        attr_writer :global_i_pv6_address
+
+        # Mask length of the global IPv6 address.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :global_i_pv6_prefix_len
+
+        sig { params(global_i_pv6_prefix_len: Integer).void }
+        attr_writer :global_i_pv6_prefix_len
+
+        # This property determines which endpoint will provide the default gateway for a
+        # container. The endpoint with the highest priority will be used. If multiple
+        # endpoints have the same priority, endpoints are lexicographically sorted based
+        # on their network name, and the one that sorts first is picked.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :gw_priority
+
+        sig { params(gw_priority: Integer).void }
+        attr_writer :gw_priority
+
+        # IPv4 address.
+        sig { returns(T.nilable(String)) }
+        attr_reader :ip_address
+
+        sig { params(ip_address: String).void }
+        attr_writer :ip_address
+
+        # EndpointIPAMConfig represents an endpoint's IPAM configuration.
+        sig do
+          returns(
+            T.nilable(DockerEngine::ConnectRequest::EndpointConfig::IpamConfig)
+          )
+        end
+        attr_reader :ipam_config
+
+        sig do
+          params(
+            ipam_config:
+              T.nilable(
+                DockerEngine::ConnectRequest::EndpointConfig::IpamConfig::OrHash
+              )
+          ).void
+        end
+        attr_writer :ipam_config
+
+        # Mask length of the IPv4 address.
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :ip_prefix_len
+
+        sig { params(ip_prefix_len: Integer).void }
+        attr_writer :ip_prefix_len
+
+        # IPv6 gateway address.
+        sig { returns(T.nilable(String)) }
+        attr_reader :i_pv6_gateway
+
+        sig { params(i_pv6_gateway: String).void }
+        attr_writer :i_pv6_gateway
+
+        sig { returns(T.nilable(T::Array[String])) }
+        attr_reader :links
+
+        sig { params(links: T::Array[String]).void }
+        attr_writer :links
+
+        # MAC address for the endpoint on this network. The network driver might ignore
+        # this parameter.
+        sig { returns(T.nilable(String)) }
+        attr_reader :mac_address
+
+        sig { params(mac_address: String).void }
+        attr_writer :mac_address
+
+        # Unique ID of the network.
+        sig { returns(T.nilable(String)) }
+        attr_reader :network_id
+
+        sig { params(network_id: String).void }
+        attr_writer :network_id
+
+        # Configuration for a network endpoint.
+        sig do
+          params(
+            aliases: T::Array[String],
+            dns_names: T::Array[String],
+            driver_opts: T.nilable(T::Hash[Symbol, String]),
+            endpoint_id: String,
+            gateway: String,
+            global_i_pv6_address: String,
+            global_i_pv6_prefix_len: Integer,
+            gw_priority: Integer,
+            ip_address: String,
+            ipam_config:
+              T.nilable(
+                DockerEngine::ConnectRequest::EndpointConfig::IpamConfig::OrHash
+              ),
+            ip_prefix_len: Integer,
+            i_pv6_gateway: String,
+            links: T::Array[String],
+            mac_address: String,
+            network_id: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          aliases: nil,
+          # List of all DNS names an endpoint has on a specific network. This list is based
+          # on the container name, network aliases, container short ID, and hostname.
+          #
+          # These DNS names are non-fully qualified but can contain several dots. You can
+          # get fully qualified DNS names by appending `.<network-name>`. For instance, if
+          # container name is `my.ctr` and the network is named `testnet`, `DNSNames` will
+          # contain `my.ctr` and the FQDN will be `my.ctr.testnet`.
+          dns_names: nil,
+          # DriverOpts is a mapping of driver options and values. These options are passed
+          # directly to the driver and are driver specific.
+          driver_opts: nil,
+          # Unique ID for the service endpoint in a Sandbox.
+          endpoint_id: nil,
+          # Gateway address for this network.
+          gateway: nil,
+          # Global IPv6 address.
+          global_i_pv6_address: nil,
+          # Mask length of the global IPv6 address.
+          global_i_pv6_prefix_len: nil,
+          # This property determines which endpoint will provide the default gateway for a
+          # container. The endpoint with the highest priority will be used. If multiple
+          # endpoints have the same priority, endpoints are lexicographically sorted based
+          # on their network name, and the one that sorts first is picked.
+          gw_priority: nil,
+          # IPv4 address.
+          ip_address: nil,
+          # EndpointIPAMConfig represents an endpoint's IPAM configuration.
+          ipam_config: nil,
+          # Mask length of the IPv4 address.
+          ip_prefix_len: nil,
+          # IPv6 gateway address.
+          i_pv6_gateway: nil,
+          links: nil,
+          # MAC address for the endpoint on this network. The network driver might ignore
+          # this parameter.
+          mac_address: nil,
+          # Unique ID of the network.
+          network_id: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              aliases: T::Array[String],
+              dns_names: T::Array[String],
+              driver_opts: T.nilable(T::Hash[Symbol, String]),
+              endpoint_id: String,
+              gateway: String,
+              global_i_pv6_address: String,
+              global_i_pv6_prefix_len: Integer,
+              gw_priority: Integer,
+              ip_address: String,
+              ipam_config:
+                T.nilable(
+                  DockerEngine::ConnectRequest::EndpointConfig::IpamConfig
+                ),
+              ip_prefix_len: Integer,
+              i_pv6_gateway: String,
+              links: T::Array[String],
+              mac_address: String,
+              network_id: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class IpamConfig < DockerEngine::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                DockerEngine::ConnectRequest::EndpointConfig::IpamConfig,
+                DockerEngine::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :i_pv4_address
+
+          sig { params(i_pv4_address: String).void }
+          attr_writer :i_pv4_address
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :i_pv6_address
+
+          sig { params(i_pv6_address: String).void }
+          attr_writer :i_pv6_address
+
+          sig { returns(T.nilable(T::Array[String])) }
+          attr_reader :link_local_ips
+
+          sig { params(link_local_ips: T::Array[String]).void }
+          attr_writer :link_local_ips
+
+          # EndpointIPAMConfig represents an endpoint's IPAM configuration.
+          sig do
+            params(
+              i_pv4_address: String,
+              i_pv6_address: String,
+              link_local_ips: T::Array[String]
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            i_pv4_address: nil,
+            i_pv6_address: nil,
+            link_local_ips: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                i_pv4_address: String,
+                i_pv6_address: String,
+                link_local_ips: T::Array[String]
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/container_archive_params.rbi

@@ -0,0 +1,43 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class ContainerArchiveParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::ContainerArchiveParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      # Resource in the container’s filesystem to archive.
+      sig { returns(String) }
+      attr_accessor :path
+
+      sig do
+        params(
+          path: String,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Resource in the container’s filesystem to archive.
+        path:,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          { path: String, request_options: DockerEngine::RequestOptions }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/container_attach_params.rbi

@@ -0,0 +1,120 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class ContainerAttachParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::ContainerAttachParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      # Override the key sequence for detaching a container.Format is a single character
+      # `[a-Z]` or `ctrl-<value>` where `<value>` is one of: `a-z`, `@`, `^`, `[`, `,`
+      # or `_`.
+      sig { returns(T.nilable(String)) }
+      attr_reader :detach_keys
+
+      sig { params(detach_keys: String).void }
+      attr_writer :detach_keys
+
+      # Replay previous logs from the container.
+      #
+      # This is useful for attaching to a container that has started and you want to
+      # output everything since the container started.
+      #
+      # If `stream` is also enabled, once all the previous output has been returned, it
+      # will seamlessly transition into streaming current output.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :logs
+
+      sig { params(logs: T::Boolean).void }
+      attr_writer :logs
+
+      # Attach to `stderr`
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stderr
+
+      sig { params(stderr: T::Boolean).void }
+      attr_writer :stderr
+
+      # Attach to `stdin`
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stdin
+
+      sig { params(stdin: T::Boolean).void }
+      attr_writer :stdin
+
+      # Attach to `stdout`
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stdout
+
+      sig { params(stdout: T::Boolean).void }
+      attr_writer :stdout
+
+      # Stream attached streams from the time the request was made onwards.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :stream
+
+      sig { params(stream: T::Boolean).void }
+      attr_writer :stream
+
+      sig do
+        params(
+          detach_keys: String,
+          logs: T::Boolean,
+          stderr: T::Boolean,
+          stdin: T::Boolean,
+          stdout: T::Boolean,
+          stream: T::Boolean,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Override the key sequence for detaching a container.Format is a single character
+        # `[a-Z]` or `ctrl-<value>` where `<value>` is one of: `a-z`, `@`, `^`, `[`, `,`
+        # or `_`.
+        detach_keys: nil,
+        # Replay previous logs from the container.
+        #
+        # This is useful for attaching to a container that has started and you want to
+        # output everything since the container started.
+        #
+        # If `stream` is also enabled, once all the previous output has been returned, it
+        # will seamlessly transition into streaming current output.
+        logs: nil,
+        # Attach to `stderr`
+        stderr: nil,
+        # Attach to `stdin`
+        stdin: nil,
+        # Attach to `stdout`
+        stdout: nil,
+        # Stream attached streams from the time the request was made onwards.
+        stream: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            detach_keys: String,
+            logs: T::Boolean,
+            stderr: T::Boolean,
+            stdin: T::Boolean,
+            stdout: T::Boolean,
+            stream: T::Boolean,
+            request_options: DockerEngine::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine/models/container_changes_params.rbi

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

data/rbi/docker_engine/models/container_changes_response.rbi

@@ -0,0 +1,11 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    ContainerChangesResponse =
+      T.let(
+        DockerEngine::Internal::Type::ArrayOf[DockerEngine::FilesystemChange],
+        DockerEngine::Internal::Type::Converter
+      )
+  end
+end

data/rbi/docker_engine/models/container_exec_params.rbi

@@ -0,0 +1,162 @@
+# typed: strong
+
+module DockerEngine
+  module Models
+    class ContainerExecParams < DockerEngine::Internal::Type::BaseModel
+      extend DockerEngine::Internal::Type::RequestParameters::Converter
+      include DockerEngine::Internal::Type::RequestParameters
+
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngine::ContainerExecParams,
+            DockerEngine::Internal::AnyHash
+          )
+        end
+
+      # Attach to `stderr` of the exec command.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :attach_stderr
+
+      sig { params(attach_stderr: T::Boolean).void }
+      attr_writer :attach_stderr
+
+      # Attach to `stdin` of the exec command.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :attach_stdin
+
+      sig { params(attach_stdin: T::Boolean).void }
+      attr_writer :attach_stdin
+
+      # Attach to `stdout` of the exec command.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :attach_stdout
+
+      sig { params(attach_stdout: T::Boolean).void }
+      attr_writer :attach_stdout
+
+      # Command to run, as a string or array of strings.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :cmd
+
+      sig { params(cmd: T::Array[String]).void }
+      attr_writer :cmd
+
+      # Initial console size, as an `[height, width]` array.
+      sig { returns(T.nilable(T::Array[Integer])) }
+      attr_accessor :console_size
+
+      # Override the key sequence for detaching a container. Format is a single
+      # character `[a-Z]` or `ctrl-<value>` where `<value>` is one of: `a-z`, `@`, `^`,
+      # `[`, `,` or `_`.
+      sig { returns(T.nilable(String)) }
+      attr_reader :detach_keys
+
+      sig { params(detach_keys: String).void }
+      attr_writer :detach_keys
+
+      # A list of environment variables in the form `["VAR=value", ...]`.
+      sig { returns(T.nilable(T::Array[String])) }
+      attr_reader :env
+
+      sig { params(env: T::Array[String]).void }
+      attr_writer :env
+
+      # Runs the exec process with extended privileges.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :privileged
+
+      sig { params(privileged: T::Boolean).void }
+      attr_writer :privileged
+
+      # Allocate a pseudo-TTY.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :tty
+
+      sig { params(tty: T::Boolean).void }
+      attr_writer :tty
+
+      # The user, and optionally, group to run the exec process inside the container.
+      # Format is one of: `user`, `user:group`, `uid`, or `uid:gid`.
+      sig { returns(T.nilable(String)) }
+      attr_reader :user
+
+      sig { params(user: String).void }
+      attr_writer :user
+
+      # The working directory for the exec process inside the container.
+      sig { returns(T.nilable(String)) }
+      attr_reader :working_dir
+
+      sig { params(working_dir: String).void }
+      attr_writer :working_dir
+
+      sig do
+        params(
+          attach_stderr: T::Boolean,
+          attach_stdin: T::Boolean,
+          attach_stdout: T::Boolean,
+          cmd: T::Array[String],
+          console_size: T.nilable(T::Array[Integer]),
+          detach_keys: String,
+          env: T::Array[String],
+          privileged: T::Boolean,
+          tty: T::Boolean,
+          user: String,
+          working_dir: String,
+          request_options: DockerEngine::RequestOptions::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Attach to `stderr` of the exec command.
+        attach_stderr: nil,
+        # Attach to `stdin` of the exec command.
+        attach_stdin: nil,
+        # Attach to `stdout` of the exec command.
+        attach_stdout: nil,
+        # Command to run, as a string or array of strings.
+        cmd: nil,
+        # Initial console size, as an `[height, width]` array.
+        console_size: nil,
+        # Override the key sequence for detaching a container. Format is a single
+        # character `[a-Z]` or `ctrl-<value>` where `<value>` is one of: `a-z`, `@`, `^`,
+        # `[`, `,` or `_`.
+        detach_keys: nil,
+        # A list of environment variables in the form `["VAR=value", ...]`.
+        env: nil,
+        # Runs the exec process with extended privileges.
+        privileged: nil,
+        # Allocate a pseudo-TTY.
+        tty: nil,
+        # The user, and optionally, group to run the exec process inside the container.
+        # Format is one of: `user`, `user:group`, `uid`, or `uid:gid`.
+        user: nil,
+        # The working directory for the exec process inside the container.
+        working_dir: nil,
+        request_options: {}
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            attach_stderr: T::Boolean,
+            attach_stdin: T::Boolean,
+            attach_stdout: T::Boolean,
+            cmd: T::Array[String],
+            console_size: T.nilable(T::Array[Integer]),
+            detach_keys: String,
+            env: T::Array[String],
+            privileged: T::Boolean,
+            tty: T::Boolean,
+            user: String,
+            working_dir: String,
+            request_options: DockerEngine::RequestOptions
+          }
+        )
+      end
+      def to_hash
+      end
+    end
+  end
+end