kube-dsl 0.1.0 → 0.5.1

data/lib/kube-dsl/dsl/v1/config_map_projection.rb

@@ -1,13 +1,18 @@
 module KubeDSL::DSL::V1
   class ConfigMapProjection < ::KubeDSL::DSLObject
-    value_fields :name, :optional
     array_field(:item) { KubeDSL::DSL::V1::KeyToPath.new }
+    value_field :name
+    value_field :optional
+
+    validates :items, array: { kind_of: KubeDSL::DSL::V1::KeyToPath }, presence: false
+    validates :name, field: { format: :string }, presence: false
+    validates :optional, field: { format: :boolean }, presence: false
 
     def serialize
       {}.tap do |result|
+        result[:items] = items.map(&:serialize)
         result[:name] = name
         result[:optional] = optional
-        result[:items] = items.map(&:serialize)
       end
     end
 

data/lib/kube-dsl/dsl/v1/config_map_volume_source.rb

@@ -1,14 +1,21 @@
 module KubeDSL::DSL::V1
   class ConfigMapVolumeSource < ::KubeDSL::DSLObject
-    value_fields :default_mode, :name, :optional
+    value_field :default_mode
     array_field(:item) { KubeDSL::DSL::V1::KeyToPath.new }
+    value_field :name
+    value_field :optional
+
+    validates :default_mode, field: { format: :integer }, presence: false
+    validates :items, array: { kind_of: KubeDSL::DSL::V1::KeyToPath }, presence: false
+    validates :name, field: { format: :string }, presence: false
+    validates :optional, field: { format: :boolean }, presence: false
 
     def serialize
       {}.tap do |result|
         result[:defaultMode] = default_mode
+        result[:items] = items.map(&:serialize)
         result[:name] = name
         result[:optional] = optional
-        result[:items] = items.map(&:serialize)
       end
     end
 

data/lib/kube-dsl/dsl/v1/container.rb

@@ -1,44 +1,75 @@
 module KubeDSL::DSL::V1
   class Container < ::KubeDSL::DSLObject
-    value_fields :image, :image_pull_policy, :name, :stdin, :stdin_once, :termination_message_path, :termination_message_policy, :tty, :working_dir
-    array_field :arg
-    array_field :command
+    value_field :args
+    value_field :command
     array_field(:env) { KubeDSL::DSL::V1::EnvVar.new }
     array_field(:env_from) { KubeDSL::DSL::V1::EnvFromSource.new }
-    array_field(:port) { KubeDSL::DSL::V1::ContainerPort.new }
-    array_field(:volume_device) { KubeDSL::DSL::V1::VolumeDevice.new }
-    array_field(:volume_mount) { KubeDSL::DSL::V1::VolumeMount.new }
+    value_field :image
+    value_field :image_pull_policy
     object_field(:lifecycle) { KubeDSL::DSL::V1::Lifecycle.new }
     object_field(:liveness_probe) { KubeDSL::DSL::V1::Probe.new }
+    value_field :name
+    array_field(:port) { KubeDSL::DSL::V1::ContainerPort.new }
     object_field(:readiness_probe) { KubeDSL::DSL::V1::Probe.new }
     object_field(:resources) { KubeDSL::DSL::V1::ResourceRequirements.new }
     object_field(:security_context) { KubeDSL::DSL::V1::SecurityContext.new }
     object_field(:startup_probe) { KubeDSL::DSL::V1::Probe.new }
+    value_field :stdin
+    value_field :stdin_once
+    value_field :termination_message_path
+    value_field :termination_message_policy
+    value_field :tty
+    array_field(:volume_device) { KubeDSL::DSL::V1::VolumeDevice.new }
+    array_field(:volume_mount) { KubeDSL::DSL::V1::VolumeMount.new }
+    value_field :working_dir
+
+    validates :args, field: { format: :string }, presence: false
+    validates :command, field: { format: :string }, presence: false
+    validates :envs, array: { kind_of: KubeDSL::DSL::V1::EnvVar }, presence: false
+    validates :env_froms, array: { kind_of: KubeDSL::DSL::V1::EnvFromSource }, presence: false
+    validates :image, field: { format: :string }, presence: false
+    validates :image_pull_policy, field: { format: :string }, presence: false
+    validates :lifecycle, object: { kind_of: KubeDSL::DSL::V1::Lifecycle }
+    validates :liveness_probe, object: { kind_of: KubeDSL::DSL::V1::Probe }
+    validates :name, field: { format: :string }, presence: false
+    validates :ports, array: { kind_of: KubeDSL::DSL::V1::ContainerPort }, presence: false
+    validates :readiness_probe, object: { kind_of: KubeDSL::DSL::V1::Probe }
+    validates :resources, object: { kind_of: KubeDSL::DSL::V1::ResourceRequirements }
+    validates :security_context, object: { kind_of: KubeDSL::DSL::V1::SecurityContext }
+    validates :startup_probe, object: { kind_of: KubeDSL::DSL::V1::Probe }
+    validates :stdin, field: { format: :boolean }, presence: false
+    validates :stdin_once, field: { format: :boolean }, presence: false
+    validates :termination_message_path, field: { format: :string }, presence: false
+    validates :termination_message_policy, field: { format: :string }, presence: false
+    validates :tty, field: { format: :boolean }, presence: false
+    validates :volume_devices, array: { kind_of: KubeDSL::DSL::V1::VolumeDevice }, presence: false
+    validates :volume_mounts, array: { kind_of: KubeDSL::DSL::V1::VolumeMount }, presence: false
+    validates :working_dir, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|
+        result[:args] = args
+        result[:command] = command
+        result[:env] = envs.map(&:serialize)
+        result[:envFrom] = env_froms.map(&:serialize)
         result[:image] = image
         result[:imagePullPolicy] = image_pull_policy
+        result[:lifecycle] = lifecycle.serialize
+        result[:livenessProbe] = liveness_probe.serialize
         result[:name] = name
+        result[:ports] = ports.map(&:serialize)
+        result[:readinessProbe] = readiness_probe.serialize
+        result[:resources] = resources.serialize
+        result[:securityContext] = security_context.serialize
+        result[:startupProbe] = startup_probe.serialize
         result[:stdin] = stdin
         result[:stdinOnce] = stdin_once
         result[:terminationMessagePath] = termination_message_path
         result[:terminationMessagePolicy] = termination_message_policy
         result[:tty] = tty
-        result[:workingDir] = working_dir
-        result[:args] = args
-        result[:command] = commands
-        result[:env] = envs.map(&:serialize)
-        result[:envFrom] = env_froms.map(&:serialize)
-        result[:ports] = ports.map(&:serialize)
         result[:volumeDevices] = volume_devices.map(&:serialize)
         result[:volumeMounts] = volume_mounts.map(&:serialize)
-        result[:lifecycle] = lifecycle.serialize
-        result[:livenessProbe] = liveness_probe.serialize
-        result[:readinessProbe] = readiness_probe.serialize
-        result[:resources] = resources.serialize
-        result[:securityContext] = security_context.serialize
-        result[:startupProbe] = startup_probe.serialize
+        result[:workingDir] = working_dir
       end
     end
 

data/lib/kube-dsl/dsl/v1/container_image.rb

@@ -1,12 +1,15 @@
 module KubeDSL::DSL::V1
   class ContainerImage < ::KubeDSL::DSLObject
-    value_fields :size_bytes
-    array_field :name
+    value_field :names
+    value_field :size_bytes
+
+    validates :names, field: { format: :string }, presence: false
+    validates :size_bytes, field: { format: :integer }, presence: false
 
     def serialize
       {}.tap do |result|
-        result[:sizeBytes] = size_bytes
         result[:names] = names
+        result[:sizeBytes] = size_bytes
       end
     end
 

data/lib/kube-dsl/dsl/v1/container_port.rb

@@ -1,6 +1,16 @@
 module KubeDSL::DSL::V1
   class ContainerPort < ::KubeDSL::DSLObject
-    value_fields :container_port, :host_ip, :host_port, :name, :protocol
+    value_field :container_port
+    value_field :host_ip
+    value_field :host_port
+    value_field :name
+    value_field :protocol
+
+    validates :container_port, field: { format: :integer }, presence: false
+    validates :host_ip, field: { format: :string }, presence: false
+    validates :host_port, field: { format: :integer }, presence: false
+    validates :name, field: { format: :string }, presence: false
+    validates :protocol, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|

data/lib/kube-dsl/dsl/v1/container_state.rb

@@ -4,6 +4,10 @@ module KubeDSL::DSL::V1
     object_field(:terminated) { KubeDSL::DSL::V1::ContainerStateTerminated.new }
     object_field(:waiting) { KubeDSL::DSL::V1::ContainerStateWaiting.new }
 
+    validates :running, object: { kind_of: KubeDSL::DSL::V1::ContainerStateRunning }
+    validates :terminated, object: { kind_of: KubeDSL::DSL::V1::ContainerStateTerminated }
+    validates :waiting, object: { kind_of: KubeDSL::DSL::V1::ContainerStateWaiting }
+
     def serialize
       {}.tap do |result|
         result[:running] = running.serialize

data/lib/kube-dsl/dsl/v1/container_state_running.rb

@@ -1,6 +1,8 @@
 module KubeDSL::DSL::V1
   class ContainerStateRunning < ::KubeDSL::DSLObject
-    value_fields :started_at
+    value_field :started_at
+
+    validates :started_at, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|

data/lib/kube-dsl/dsl/v1/container_state_terminated.rb

@@ -1,6 +1,20 @@
 module KubeDSL::DSL::V1
   class ContainerStateTerminated < ::KubeDSL::DSLObject
-    value_fields :container_id, :exit_code, :finished_at, :message, :reason, :signal, :started_at
+    value_field :container_id
+    value_field :exit_code
+    value_field :finished_at
+    value_field :message
+    value_field :reason
+    value_field :signal
+    value_field :started_at
+
+    validates :container_id, field: { format: :string }, presence: false
+    validates :exit_code, field: { format: :integer }, presence: false
+    validates :finished_at, field: { format: :string }, presence: false
+    validates :message, field: { format: :string }, presence: false
+    validates :reason, field: { format: :string }, presence: false
+    validates :signal, field: { format: :integer }, presence: false
+    validates :started_at, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|

data/lib/kube-dsl/dsl/v1/container_state_waiting.rb

@@ -1,6 +1,10 @@
 module KubeDSL::DSL::V1
   class ContainerStateWaiting < ::KubeDSL::DSLObject
-    value_fields :message, :reason
+    value_field :message
+    value_field :reason
+
+    validates :message, field: { format: :string }, presence: false
+    validates :reason, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|

data/lib/kube-dsl/dsl/v1/container_status.rb

@@ -1,19 +1,35 @@
 module KubeDSL::DSL::V1
   class ContainerStatus < ::KubeDSL::DSLObject
-    value_fields :container_id, :image, :image_id, :name, :ready, :restart_count, :started
+    value_field :container_id
+    value_field :image
+    value_field :image_id
     object_field(:last_state) { KubeDSL::DSL::V1::ContainerState.new }
+    value_field :name
+    value_field :ready
+    value_field :restart_count
+    value_field :started
     object_field(:state) { KubeDSL::DSL::V1::ContainerState.new }
 
+    validates :container_id, field: { format: :string }, presence: false
+    validates :image, field: { format: :string }, presence: false
+    validates :image_id, field: { format: :string }, presence: false
+    validates :last_state, object: { kind_of: KubeDSL::DSL::V1::ContainerState }
+    validates :name, field: { format: :string }, presence: false
+    validates :ready, field: { format: :boolean }, presence: false
+    validates :restart_count, field: { format: :integer }, presence: false
+    validates :started, field: { format: :boolean }, presence: false
+    validates :state, object: { kind_of: KubeDSL::DSL::V1::ContainerState }
+
     def serialize
       {}.tap do |result|
         result[:containerID] = container_id
         result[:image] = image
         result[:imageID] = image_id
+        result[:lastState] = last_state.serialize
         result[:name] = name
         result[:ready] = ready
         result[:restartCount] = restart_count
         result[:started] = started
-        result[:lastState] = last_state.serialize
         result[:state] = state.serialize
       end
     end

data/lib/kube-dsl/dsl/v1/csi_persistent_volume_source.rb

@@ -1,23 +1,36 @@
 module KubeDSL::DSL::V1
   class CSIPersistentVolumeSource < ::KubeDSL::DSLObject
-    value_fields :driver, :fs_type, :read_only, :volume_handle
     object_field(:controller_expand_secret_ref) { KubeDSL::DSL::V1::SecretReference.new }
     object_field(:controller_publish_secret_ref) { KubeDSL::DSL::V1::SecretReference.new }
+    value_field :driver
+    value_field :fs_type
     object_field(:node_publish_secret_ref) { KubeDSL::DSL::V1::SecretReference.new }
     object_field(:node_stage_secret_ref) { KubeDSL::DSL::V1::SecretReference.new }
-    object_field(:volume_attributes) { ::KubeDSL::KeyValueFields.new(format: :string) }
+    value_field :read_only
+    key_value_field(:volume_attributes, format: :string)
+    value_field :volume_handle
+
+    validates :controller_expand_secret_ref, object: { kind_of: KubeDSL::DSL::V1::SecretReference }
+    validates :controller_publish_secret_ref, object: { kind_of: KubeDSL::DSL::V1::SecretReference }
+    validates :driver, field: { format: :string }, presence: false
+    validates :fs_type, field: { format: :string }, presence: false
+    validates :node_publish_secret_ref, object: { kind_of: KubeDSL::DSL::V1::SecretReference }
+    validates :node_stage_secret_ref, object: { kind_of: KubeDSL::DSL::V1::SecretReference }
+    validates :read_only, field: { format: :boolean }, presence: false
+    validates :volume_attributes, kv: { value_format: :string }, presence: false
+    validates :volume_handle, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|
-        result[:driver] = driver
-        result[:fsType] = fs_type
-        result[:readOnly] = read_only
-        result[:volumeHandle] = volume_handle
         result[:controllerExpandSecretRef] = controller_expand_secret_ref.serialize
         result[:controllerPublishSecretRef] = controller_publish_secret_ref.serialize
+        result[:driver] = driver
+        result[:fsType] = fs_type
         result[:nodePublishSecretRef] = node_publish_secret_ref.serialize
         result[:nodeStageSecretRef] = node_stage_secret_ref.serialize
+        result[:readOnly] = read_only
         result[:volumeAttributes] = volume_attributes.serialize
+        result[:volumeHandle] = volume_handle
       end
     end
 

data/lib/kube-dsl/dsl/v1/csi_volume_source.rb

@@ -1,15 +1,23 @@
 module KubeDSL::DSL::V1
   class CSIVolumeSource < ::KubeDSL::DSLObject
-    value_fields :driver, :fs_type, :read_only
+    value_field :driver
+    value_field :fs_type
     object_field(:node_publish_secret_ref) { KubeDSL::DSL::V1::LocalObjectReference.new }
-    object_field(:volume_attributes) { ::KubeDSL::KeyValueFields.new(format: :string) }
+    value_field :read_only
+    key_value_field(:volume_attributes, format: :string)
+
+    validates :driver, field: { format: :string }, presence: false
+    validates :fs_type, field: { format: :string }, presence: false
+    validates :node_publish_secret_ref, object: { kind_of: KubeDSL::DSL::V1::LocalObjectReference }
+    validates :read_only, field: { format: :boolean }, presence: false
+    validates :volume_attributes, kv: { value_format: :string }, presence: false
 
     def serialize
       {}.tap do |result|
         result[:driver] = driver
         result[:fsType] = fs_type
-        result[:readOnly] = read_only
         result[:nodePublishSecretRef] = node_publish_secret_ref.serialize
+        result[:readOnly] = read_only
         result[:volumeAttributes] = volume_attributes.serialize
       end
     end

data/lib/kube-dsl/dsl/v1/daemon_endpoint.rb

@@ -1,6 +1,8 @@
 module KubeDSL::DSL::V1
   class DaemonEndpoint < ::KubeDSL::DSLObject
-    value_fields :port
+    value_field :port
+
+    validates :port, field: { format: :integer }, presence: false
 
     def serialize
       {}.tap do |result|

data/lib/kube-dsl/dsl/v1/downward_api_projection.rb

@@ -2,6 +2,8 @@ module KubeDSL::DSL::V1
   class DownwardAPIProjection < ::KubeDSL::DSLObject
     array_field(:item) { KubeDSL::DSL::V1::DownwardAPIVolumeFile.new }
 
+    validates :items, array: { kind_of: KubeDSL::DSL::V1::DownwardAPIVolumeFile }, presence: false
+
     def serialize
       {}.tap do |result|
         result[:items] = items.map(&:serialize)

data/lib/kube-dsl/dsl/v1/downward_api_volume_file.rb

@@ -1,14 +1,20 @@
 module KubeDSL::DSL::V1
   class DownwardAPIVolumeFile < ::KubeDSL::DSLObject
-    value_fields :mode, :path
     object_field(:field_ref) { KubeDSL::DSL::V1::ObjectFieldSelector.new }
+    value_field :mode
+    value_field :path
     object_field(:resource_field_ref) { KubeDSL::DSL::V1::ResourceFieldSelector.new }
 
+    validates :field_ref, object: { kind_of: KubeDSL::DSL::V1::ObjectFieldSelector }
+    validates :mode, field: { format: :integer }, presence: false
+    validates :path, field: { format: :string }, presence: false
+    validates :resource_field_ref, object: { kind_of: KubeDSL::DSL::V1::ResourceFieldSelector }
+
     def serialize
       {}.tap do |result|
+        result[:fieldRef] = field_ref.serialize
         result[:mode] = mode
         result[:path] = path
-        result[:fieldRef] = field_ref.serialize
         result[:resourceFieldRef] = resource_field_ref.serialize
       end
     end

data/lib/kube-dsl/dsl/v1/downward_api_volume_source.rb

@@ -1,8 +1,11 @@
 module KubeDSL::DSL::V1
   class DownwardAPIVolumeSource < ::KubeDSL::DSLObject
-    value_fields :default_mode
+    value_field :default_mode
     array_field(:item) { KubeDSL::DSL::V1::DownwardAPIVolumeFile.new }
 
+    validates :default_mode, field: { format: :integer }, presence: false
+    validates :items, array: { kind_of: KubeDSL::DSL::V1::DownwardAPIVolumeFile }, presence: false
+
     def serialize
       {}.tap do |result|
         result[:defaultMode] = default_mode

data/lib/kube-dsl/dsl/v1/empty_dir_volume_source.rb

@@ -1,6 +1,10 @@
 module KubeDSL::DSL::V1
   class EmptyDirVolumeSource < ::KubeDSL::DSLObject
-    value_fields :medium, :size_limit
+    value_field :medium
+    value_field :size_limit
+
+    validates :medium, field: { format: :string }, presence: false
+    validates :size_limit, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|

data/lib/kube-dsl/dsl/v1/endpoint_address.rb

@@ -1,8 +1,15 @@
 module KubeDSL::DSL::V1
   class EndpointAddress < ::KubeDSL::DSLObject
-    value_fields :hostname, :ip, :node_name
+    value_field :hostname
+    value_field :ip
+    value_field :node_name
     object_field(:target_ref) { KubeDSL::DSL::V1::ObjectReference.new }
 
+    validates :hostname, field: { format: :string }, presence: false
+    validates :ip, field: { format: :string }, presence: false
+    validates :node_name, field: { format: :string }, presence: false
+    validates :target_ref, object: { kind_of: KubeDSL::DSL::V1::ObjectReference }
+
     def serialize
       {}.tap do |result|
         result[:hostname] = hostname

data/lib/kube-dsl/dsl/v1/endpoint_port.rb

@@ -1,6 +1,12 @@
 module KubeDSL::DSL::V1
   class EndpointPort < ::KubeDSL::DSLObject
-    value_fields :name, :port, :protocol
+    value_field :name
+    value_field :port
+    value_field :protocol
+
+    validates :name, field: { format: :string }, presence: false
+    validates :port, field: { format: :integer }, presence: false
+    validates :protocol, field: { format: :string }, presence: false
 
     def serialize
       {}.tap do |result|