kontena-cli 0.16.0.pre7 → 0.16.0.pre8

data/lib/kontena/cli/apps/restart_command.rb

@@ -15,7 +15,7 @@ module Kontena::Cli::Apps
     def execute
       require_config_file(filename)
 
-      @services = services_from_yaml(filename, service_list, service_prefix)
+      @services = services_from_yaml(filename, service_list, service_prefix, true)
       if services.size > 0
         restart_services(services)
       elsif !service_list.empty?

data/lib/kontena/cli/apps/scale_command.rb

@@ -16,7 +16,7 @@ module Kontena::Cli::Apps
 
     def execute
       require_config_file(filename)
-      yml_service = services_from_yaml(filename, [service], service_prefix)
+      yml_service = services_from_yaml(filename, [service], service_prefix, true)
       if yml_service[service]
         options = yml_service[service]
         exit_with_error("Service has already instances defined in #{filename}. Please update #{filename} and deploy service instead") if options['container_count']

data/lib/kontena/cli/apps/start_command.rb

@@ -16,7 +16,7 @@ module Kontena::Cli::Apps
     def execute
       require_config_file(filename)
 
-      @services = services_from_yaml(filename, service_list, service_prefix)
+      @services = services_from_yaml(filename, service_list, service_prefix, true)
       if services.size > 0
         start_services(services)
       elsif !service_list.empty?

data/lib/kontena/cli/apps/stop_command.rb

@@ -16,7 +16,7 @@ module Kontena::Cli::Apps
     def execute
       require_config_file(filename)
 
-      @services = services_from_yaml(filename, service_list, service_prefix)
+      @services = services_from_yaml(filename, service_list, service_prefix, true)
       if services.size > 0
         stop_services(services)
       elsif !service_list.empty?

data/lib/kontena/cli/apps/yaml/custom_validators/affinities_validator.rb

@@ -0,0 +1,19 @@
+module Kontena::Cli::Apps::YAML::Validations::CustomValidators
+  class AffinitiesValidator < HashValidator::Validator::Base
+    def initialize
+      super('valid_affinities')
+    end
+
+    def validate(key, value, validations, errors)
+      unless value.is_a?(Array)
+        errors[key] = 'affinity must be array'
+        return
+      end
+
+      invalid_formats = value.find_all { |a| !a.match(/(?<=\!|\=)=/) }
+      if invalid_formats.count > 0
+        errors[key] = "affinity contains invalid formats: #{invalid_formats.join(', ')}"
+      end
+    end
+  end
+end

data/lib/kontena/cli/apps/yaml/custom_validators/build_validator.rb

@@ -0,0 +1,22 @@
+module Kontena::Cli::Apps::YAML::Validations::CustomValidators
+  class BuildValidator < HashValidator::Validator::Base
+    def initialize
+      super('valid_build')
+    end
+
+    def validate(key, value, validations, errors)
+      unless value.is_a?(String) || value.is_a?(Hash)
+        errors[key] = 'build must be string or hash'
+        return
+      end
+      if value.is_a?(Hash)
+        build_validation = {
+          'context' => 'string',
+          'dockerfile' => HashValidator.optional('string'),
+          'args' => HashValidator.optional(-> (value) { value.is_a?(Array) || value.is_a?(Hash) })
+        }
+        HashValidator.validator_for(build_validation).validate(key, value, build_validation, errors)
+      end
+    end
+  end
+end

data/lib/kontena/cli/apps/yaml/custom_validators/extends_validator.rb

@@ -0,0 +1,21 @@
+module Kontena::Cli::Apps::YAML::Validations::CustomValidators
+  class ExtendsValidator < HashValidator::Validator::Base
+    def initialize
+      super('valid_extends')
+    end
+
+    def validate(key, value, validations, errors)
+      unless value.is_a?(String) || value.is_a?(Hash)
+        errors[key] = 'extends must be string or hash'
+        return
+      end
+      if value.is_a?(Hash)
+        extends_validation = {
+          'service' => 'string',
+          'file' => HashValidator.optional('string')
+        }
+        HashValidator.validator_for(extends_validation).validate(key, value, extends_validation, errors)
+      end
+    end
+  end
+end

data/lib/kontena/cli/apps/yaml/custom_validators/hooks_validator.rb

@@ -0,0 +1,54 @@
+module Kontena::Cli::Apps::YAML::Validations::CustomValidators
+  class HooksValidator < HashValidator::Validator::Base
+    def initialize
+      super('valid_hooks')
+    end
+
+    def validate(key, value, validations, errors)
+      unless value.is_a?(Hash)
+        errors[key] = 'hooks must be array'
+        return
+      end
+
+      if value['pre_build']
+        validate_pre_build_hooks(key, value['pre_build'], errors)
+      end
+
+      if value['post_start']
+        validate_post_start_hooks(key, value['post_start'], errors)
+      end
+    end
+
+    def validate_pre_build_hooks(key, pre_build_hooks, errors)
+      unless pre_build_hooks.is_a?(Array)
+        errors[key] = 'pre_build must be array'
+        return
+      end
+      pre_build_validation = {
+        'name' => 'string',
+        'cmd' => 'string'
+      }
+      validator = HashValidator.validator_for(pre_build_validation)
+      pre_build_hooks.each do |pre_build|
+        validator.validate('hooks.pre_build', pre_build, pre_build_validation, errors)
+      end
+    end
+
+    def validate_post_start_hooks(key, post_start_hooks, errors)
+      unless post_start_hooks.is_a?(Array)
+        errors[key] = 'post_start must be array'
+        return
+      end
+      post_start_validation = {
+        'name' => 'string',
+        'instances' => (-> (value) { value.is_a?(Integer) || value == '*' }),
+        'cmd' => 'string',
+        'oneshot' => HashValidator.optional('boolean')
+      }
+      validator = HashValidator.validator_for(post_start_validation)
+      post_start_hooks.each do |post_start|
+        validator.validate('hooks.post_start', post_start, post_start_validation, errors)
+      end
+    end
+  end
+end

data/lib/kontena/cli/apps/yaml/custom_validators/secrets_validator.rb

@@ -0,0 +1,22 @@
+module Kontena::Cli::Apps::YAML::Validations::CustomValidators
+  class SecretsValidator < HashValidator::Validator::Base
+    def initialize
+      super('valid_secrets')
+    end
+
+    def validate(key, value, validations, errors)
+      unless value.is_a?(Array)
+        errors[key] = 'secrets must be array'
+        return
+      end
+      secret_item_validation = {
+        'secret' => 'string',
+        'name' => 'string',
+        'type' => 'string'
+      }
+      value.each do |secret|
+        HashValidator.validator_for(secret_item_validation).validate(key, secret, secret_item_validation, errors)
+      end
+    end
+  end
+end

data/lib/kontena/cli/apps/yaml/validations.rb

@@ -1,97 +1,67 @@
 module Kontena::Cli::Apps::YAML
  module Validations
-
-   def append_common_validations(base)
-     base.optional('image').maybe(:str?)
-
-     base.optional('extends') { str? | type?(Hash) }
-     base.rule(when_extends_is_hash: ['extends']) do |extends|
-       extends.type?(Hash) > extends.schema do
-         required('service').filled(:str?)
-         optional('file').value(:str?)
-       end
-     end
-
-     base.optional('stateful') { bool? }
-     base.optional('affinity') { array? { each { format?(/(?<=\!|\=)=/) } } }
-     base.optional('cap_add').maybe(:array?)
-     base.optional('cap_drop').maybe(:array?)
-     base.optional('command').maybe(:str?)
-     base.optional('cpu_shares').maybe(:int?)
-     base.optional('external_links') { array? }
-     base.optional('mem_limit') { int? | str? }
-     base.optional('memswap_limit') { int? | str? }
-     base.optional('environment') { array? | type?(Hash) }
-     base.optional('env_file') { str? | array? }
-     base.optional('instances') { int? }
-     base.optional('links') { array? | empty? }
-     base.optional('ports').value(:array?)
-     base.optional('volumes').value(:array?)
-     base.optional('volumes_from').value(:array?)
-
-     base.optional('deploy').schema do
-       optional('strategy').value(included_in?: %w(ha daemon random))
-       optional('wait_for_port').value(:int?)
-       optional('min_health').value(:float?)
-       optional('interval').value(format?: /^\d+(min|h|d|)$/)
-     end
-
-     base.optional('hooks').schema do
-       optional('post_start').each do
-         required('name').filled
-         required('cmd').filled
-         required('instances') { int? | eql?('*') }
-         optional('oneshot').value(:bool?)
-       end
-
-       optional('pre_build').each do
-         required('cmd').filled
-       end
-     end
-
-     base.optional('secrets').each do
-       required('secret').filled
-       required('name').filled
-       required('type').filled
-     end
-     base.optional('health_check').schema do
-      required('protocol').filled(format?: /^(http|tcp)$/)
-      required('port').filled(:int?)
-      optional('uri').value(format?: /\/[\S]*/)
-      optional('timeout').value(:int?)
-      optional('interval').value(:int?)
-      optional('initial_delay').value(:int?)
-     end
+   module CustomValidators
+     require_relative 'custom_validators/affinities_validator'
+     require_relative 'custom_validators/build_validator'
+     require_relative 'custom_validators/extends_validator'
+     require_relative 'custom_validators/hooks_validator'
+     require_relative 'custom_validators/secrets_validator'
+     
+     HashValidator.append_validator(AffinitiesValidator.new)
+     HashValidator.append_validator(BuildValidator.new)
+     HashValidator.append_validator(ExtendsValidator.new)
+     HashValidator.append_validator(SecretsValidator.new)
+     HashValidator.append_validator(HooksValidator.new)
    end
 
-   ##
-   # @param [Hash] service_config
-   def validate_options(service_config)
-     @yaml_schema.call(service_config)
-   end
+   def common_validations
+     {
+        'image' => optional('string'), # it's optional because some base yml file might contain image option
+        'extends' => optional('valid_extends'),
+        'stateful' => optional('boolean'),
+        'affinity' => optional('valid_affinities'),
+        'cap_add' => optional('array'),
+        'cap_drop' => optional('array'),
+        'command' => optional('string'),
+        'cpu_shares' => optional('integer'),
+        'external_links' => optional('array'),
+        'mem_limit' => optional('string'),
+        'mem_swaplimit' => optional('string'),
+        'environment' => optional(-> (value) { value.is_a?(Array) || value.is_a?(Hash) }),
+        'env_file' => optional(-> (value) { value.is_a?(String) || value.is_a?(Array) }),
+        'instances' => optional('integer'),
+        'links' => optional(-> (value) { value.is_a?(Array) || value.nil? }),
+        'ports' => optional('array'),
+        'pid' => optional('string'),
+        'privileged' => optional('boolean'),
+        'user' => optional('string'),
+        'volumes' => optional('array'),
+        'volumes_from' => optional('array'),
+        'secrets' => optional('valid_secrets'),
+        'hooks' => optional('valid_hooks'),
+        'deploy' => optional({
+          'strategy' => optional(%w(ha daemon random)),
+          'wait_for_port' => optional('integer'),
+          'min_health' => optional('float'),
+          'interval' => optional(/^\d+(min|h|d|)$/)
+        }),
+        'health_check' => optional({
+          'protocol' => /^(http|tcp)$/,
+          'port' => 'integer',
+          'uri' => optional(/\/[\S]*/),
+          'timeout' => optional('integer'),
+          'interval' => optional('integer'),
+          'initial_delay' => optional('integer')
+        })
+      }
+    end
 
-   ##
-   # @param [Hash] service_config
-   # @return [Array<String>] errors
-   def validate_keys(service_config)
-     errors = {}
-     service_config.keys.each do |key|
-       error = validate_required(key)
-       errors[key] = error if error
-     end
-     errors
-   end
+    def optional(type)
+      HashValidator.optional(type)
+    end
 
-   ##
-   # @param [String] key
-   def validate_required(key)
-     if self.class::UNSUPPORTED_KEYS.include?(key)
-       ['unsupported option']
-     elsif !self.class::VALID_KEYS.include?(key)
-       ['invalid option']
-     else
-       nil
-     end
-   end
- end
+    def validate_options(service_config)
+      HashValidator.validate(service_config, @schema, true)
+    end
+  end
 end

data/lib/kontena/cli/apps/yaml/validator.rb

@@ -1,36 +1,17 @@
-require 'dry-validation'
+require 'hash_validator'
 module Kontena::Cli::Apps
   module YAML
     class Validator
       require_relative 'validations'
       include Validations
 
-      VALID_KEYS = %w(
-      affinity build dockerfile cap_add cap_drop command deploy env_file environment extends external_links
-      image links log_driver log_opt net pid ports volumes volumes_from cpu_shares
-      mem_limit memswap_limit privileged stateful user instances hooks secrets health_check
-      ).freeze
-
-      UNSUPPORTED_KEYS = %w(
-      cgroup_parent container_name devices depends_on dns dns_search tmpfs entrypoint
-      expose extra_hosts labels logging network_mode networks security_opt stop_signal ulimits volume_driver
-      cpu_quota cpuset domainname hostname ipc mac_address
-      read_only restart shm_size stdin_open tty working_dir
-      ).freeze
-
-      ##
-      # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       def initialize(need_image=false)
-        base = self
-        @yaml_schema = Dry::Validation.Schema do
-          base.append_common_validations(self)
-
-          optional('build').value(:str?)
-          optional('dockerfile').value(:str?)
-          optional('net').value(included_in?: (%w(host bridge)))
-          optional('log_driver').value(:str?)
-          optional('log_opts').value(type?: Hash)
-        end
+        @schema = common_validations
+        @schema['build'] = optional('string')
+        @schema['dockerfile'] = optional('string')
+        @schema['net'] = optional(%w(host bridge))
+        @schema['log_driver'] = optional('string')
+        @schema['log_opts'] = optional({})
       end
 
       ##
@@ -41,16 +22,13 @@ module Kontena::Cli::Apps
           errors: [],
           notifications: []
         }
-
         yaml.each do |service, options|
           unless options.is_a?(Hash)
-            result[:errors] << { service => { 'options' => 'must be a mapping not a string'}  }            
+            result[:errors] << { service => { 'options' => 'must be a mapping not a string'}  }
             next
           end
-          key_errors = validate_keys(options)
           option_errors = validate_options(options)
-          result[:errors] << { service => option_errors.messages } if option_errors.failure?
-          result[:notifications] << { service => key_errors } if key_errors.size > 0
+          result[:errors] << { service => option_errors.errors } unless option_errors.valid?
         end
         result
       end

data/lib/kontena/cli/apps/yaml/validator_v2.rb

@@ -1,4 +1,4 @@
-require 'dry-validation'
+require 'hash_validator'
 require_relative 'validator'
 
 module Kontena::Cli::Apps
@@ -7,45 +7,20 @@ module Kontena::Cli::Apps
       require_relative 'validations'
       include Validations
 
-      VALID_KEYS = %w(
-      affinity build cap_add cap_drop command deploy depends_on env_file environment extends external_links
-      image links logging network_mode pid ports volumes volumes_from cpu_shares
-      mem_limit memswap_limit privileged stateful user instances hooks secrets health_check
-      ).freeze
-
-      UNSUPPORTED_KEYS = %w(
-      cgroup_parent container_name devices dns dns_search tmpfs entrypoint
-      expose extra_hosts labels log_driver log_opt net networks security_opt stop_signal ulimits volume_driver
-      cpu_quota cpuset domainname hostname ipc mac_address
-      read_only restart shm_size stdin_open tty working_dir
-      ).freeze
-
-      ##
-      # rubocop:disable Metrics/MethodLength,Metrics/AbcSize
       def initialize
-        base = self
-        @yaml_schema = Dry::Validation.Schema do
-          base.append_common_validations(self)
-          optional('build') { str? | type?(Hash) }
-
-          rule(build_hash: ['build']) do |build|
-            build.type?(Hash) > build.schema do
-              required('context').filled
-              optional('dockerfile').value(:str?)
-              optional('args') { array? | type?(Hash) }
-            end
-          end
-          optional('depends_on').value(:array?)
-          optional('network_mode').value(included_in?: (%w(host bridge)))
-          optional('logging').schema do
-            optional('driver').value(:str?)
-            optional('options') { type?(Hash) }
-          end
-        end
+        @schema = common_validations
+        @schema['build'] = optional('valid_build')
+        @schema['depends_on'] = optional('array')
+        @schema['network_mode'] = optional(%w(host bridge))
+        @schema['logging'] = optional({
+          'driver' => optional('string'),
+          'options' => optional(-> (value) { value.is_a?(Hash) })
+          })
       end
 
       ##
       # @param [Hash] yaml
+      # @param [TrueClass|FalseClass] strict
       # @return [Array] validation_errors
       def validate(yaml)
         result = {
@@ -53,15 +28,13 @@ module Kontena::Cli::Apps
           notifications: []
         }
         if yaml.key?('services')
-          yaml['services'].each do |service, options|            
+          yaml['services'].each do |service, options|
             unless options.is_a?(Hash)
-              result[:errors] << { service => { 'options' => 'must be a mapping not a string'} }
+              result[:errors] << { service => { 'options' => 'must be a mapping not a string'}  }
               next
             end
-            key_errors = validate_keys(options)
             option_errors = validate_options(options)
-            result[:errors] << { service => option_errors.messages } if option_errors.failure?
-            result[:notifications] << { service => key_errors } if key_errors.size > 0
+            result[:errors] << { service => option_errors.errors } unless option_errors.valid?
           end
         else
           result[:errors] << { 'file' => 'services missing' }