kontena-cli 0.16.3 → 0.17.0.pre1

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

@@ -0,0 +1,22 @@
+module Kontena::Cli::Stacks::YAML::Validations::CustomValidators
+  class BuildValidator < HashValidator::Validator::Base
+    def initialize
+      super('stacks_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/stacks/yaml/custom_validators/extends_validator.rb

@@ -0,0 +1,21 @@
+module Kontena::Cli::Stacks::YAML::Validations::CustomValidators
+  class ExtendsValidator < HashValidator::Validator::Base
+    def initialize
+      super('stacks_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/stacks/yaml/custom_validators/hooks_validator.rb

@@ -0,0 +1,54 @@
+module Kontena::Cli::Stacks::YAML::Validations::CustomValidators
+  class HooksValidator < HashValidator::Validator::Base
+    def initialize
+      super('stacks_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/stacks/yaml/custom_validators/secrets_validator.rb

@@ -0,0 +1,22 @@
+module Kontena::Cli::Stacks::YAML::Validations::CustomValidators
+  class SecretsValidator < HashValidator::Validator::Base
+    def initialize
+      super('stacks_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/stacks/yaml/reader.rb

@@ -0,0 +1,219 @@
+require 'yaml'
+require_relative 'service_extender'
+require_relative 'validator_v3'
+require_relative '../../../util'
+
+module Kontena::Cli::Stacks
+  module YAML
+    class Reader
+      include Kontena::Util
+      attr_reader :yaml, :file, :errors, :notifications
+
+      def initialize(file, skip_validation = false)
+        @file = file
+        @errors = []
+        @notifications = []
+        @skip_validation = skip_validation
+        parse_yaml
+      end
+
+      ##
+      # @param [String] service_name
+      # @return [Hash]
+      def execute(service_name = nil)
+        result = {}
+        Dir.chdir(File.dirname(File.expand_path(file))) do
+          result[:version] = yaml['version'] || '1'
+          result[:stack] = yaml['stack']
+          result[:name] = self.stack_name
+          result[:expose] = yaml['expose']
+          result[:errors] = errors
+          result[:notifications] = notifications
+          result[:services] = parse_services(service_name) unless errors.count > 0
+        end
+        result
+      end
+
+      def reload
+        @errors = []
+        @notifications = []
+        parse_yaml
+      end
+
+      def stack_name
+        yaml['stack'].split('/').last if yaml['stack']
+      end
+
+      # @return [String]
+      def raw
+        read_content
+      end
+
+      private
+
+      def parse_yaml
+        load_yaml
+        validate unless skip_validation?
+      end
+
+      def read_content
+        @content ||= File.read(File.expand_path(file))
+      end
+
+      def load_yaml
+        content = read_content.dup
+        interpolate(content)
+        replace_dollar_dollars(content)
+        begin
+          @yaml = ::YAML.load(content)
+        rescue Psych::SyntaxError => e
+          raise "Error while parsing #{file}".colorize(:red)+ " "+e.message
+        end
+      end
+
+      # @return [Array] array of validation errors
+      def validate
+        result = validator.validate(yaml)
+        store_failures(result)
+        result
+      end
+
+      def skip_validation?
+        @skip_validation == true
+      end
+
+      def store_failures(data)
+        errors << { file => data[:errors] } unless data[:errors].empty?
+        notifications << { file => data[:notifications] } unless data[:notifications].empty?
+      end
+
+      # @return [Kontena::Cli::Stacks::YAML::ValidatorV3]
+      def validator
+        @validator ||= YAML::ValidatorV3.new
+      end
+
+      ##
+      # @param [String] service_name - optional service to parse
+      # @return [Hash]
+      def parse_services(service_name = nil)
+        if service_name.nil?
+          services.each do |name, config|
+            services[name] = process_config(config)
+          end
+          services
+        else
+          raise ("Service '#{service_name}' not found in #{file}") unless services.key?(service_name)
+          process_config(services[service_name])
+        end
+      end
+
+      # @param [Hash] service_config
+      def process_config(service_config)
+        normalize_env_vars(service_config)
+        merge_env_vars(service_config)
+        expand_build_context(service_config)
+        normalize_build_args(service_config)
+        service_config = extend_config(service_config) if service_config.key?('extends')
+        service_config
+      end
+
+      # @return [Hash] - services from YAML file
+      def services
+        yaml['services']
+      end
+
+      ##
+      # @param [String] text - content of YAML file
+      def interpolate(text)
+        text.gsub!(/(?<!\$)\$(?!\$)\{?\w+\}?/) do |v| # searches $VAR and ${VAR} and not $$VAR
+          var = v.tr('${}', '')
+          puts "The #{var} is not set. Substituting an empty string." if !ENV.key?(var) && !skip_validation?
+          ENV[var] # replace with equivalent ENV variables
+        end
+      end
+
+      ##
+      # @param [String] text - content of yaml file
+      def replace_dollar_dollars(text)
+        text.gsub!('$$', '$')
+      end
+
+      # @param [Hash] service_config
+      # @return [Hash] updated service config
+      def extend_config(service_config)
+        extended_service = extended_service(service_config['extends'])
+        return unless extended_service
+        filename = service_config['extends']['file']
+        if filename
+          parent_config = from_external_file(filename, extended_service)
+        else
+          raise ("Service '#{extended_service}' not found in #{file}") unless services.key?(extended_service)
+          parent_config = process_config(services[extended_service])
+        end
+        ServiceExtender.new(service_config).extend_from(parent_config)
+      end
+
+      def extended_service(extend_config)
+        if extend_config.is_a?(Hash)
+          extend_config['service']
+        elsif extend_config.is_a?(String)
+          extend_config
+        else
+          nil
+        end
+      end
+
+      def from_external_file(filename, service_name)
+        outcome = Reader.new(filename, @skip_validation).execute(service_name)
+        errors.concat outcome[:errors] unless errors.any? { |item| item.key?(filename) }
+        notifications.concat outcome[:notifications] unless notifications.any? { |item| item.key?(filename) }
+        outcome[:services]
+      end
+
+      # @param [Hash] options - service config
+      def normalize_env_vars(options)
+        if options['environment'].is_a?(Hash)
+          options['environment'] = options['environment'].map { |k, v| "#{k}=#{v}" }
+        end
+      end
+
+      # @param [Hash] options
+      def merge_env_vars(options)
+        return options['environment'] unless options['env_file']
+
+        options['env_file'] = [options['env_file']] if options['env_file'].is_a?(String)
+        options['environment'] = [] unless options['environment']
+        options['env_file'].each do |env_file|
+          options['environment'].concat(read_env_file(env_file))
+        end
+        options.delete('env_file')
+        options['environment'].uniq! { |s| s.split('=').first }
+      end
+
+      # @param [String] path
+      def read_env_file(path)
+        File.readlines(path).map { |line| line.strip }.delete_if { |line| line.start_with?('#') || line.empty? }
+      end
+
+      def expand_build_context(options)
+        if options['build'].is_a?(String)
+          options['build'] = File.expand_path(options['build'])
+        elsif context = options.dig('build', 'context')
+          options['build']['context'] = File.expand_path(context)
+        end
+      end
+
+      # @param [Hash] options - service config
+      def normalize_build_args(options)
+        if safe_dig(options, 'build', 'args').is_a?(Array)
+          args = options['build']['args'].dup
+          options['build']['args'] = {}
+          args.each do |arg|
+            k,v = arg.split('=')
+            options['build']['args'][k] = v
+          end
+        end
+      end
+    end
+  end
+end

data/lib/kontena/cli/stacks/yaml/service_extender.rb

@@ -0,0 +1,78 @@
+require 'yaml'
+require_relative '../../../util'
+
+module Kontena::Cli::Stacks
+  module YAML
+    class ServiceExtender
+      include Kontena::Util
+      attr_reader :service_config
+
+      # @param [Hash] service_config
+      def initialize(service_config)
+        @service_config = service_config
+      end
+
+      # @param [Hash] from
+      # @return [Hash]
+      def extend_from(from)
+        service_config['environment'] = extend_env_vars(
+          from['environment'],
+          service_config['environment']
+        )
+        service_config['secrets'] = extend_secrets(
+          from['secrets'],
+          service_config['secrets']
+        )
+        build_args = extend_build_args(safe_dig(from, 'build', 'args'), safe_dig(service_config, 'build', 'args'))
+        unless build_args.empty?
+          service_config['build'] = {} unless service_config['build']
+          service_config['build']['args'] = build_args
+        end
+
+        from.merge(service_config)
+      end
+
+      private
+
+      # @param [Array] from
+      # @param [Array] to
+      # @return [Array]
+      def extend_env_vars(from, to)
+        env_vars = to || []
+        if from
+          from.each do |env|
+            env_vars << env unless to && to.find do |key|
+              key.split('=').first == env.split('=').first
+            end
+          end
+        end
+        env_vars
+      end
+
+      # @param [Array] from
+      # @param [Array] to
+      # @return [Array]
+      def extend_secrets(from, to)
+        secrets = to || []
+        if from
+          from.each do |from_secret|
+            secrets << from_secret unless to && to.any? do |to_secret|
+              to_secret['secret'] == from_secret['secret']
+            end
+          end
+        end
+        secrets
+      end
+
+      def extend_build_args(from, to)
+        args = to || {}
+        if from
+          from.each do |k,v|
+            args[k] = v unless args.has_key?(k)
+          end
+        end
+        args
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Kontena::Cli::Stacks::YAML
+ module Validations
+   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'
+
+     def self.load
+       return if @loaded
+       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)
+       @loaded = true
+     end
+   end
+
+   def common_validations
+     {
+        'image' => optional('string'), # it's optional because some base yml file might contain image option
+        'extends' => optional('stacks_valid_extends'),
+        'stateful' => optional('boolean'),
+        'affinity' => optional('stacks_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('stacks_valid_secrets'),
+        'hooks' => optional('stacks_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
+
+    def optional(type)
+      HashValidator.optional(type)
+    end
+
+    def validate_options(service_config)
+      HashValidator.validate(service_config, @schema, true)
+    end
+  end
+end