docker-engine-ruby 0.2.2 → 0.4.0

data/rbi/docker_engine_ruby/models/swarm_spec.rbi

@@ -0,0 +1,568 @@
+# typed: strong
+
+module DockerEngineRuby
+  module Models
+    class SwarmSpec < DockerEngineRuby::Internal::Type::BaseModel
+      OrHash =
+        T.type_alias do
+          T.any(
+            DockerEngineRuby::SwarmSpec,
+            DockerEngineRuby::Internal::AnyHash
+          )
+        end
+
+      # CA configuration.
+      sig { returns(T.nilable(DockerEngineRuby::SwarmSpec::CaConfig)) }
+      attr_reader :ca_config
+
+      sig do
+        params(
+          ca_config: T.nilable(DockerEngineRuby::SwarmSpec::CaConfig::OrHash)
+        ).void
+      end
+      attr_writer :ca_config
+
+      # Dispatcher configuration.
+      sig { returns(T.nilable(DockerEngineRuby::SwarmSpec::Dispatcher)) }
+      attr_reader :dispatcher
+
+      sig do
+        params(
+          dispatcher: T.nilable(DockerEngineRuby::SwarmSpec::Dispatcher::OrHash)
+        ).void
+      end
+      attr_writer :dispatcher
+
+      # Parameters related to encryption-at-rest.
+      sig { returns(T.nilable(DockerEngineRuby::SwarmSpec::EncryptionConfig)) }
+      attr_reader :encryption_config
+
+      sig do
+        params(
+          encryption_config:
+            DockerEngineRuby::SwarmSpec::EncryptionConfig::OrHash
+        ).void
+      end
+      attr_writer :encryption_config
+
+      # 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 of the swarm.
+      sig { returns(T.nilable(String)) }
+      attr_reader :name
+
+      sig { params(name: String).void }
+      attr_writer :name
+
+      # Orchestration configuration.
+      sig { returns(T.nilable(DockerEngineRuby::SwarmSpec::Orchestration)) }
+      attr_reader :orchestration
+
+      sig do
+        params(
+          orchestration:
+            T.nilable(DockerEngineRuby::SwarmSpec::Orchestration::OrHash)
+        ).void
+      end
+      attr_writer :orchestration
+
+      # Raft configuration.
+      sig { returns(T.nilable(DockerEngineRuby::SwarmSpec::Raft)) }
+      attr_reader :raft
+
+      sig { params(raft: DockerEngineRuby::SwarmSpec::Raft::OrHash).void }
+      attr_writer :raft
+
+      # Defaults for creating tasks in this cluster.
+      sig { returns(T.nilable(DockerEngineRuby::SwarmSpec::TaskDefaults)) }
+      attr_reader :task_defaults
+
+      sig do
+        params(
+          task_defaults: DockerEngineRuby::SwarmSpec::TaskDefaults::OrHash
+        ).void
+      end
+      attr_writer :task_defaults
+
+      # User modifiable swarm configuration.
+      sig do
+        params(
+          ca_config: T.nilable(DockerEngineRuby::SwarmSpec::CaConfig::OrHash),
+          dispatcher:
+            T.nilable(DockerEngineRuby::SwarmSpec::Dispatcher::OrHash),
+          encryption_config:
+            DockerEngineRuby::SwarmSpec::EncryptionConfig::OrHash,
+          labels: T::Hash[Symbol, String],
+          name: String,
+          orchestration:
+            T.nilable(DockerEngineRuby::SwarmSpec::Orchestration::OrHash),
+          raft: DockerEngineRuby::SwarmSpec::Raft::OrHash,
+          task_defaults: DockerEngineRuby::SwarmSpec::TaskDefaults::OrHash
+        ).returns(T.attached_class)
+      end
+      def self.new(
+        # CA configuration.
+        ca_config: nil,
+        # Dispatcher configuration.
+        dispatcher: nil,
+        # Parameters related to encryption-at-rest.
+        encryption_config: nil,
+        # User-defined key/value metadata.
+        labels: nil,
+        # Name of the swarm.
+        name: nil,
+        # Orchestration configuration.
+        orchestration: nil,
+        # Raft configuration.
+        raft: nil,
+        # Defaults for creating tasks in this cluster.
+        task_defaults: nil
+      )
+      end
+
+      sig do
+        override.returns(
+          {
+            ca_config: T.nilable(DockerEngineRuby::SwarmSpec::CaConfig),
+            dispatcher: T.nilable(DockerEngineRuby::SwarmSpec::Dispatcher),
+            encryption_config: DockerEngineRuby::SwarmSpec::EncryptionConfig,
+            labels: T::Hash[Symbol, String],
+            name: String,
+            orchestration:
+              T.nilable(DockerEngineRuby::SwarmSpec::Orchestration),
+            raft: DockerEngineRuby::SwarmSpec::Raft,
+            task_defaults: DockerEngineRuby::SwarmSpec::TaskDefaults
+          }
+        )
+      end
+      def to_hash
+      end
+
+      class CaConfig < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::SwarmSpec::CaConfig,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(
+              T::Array[DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA]
+            )
+          )
+        end
+        attr_reader :external_c_as
+
+        sig do
+          params(
+            external_c_as:
+              T::Array[
+                DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::OrHash
+              ]
+          ).void
+        end
+        attr_writer :external_c_as
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :force_rotate
+
+        sig { params(force_rotate: Integer).void }
+        attr_writer :force_rotate
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :node_cert_expiry
+
+        sig { params(node_cert_expiry: Integer).void }
+        attr_writer :node_cert_expiry
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :signing_ca_cert
+
+        sig { params(signing_ca_cert: String).void }
+        attr_writer :signing_ca_cert
+
+        sig { returns(T.nilable(String)) }
+        attr_reader :signing_ca_key
+
+        sig { params(signing_ca_key: String).void }
+        attr_writer :signing_ca_key
+
+        # CA configuration.
+        sig do
+          params(
+            external_c_as:
+              T::Array[
+                DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::OrHash
+              ],
+            force_rotate: Integer,
+            node_cert_expiry: Integer,
+            signing_ca_cert: String,
+            signing_ca_key: String
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          external_c_as: nil,
+          force_rotate: nil,
+          node_cert_expiry: nil,
+          signing_ca_cert: nil,
+          signing_ca_key: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              external_c_as:
+                T::Array[DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA],
+              force_rotate: Integer,
+              node_cert_expiry: Integer,
+              signing_ca_cert: String,
+              signing_ca_key: String
+            }
+          )
+        end
+        def to_hash
+        end
+
+        class ExternalCA < DockerEngineRuby::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA,
+                DockerEngineRuby::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :ca_cert
+
+          sig { params(ca_cert: String).void }
+          attr_writer :ca_cert
+
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_reader :options
+
+          sig { params(options: T::Hash[Symbol, String]).void }
+          attr_writer :options
+
+          sig do
+            returns(
+              T.nilable(
+                DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::Protocol::OrSymbol
+              )
+            )
+          end
+          attr_reader :protocol
+
+          sig do
+            params(
+              protocol:
+                DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::Protocol::OrSymbol
+            ).void
+          end
+          attr_writer :protocol
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :url
+
+          sig { params(url: String).void }
+          attr_writer :url
+
+          sig do
+            params(
+              ca_cert: String,
+              options: T::Hash[Symbol, String],
+              protocol:
+                DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::Protocol::OrSymbol,
+              url: String
+            ).returns(T.attached_class)
+          end
+          def self.new(ca_cert: nil, options: nil, protocol: nil, url: nil)
+          end
+
+          sig do
+            override.returns(
+              {
+                ca_cert: String,
+                options: T::Hash[Symbol, String],
+                protocol:
+                  DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::Protocol::OrSymbol,
+                url: String
+              }
+            )
+          end
+          def to_hash
+          end
+
+          module Protocol
+            extend DockerEngineRuby::Internal::Type::Enum
+
+            TaggedSymbol =
+              T.type_alias do
+                T.all(
+                  Symbol,
+                  DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::Protocol
+                )
+              end
+            OrSymbol = T.type_alias { T.any(Symbol, String) }
+
+            CFSSL =
+              T.let(
+                :cfssl,
+                DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::Protocol::TaggedSymbol
+              )
+
+            sig do
+              override.returns(
+                T::Array[
+                  DockerEngineRuby::SwarmSpec::CaConfig::ExternalCA::Protocol::TaggedSymbol
+                ]
+              )
+            end
+            def self.values
+            end
+          end
+        end
+      end
+
+      class Dispatcher < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::SwarmSpec::Dispatcher,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :heartbeat_period
+
+        sig { params(heartbeat_period: Integer).void }
+        attr_writer :heartbeat_period
+
+        # Dispatcher configuration.
+        sig { params(heartbeat_period: Integer).returns(T.attached_class) }
+        def self.new(heartbeat_period: nil)
+        end
+
+        sig { override.returns({ heartbeat_period: Integer }) }
+        def to_hash
+        end
+      end
+
+      class EncryptionConfig < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::SwarmSpec::EncryptionConfig,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(T::Boolean)) }
+        attr_reader :auto_lock_managers
+
+        sig { params(auto_lock_managers: T::Boolean).void }
+        attr_writer :auto_lock_managers
+
+        # Parameters related to encryption-at-rest.
+        sig { params(auto_lock_managers: T::Boolean).returns(T.attached_class) }
+        def self.new(auto_lock_managers: nil)
+        end
+
+        sig { override.returns({ auto_lock_managers: T::Boolean }) }
+        def to_hash
+        end
+      end
+
+      class Orchestration < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::SwarmSpec::Orchestration,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :task_history_retention_limit
+
+        sig { params(task_history_retention_limit: Integer).void }
+        attr_writer :task_history_retention_limit
+
+        # Orchestration configuration.
+        sig do
+          params(task_history_retention_limit: Integer).returns(
+            T.attached_class
+          )
+        end
+        def self.new(task_history_retention_limit: nil)
+        end
+
+        sig { override.returns({ task_history_retention_limit: Integer }) }
+        def to_hash
+        end
+      end
+
+      class Raft < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::SwarmSpec::Raft,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :election_tick
+
+        sig { params(election_tick: Integer).void }
+        attr_writer :election_tick
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :heartbeat_tick
+
+        sig { params(heartbeat_tick: Integer).void }
+        attr_writer :heartbeat_tick
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :keep_old_snapshots
+
+        sig { params(keep_old_snapshots: Integer).void }
+        attr_writer :keep_old_snapshots
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :log_entries_for_slow_followers
+
+        sig { params(log_entries_for_slow_followers: Integer).void }
+        attr_writer :log_entries_for_slow_followers
+
+        sig { returns(T.nilable(Integer)) }
+        attr_reader :snapshot_interval
+
+        sig { params(snapshot_interval: Integer).void }
+        attr_writer :snapshot_interval
+
+        # Raft configuration.
+        sig do
+          params(
+            election_tick: Integer,
+            heartbeat_tick: Integer,
+            keep_old_snapshots: Integer,
+            log_entries_for_slow_followers: Integer,
+            snapshot_interval: Integer
+          ).returns(T.attached_class)
+        end
+        def self.new(
+          election_tick: nil,
+          heartbeat_tick: nil,
+          keep_old_snapshots: nil,
+          log_entries_for_slow_followers: nil,
+          snapshot_interval: nil
+        )
+        end
+
+        sig do
+          override.returns(
+            {
+              election_tick: Integer,
+              heartbeat_tick: Integer,
+              keep_old_snapshots: Integer,
+              log_entries_for_slow_followers: Integer,
+              snapshot_interval: Integer
+            }
+          )
+        end
+        def to_hash
+        end
+      end
+
+      class TaskDefaults < DockerEngineRuby::Internal::Type::BaseModel
+        OrHash =
+          T.type_alias do
+            T.any(
+              DockerEngineRuby::SwarmSpec::TaskDefaults,
+              DockerEngineRuby::Internal::AnyHash
+            )
+          end
+
+        sig do
+          returns(
+            T.nilable(DockerEngineRuby::SwarmSpec::TaskDefaults::LogDriver)
+          )
+        end
+        attr_reader :log_driver
+
+        sig do
+          params(
+            log_driver:
+              DockerEngineRuby::SwarmSpec::TaskDefaults::LogDriver::OrHash
+          ).void
+        end
+        attr_writer :log_driver
+
+        # Defaults for creating tasks in this cluster.
+        sig do
+          params(
+            log_driver:
+              DockerEngineRuby::SwarmSpec::TaskDefaults::LogDriver::OrHash
+          ).returns(T.attached_class)
+        end
+        def self.new(log_driver: nil)
+        end
+
+        sig do
+          override.returns(
+            { log_driver: DockerEngineRuby::SwarmSpec::TaskDefaults::LogDriver }
+          )
+        end
+        def to_hash
+        end
+
+        class LogDriver < DockerEngineRuby::Internal::Type::BaseModel
+          OrHash =
+            T.type_alias do
+              T.any(
+                DockerEngineRuby::SwarmSpec::TaskDefaults::LogDriver,
+                DockerEngineRuby::Internal::AnyHash
+              )
+            end
+
+          sig { returns(T.nilable(String)) }
+          attr_reader :name
+
+          sig { params(name: String).void }
+          attr_writer :name
+
+          sig { returns(T.nilable(T::Hash[Symbol, String])) }
+          attr_reader :options
+
+          sig { params(options: T::Hash[Symbol, String]).void }
+          attr_writer :options
+
+          sig do
+            params(name: String, options: T::Hash[Symbol, String]).returns(
+              T.attached_class
+            )
+          end
+          def self.new(name: nil, options: nil)
+          end
+
+          sig do
+            override.returns({ name: String, options: T::Hash[Symbol, String] })
+          end
+          def to_hash
+          end
+        end
+      end
+    end
+  end
+end

data/rbi/docker_engine_ruby/models/swarm_unlock_key_response.rbi

@@ -11,7 +11,6 @@ module DockerEngineRuby
           )
         end
 
-      # The swarm's unlock key.
       sig { returns(T.nilable(String)) }
       attr_reader :unlock_key
 
@@ -19,10 +18,7 @@ module DockerEngineRuby
       attr_writer :unlock_key
 
       sig { params(unlock_key: String).returns(T.attached_class) }
-      def self.new(
-        # The swarm's unlock key.
-        unlock_key: nil
-      )
+      def self.new(unlock_key: nil)
       end
 
       sig { override.returns({ unlock_key: String }) }

data/rbi/docker_engine_ruby/models/swarm_unlock_params.rbi

@@ -14,7 +14,6 @@ module DockerEngineRuby
           )
         end
 
-      # The swarm's unlock key.
       sig { returns(T.nilable(String)) }
       attr_reader :unlock_key
 
@@ -27,11 +26,7 @@ module DockerEngineRuby
           request_options: DockerEngineRuby::RequestOptions::OrHash
         ).returns(T.attached_class)
       end
-      def self.new(
-        # The swarm's unlock key.
-        unlock_key: nil,
-        request_options: {}
-      )
+      def self.new(unlock_key: nil, request_options: {})
       end
 
       sig do

data/rbi/docker_engine_ruby/models/swarm_update_params.rbi

@@ -14,26 +14,21 @@ module DockerEngineRuby
           )
         end
 
-      # The version number of the swarm object being updated. This is required to avoid
-      # conflicting writes.
       sig { returns(Integer) }
       attr_accessor :version
 
-      # Rotate the manager join token.
       sig { returns(T.nilable(T::Boolean)) }
       attr_reader :rotate_manager_token
 
       sig { params(rotate_manager_token: T::Boolean).void }
       attr_writer :rotate_manager_token
 
-      # Rotate the manager unlock key.
       sig { returns(T.nilable(T::Boolean)) }
       attr_reader :rotate_manager_unlock_key
 
       sig { params(rotate_manager_unlock_key: T::Boolean).void }
       attr_writer :rotate_manager_unlock_key
 
-      # Rotate the worker join token.
       sig { returns(T.nilable(T::Boolean)) }
       attr_reader :rotate_worker_token
 
@@ -50,14 +45,9 @@ module DockerEngineRuby
         ).returns(T.attached_class)
       end
       def self.new(
-        # The version number of the swarm object being updated. This is required to avoid
-        # conflicting writes.
         version:,
-        # Rotate the manager join token.
         rotate_manager_token: nil,
-        # Rotate the manager unlock key.
         rotate_manager_unlock_key: nil,
-        # Rotate the worker join token.
         rotate_worker_token: nil,
         request_options: {}
       )