docker-engine-ruby 0.3.0 → 0.4.0

data/rbi/docker_engine_ruby/models/info.rbi

@@ -2204,10 +2204,10 @@ module DockerEngineRuby
           attr_writer :root_rotation_in_progress
 
           # User modifiable swarm configuration.
-          sig { returns(T.nilable(DockerEngineRuby::Spec)) }
+          sig { returns(T.nilable(DockerEngineRuby::SwarmSpec)) }
           attr_reader :spec
 
-          sig { params(spec: DockerEngineRuby::Spec::OrHash).void }
+          sig { params(spec: DockerEngineRuby::SwarmSpec::OrHash).void }
           attr_writer :spec
 
           # SubnetSize specifies the subnet size of the networks created from the default
@@ -2270,7 +2270,7 @@ module DockerEngineRuby
               default_addr_pool: T::Array[String],
               id: String,
               root_rotation_in_progress: T::Boolean,
-              spec: DockerEngineRuby::Spec::OrHash,
+              spec: DockerEngineRuby::SwarmSpec::OrHash,
               subnet_size: Integer,
               tls_info: DockerEngineRuby::Info::Swarm::Cluster::TlsInfo::OrHash,
               updated_at: Time,
@@ -2323,7 +2323,7 @@ module DockerEngineRuby
                 default_addr_pool: T::Array[String],
                 id: String,
                 root_rotation_in_progress: T::Boolean,
-                spec: DockerEngineRuby::Spec,
+                spec: DockerEngineRuby::SwarmSpec,
                 subnet_size: Integer,
                 tls_info: DockerEngineRuby::Info::Swarm::Cluster::TlsInfo,
                 updated_at: Time,

data/rbi/docker_engine_ruby/models/network_create_response.rbi

@@ -0,0 +1,37 @@
+# typed: strong
+
+module DockerEngineRuby
+  module Models
+    class NetworkCreateResponse < DockerEngineRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineRuby::NetworkCreateResponse,
+            DockerEngineRuby::Internal::AnyHash
+          )
+        end
+
+      # The ID of the created network.
+      sig { returns(String) }
+      attr_accessor :id
+
+      # Warnings encountered when creating the container
+      sig { returns(String) }
+      attr_accessor :warning
+
+      # OK response to NetworkCreate operation
+      sig { params(id: String, warning: String).returns(T.attached_class) }
+      def self.new(
+        # The ID of the created network.
+        id:,
+        # Warnings encountered when creating the container
+        warning:
+      )
+      end
+
+      sig { override.returns({ id: String, warning: String }) }
+      def to_hash
+      end
+    end
+  end
+end

data/rbi/docker_engine_ruby/models/network_list_response.rbi

@@ -4,7 +4,9 @@ module DockerEngineRuby
   module Models
     NetworkListResponse =
       T.let(
-        DockerEngineRuby::Internal::Type::ArrayOf[DockerEngineRuby::Summary],
+        DockerEngineRuby::Internal::Type::ArrayOf[
+          DockerEngineRuby::NetworkSummary
+        ],
         DockerEngineRuby::Internal::Type::Converter
       )
   end

data/rbi/docker_engine_ruby/models/network_summary.rbi

@@ -0,0 +1,444 @@
+# typed: strong
+
+module DockerEngineRuby
+  module Models
+    class NetworkSummary < DockerEngineRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineRuby::NetworkSummary,
+            DockerEngineRuby::Internal::AnyHash
+          )
+        end
+
+      # Whether a global / swarm scope network is manually attachable by regular
+      # containers from workers in swarm mode.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :attachable
+
+      sig { params(attachable: T::Boolean).void }
+      attr_writer :attachable
+
+      # The config-only network source to provide the configuration for this network.
+      sig { returns(T.nilable(DockerEngineRuby::NetworkSummary::ConfigFrom)) }
+      attr_reader :config_from
+
+      sig do
+        params(
+          config_from: DockerEngineRuby::NetworkSummary::ConfigFrom::OrHash
+        ).void
+      end
+      attr_writer :config_from
+
+      # Whether the network is a config-only network. Config-only networks are
+      # placeholder networks for network configurations to be used by other networks.
+      # Config-only networks cannot be used directly to run containers or services.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :config_only
+
+      sig { params(config_only: T::Boolean).void }
+      attr_writer :config_only
+
+      # Date and time at which the network was created in
+      # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds.
+      sig { returns(T.nilable(Time)) }
+      attr_reader :created
+
+      sig { params(created: Time).void }
+      attr_writer :created
+
+      # The name of the driver used to create the network (e.g. `bridge`, `overlay`).
+      sig { returns(T.nilable(String)) }
+      attr_reader :driver
+
+      sig { params(driver: String).void }
+      attr_writer :driver
+
+      # Whether the network was created with IPv4 enabled.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :enable_i_pv4
+
+      sig { params(enable_i_pv4: T::Boolean).void }
+      attr_writer :enable_i_pv4
+
+      # Whether the network was created with IPv6 enabled.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :enable_i_pv6
+
+      sig { params(enable_i_pv6: T::Boolean).void }
+      attr_writer :enable_i_pv6
+
+      # ID that uniquely identifies a network on a single machine.
+      sig { returns(T.nilable(String)) }
+      attr_reader :id
+
+      sig { params(id: String).void }
+      attr_writer :id
+
+      # Whether the network is providing the routing-mesh for the swarm cluster.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :ingress
+
+      sig { params(ingress: T::Boolean).void }
+      attr_writer :ingress
+
+      # Whether the network is created to only allow internal networking connectivity.
+      sig { returns(T.nilable(T::Boolean)) }
+      attr_reader :internal
+
+      sig { params(internal: T::Boolean).void }
+      attr_writer :internal
+
+      # The network's IP Address Management.
+      sig { returns(T.nilable(DockerEngineRuby::NetworkSummary::Ipam)) }
+      attr_reader :ipam
+
+      sig { params(ipam: DockerEngineRuby::NetworkSummary::Ipam::OrHash).void }
+      attr_writer :ipam
+
+      # Metadata specific to the network being created.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :labels
+
+      sig { params(labels: T::Hash[Symbol, String]).void }
+      attr_writer :labels
+
+      # Name of the network.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # Network-specific options uses when creating the network.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :options
+
+      sig { params(options: T::Hash[Symbol, String]).void }
+      attr_writer :options
+
+      # List of peer nodes for an overlay network. This field is only present for
+      # overlay networks, and omitted for other network types.
+      sig do
+        returns(T.nilable(T::Array[DockerEngineRuby::NetworkSummary::Peer]))
+      end
+      attr_reader :peers
+
+      sig do
+        params(
+          peers: T::Array[DockerEngineRuby::NetworkSummary::Peer::OrHash]
+        ).void
+      end
+      attr_writer :peers
+
+      # The level at which the network exists (e.g. `swarm` for cluster-wide or `local`
+      # for machine level)
+      sig { returns(T.nilable(String)) }
+      attr_reader :scope
+
+      sig { params(scope: String).void }
+      attr_writer :scope
+
+      # Network list response item
+      sig do
+        params(
+          attachable: T::Boolean,
+          config_from: DockerEngineRuby::NetworkSummary::ConfigFrom::OrHash,
+          config_only: T::Boolean,
+          created: Time,
+          driver: String,
+          enable_i_pv4: T::Boolean,
+          enable_i_pv6: T::Boolean,
+          id: String,
+          ingress: T::Boolean,
+          internal: T::Boolean,
+          ipam: DockerEngineRuby::NetworkSummary::Ipam::OrHash,
+          labels: T::Hash[Symbol, String],
+          name: String,
+          options: T::Hash[Symbol, String],
+          peers: T::Array[DockerEngineRuby::NetworkSummary::Peer::OrHash],
+          scope: String
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Whether a global / swarm scope network is manually attachable by regular
+        # containers from workers in swarm mode.
+        attachable: nil,
+        # The config-only network source to provide the configuration for this network.
+        config_from: nil,
+        # Whether the network is a config-only network. Config-only networks are
+        # placeholder networks for network configurations to be used by other networks.
+        # Config-only networks cannot be used directly to run containers or services.
+        config_only: nil,
+        # Date and time at which the network was created in
+        # [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format with nano-seconds.
+        created: nil,
+        # The name of the driver used to create the network (e.g. `bridge`, `overlay`).
+        driver: nil,
+        # Whether the network was created with IPv4 enabled.
+        enable_i_pv4: nil,
+        # Whether the network was created with IPv6 enabled.
+        enable_i_pv6: nil,
+        # ID that uniquely identifies a network on a single machine.
+        id: nil,
+        # Whether the network is providing the routing-mesh for the swarm cluster.
+        ingress: nil,
+        # Whether the network is created to only allow internal networking connectivity.
+        internal: nil,
+        # The network's IP Address Management.
+        ipam: nil,
+        # Metadata specific to the network being created.
+        labels: nil,
+        # Name of the network.
+        name: nil,
+        # Network-specific options uses when creating the network.
+        options: nil,
+        # List of peer nodes for an overlay network. This field is only present for
+        # overlay networks, and omitted for other network types.
+        peers: nil,
+        # The level at which the network exists (e.g. `swarm` for cluster-wide or `local`
+        # for machine level)
+        scope: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            attachable: T::Boolean,
+            config_from: DockerEngineRuby::NetworkSummary::ConfigFrom,
+            config_only: T::Boolean,
+            created: Time,
+            driver: String,
+            enable_i_pv4: T::Boolean,
+            enable_i_pv6: T::Boolean,
+            id: String,
+            ingress: T::Boolean,
+            internal: T::Boolean,
+            ipam: DockerEngineRuby::NetworkSummary::Ipam,
+            labels: T::Hash[Symbol, String],
+            name: String,
+            options: T::Hash[Symbol, String],
+            peers: T::Array[DockerEngineRuby::NetworkSummary::Peer],
+            scope: String
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class ConfigFrom < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::NetworkSummary::ConfigFrom,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        # The name of the config-only network that provides the network's configuration.
+        # The specified network must be an existing config-only network. Only network
+        # names are allowed, not network IDs.
+        sig { returns(T.nilable(String)) }
+        attr_reader :network
+
+        sig { params(network: String).void }
+        attr_writer :network
+
+        # The config-only network source to provide the configuration for this network.
+        sig { params(network: String).returns(T.attached_class) }
+        def self.new(
+          # The name of the config-only network that provides the network's configuration.
+          # The specified network must be an existing config-only network. Only network
+          # names are allowed, not network IDs.
+          network: nil
+        )
+        end
+
+        sig { override.returns({ network: String }) }
+        def to_hash
+        end
+      end
+
+      class Ipam < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::NetworkSummary::Ipam,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        # List of IPAM configuration options, specified as a map:
+        #
+        # ```
+        # {"Subnet": <CIDR>, "IPRange": <CIDR>, "Gateway": <IP address>, "AuxAddress": <device_name:IP address>}
+        # ```
+        sig do
+          returns(
+            T.nilable(T::Array[DockerEngineRuby::NetworkSummary::Ipam::Config])
+          )
+        end
+        attr_reader :config
+
+        sig do
+          params(
+            config:
+              T::Array[DockerEngineRuby::NetworkSummary::Ipam::Config::OrHash]
+          ).void
+        end
+        attr_writer :config
+
+        # Name of the IPAM driver to use.
+        sig { returns(T.nilable(String)) }
+        attr_reader :driver
+
+        sig { params(driver: String).void }
+        attr_writer :driver
+
+        # Driver-specific options, specified as a map.
+        sig { returns(T.nilable(T::Hash[Symbol, String])) }
+        attr_reader :options
+
+        sig { params(options: T::Hash[Symbol, String]).void }
+        attr_writer :options
+
+        # The network's IP Address Management.
+        sig do
+          params(
+            config:
+              T::Array[DockerEngineRuby::NetworkSummary::Ipam::Config::OrHash],
+            driver: String,
+            options: T::Hash[Symbol, String]
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          # List of IPAM configuration options, specified as a map:
+          #
+          # ```
+          # {"Subnet": <CIDR>, "IPRange": <CIDR>, "Gateway": <IP address>, "AuxAddress": <device_name:IP address>}
+          # ```
+          config: nil,
+          # Name of the IPAM driver to use.
+          driver: nil,
+          # Driver-specific options, specified as a map.
+          options: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              config: T::Array[DockerEngineRuby::NetworkSummary::Ipam::Config],
+              driver: String,
+              options: T::Hash[Symbol, String]
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class Config < DockerEngineRuby::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                DockerEngineRuby::NetworkSummary::Ipam::Config,
+                DockerEngineRuby::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_reader :auxiliary_addresses
+
+          sig { params(auxiliary_addresses: T::Hash[Symbol, String]).void }
+          attr_writer :auxiliary_addresses
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :gateway
+
+          sig { params(gateway: String).void }
+          attr_writer :gateway
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :ip_range
+
+          sig { params(ip_range: String).void }
+          attr_writer :ip_range
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :subnet
+
+          sig { params(subnet: String).void }
+          attr_writer :subnet
+
+          sig do
+            params(
+              auxiliary_addresses: T::Hash[Symbol, String],
+              gateway: String,
+              ip_range: String,
+              subnet: String
+            ).returns(T.attached_class)
+          end
+          def self.new(
+            auxiliary_addresses: nil,
+            gateway: nil,
+            ip_range: nil,
+            subnet: nil
+          )
+          end
+
+          sig do
+            override.returns(
+              {
+                auxiliary_addresses: T::Hash[Symbol, String],
+                gateway: String,
+                ip_range: String,
+                subnet: String
+              }
+            )
+          end
+          def to_hash
+          end
+        end
+      end
+
+      class Peer < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::NetworkSummary::Peer,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        # IP-address of the peer-node in the Swarm cluster.
+        sig { returns(T.nilable(String)) }
+        attr_reader :ip
+
+        sig { params(ip: String).void }
+        attr_writer :ip
+
+        # ID of the peer-node in the Swarm cluster.
+        sig { returns(T.nilable(String)) }
+        attr_reader :name
+
+        sig { params(name: String).void }
+        attr_writer :name
+
+        # represents one peer of an overlay network.
+        sig { params(ip: String, name: String).returns(T.attached_class) }
+        def self.new(
+          # IP-address of the peer-node in the Swarm cluster.
+          ip: nil,
+          # ID of the peer-node in the Swarm cluster.
+          name: nil
+        )
+        end
+
+        sig { override.returns({ ip: String, name: String }) }
+        def to_hash
+        end
+      end
+    end
+  end
+end

data/rbi/docker_engine_ruby/models/node.rbi

@@ -46,10 +46,10 @@ module DockerEngineRuby
       end
       attr_writer :manager_status
 
-      sig { returns(T.nilable(DockerEngineRuby::Spec)) }
+      sig { returns(T.nilable(DockerEngineRuby::NodeSpec)) }
       attr_reader :spec
 
-      sig { params(spec: DockerEngineRuby::Spec::OrHash).void }
+      sig { params(spec: DockerEngineRuby::NodeSpec::OrHash).void }
       attr_writer :spec
 
       # NodeStatus represents the status of a node.
@@ -90,7 +90,7 @@ module DockerEngineRuby
           description: DockerEngineRuby::Node::Description::OrHash,
           id: String,
           manager_status: DockerEngineRuby::Node::ManagerStatus::OrHash,
-          spec: DockerEngineRuby::Spec::OrHash,
+          spec: DockerEngineRuby::NodeSpec::OrHash,
           status: DockerEngineRuby::Node::Status::OrHash,
           updated_at: Time,
           version: DockerEngineRuby::Node::Version::OrHash
@@ -137,7 +137,7 @@ module DockerEngineRuby
             description: DockerEngineRuby::Node::Description,
             id: String,
             manager_status: DockerEngineRuby::Node::ManagerStatus,
-            spec: DockerEngineRuby::Spec,
+            spec: DockerEngineRuby::NodeSpec,
             status: DockerEngineRuby::Node::Status,
             updated_at: Time,
             version: DockerEngineRuby::Node::Version

data/rbi/docker_engine_ruby/models/node_spec.rbi

@@ -0,0 +1,126 @@
+# typed: strong
+
+module DockerEngineRuby
+  module Models
+    class NodeSpec < DockerEngineRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(DockerEngineRuby::NodeSpec, DockerEngineRuby::Internal::AnyHash)
+        end
+
+      # Availability of the node.
+      sig do
+        returns(T.nilable(DockerEngineRuby::NodeSpec::Availability::OrSymbol))
+      end
+      attr_reader :availability
+
+      sig do
+        params(
+          availability: DockerEngineRuby::NodeSpec::Availability::OrSymbol
+        ).void
+      end
+      attr_writer :availability
+
+      # User-defined key/value metadata.
+      sig { returns(T.nilable(T::Hash[Symbol, String])) }
+      attr_reader :labels
+
+      sig { params(labels: T::Hash[Symbol, String]).void }
+      attr_writer :labels
+
+      # Name for the node.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # Role of the node.
+      sig { returns(T.nilable(DockerEngineRuby::NodeSpec::Role::OrSymbol)) }
+      attr_reader :role
+
+      sig { params(role: DockerEngineRuby::NodeSpec::Role::OrSymbol).void }
+      attr_writer :role
+
+      sig do
+        params(
+          availability: DockerEngineRuby::NodeSpec::Availability::OrSymbol,
+          labels: T::Hash[Symbol, String],
+          name: String,
+          role: DockerEngineRuby::NodeSpec::Role::OrSymbol
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # Availability of the node.
+        availability: nil,
+        # User-defined key/value metadata.
+        labels: nil,
+        # Name for the node.
+        name: nil,
+        # Role of the node.
+        role: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            availability: DockerEngineRuby::NodeSpec::Availability::OrSymbol,
+            labels: T::Hash[Symbol, String],
+            name: String,
+            role: DockerEngineRuby::NodeSpec::Role::OrSymbol
+          }
+        )
+      end
+      def to_hash
+      end
+
+      # Availability of the node.
+      module Availability
+        extend DockerEngineRuby::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias do
+            T.all(Symbol, DockerEngineRuby::NodeSpec::Availability)
+          end
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        ACTIVE =
+          T.let(:active, DockerEngineRuby::NodeSpec::Availability::TaggedSymbol)
+        PAUSE =
+          T.let(:pause, DockerEngineRuby::NodeSpec::Availability::TaggedSymbol)
+        DRAIN =
+          T.let(:drain, DockerEngineRuby::NodeSpec::Availability::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[DockerEngineRuby::NodeSpec::Availability::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+
+      # Role of the node.
+      module Role
+        extend DockerEngineRuby::Internal::Type::Enum
+
+        TaggedSymbol =
+          T.type_alias { T.all(Symbol, DockerEngineRuby::NodeSpec::Role) }
+        OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+        WORKER = T.let(:worker, DockerEngineRuby::NodeSpec::Role::TaggedSymbol)
+        MANAGER =
+          T.let(:manager, DockerEngineRuby::NodeSpec::Role::TaggedSymbol)
+
+        sig do
+          override.returns(
+            T::Array[DockerEngineRuby::NodeSpec::Role::TaggedSymbol]
+          )
+        end
+        def self.values
+        end
+      end
+    end
+  end
+end