kontena-cli 1.4.0.pre6 → 1.4.0.pre7

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

@@ -1,213 +0,0 @@
-require_relative 'service_extender'
-require_relative 'validator'
-require_relative 'validator_v2'
-require_relative '../../../util'
-
-module Kontena::Cli::Apps
-  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
-        load_yaml
-        validate unless skip_validation?
-      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[:name] = yaml['name']
-          result[:errors] = errors
-          result[:notifications] = notifications
-          result[:services] = errors.count == 0 ? parse_services(service_name) : {}
-        end
-        result
-      end
-
-      def stack_name
-        yaml['name'] if v2?
-      end
-
-      ##
-      # @return [true|false]
-      def v2?
-        yaml['version'].to_s == '2'
-      end
-
-      private
-
-      def load_yaml
-        content = File.read(File.expand_path(file))
-        content = content % { project: ENV['project'], grid: ENV['grid'] }
-        interpolate(content)
-        replace_dollar_dollars(content)
-        begin
-          @yaml = ::YAML.safe_load(content)
-        rescue Psych::SyntaxError => ex
-          raise ex.class, "Error while parsing #{file} : #{ex.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::Apps::YAML::Validator]
-      def validator
-        if @validator.nil?
-          validator_klass = v2? ? YAML::ValidatorV2 : YAML::Validator
-          @validator = validator_klass.new
-        end
-        @validator
-      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
-        if v2?
-          yaml['services']
-        else
-          yaml
-        end
-      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(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 v2? && 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/apps/yaml/service_extender.rb

@@ -1,77 +0,0 @@
-require_relative '../../../util'
-
-module Kontena::Cli::Apps
-  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)
-        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/apps/yaml/validations.rb

@@ -1,71 +0,0 @@
-module Kontena::Cli::Apps::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('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
-
-    def optional(type)
-      HashValidator.optional(type)
-    end
-
-    def validate_options(service_config)
-      HashValidator.validate(service_config, @schema, true)
-    end
-  end
-end

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

@@ -1,38 +0,0 @@
-require 'hash_validator'
-module Kontena::Cli::Apps
-  module YAML
-    class Validator
-      require_relative 'validations'
-      include Validations
-
-      def initialize(need_image=false)
-        @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({})
-        Validations::CustomValidators.load
-      end
-
-      ##
-      # @param [Hash] yaml
-      # @return [Array] validation_errors
-      def validate(yaml)
-        result = {
-          errors: [],
-          notifications: []
-        }
-        yaml.each do |service, options|
-          unless options.is_a?(Hash)
-            result[:errors] << { service => { 'options' => 'must be a mapping not a string'}  }
-            next
-          end
-          option_errors = validate_options(options)
-          result[:errors] << { service => option_errors.errors } unless option_errors.valid?
-        end
-        result
-      end
-    end
-  end
-end

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

@@ -1,53 +0,0 @@
-require 'hash_validator'
-require_relative 'validator'
-
-module Kontena::Cli::Apps
-  module YAML
-    class ValidatorV2
-      require_relative 'validations'
-      include Validations
-
-      def initialize
-        @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) })
-          })
-        Validations::CustomValidators.load
-      end
-
-      ##
-      # @param [Hash] yaml
-      # @param [TrueClass|FalseClass] strict
-      # @return [Array] validation_errors
-      def validate(yaml)
-        result = {
-          errors: [],
-          notifications: []
-        }
-        if yaml.key?('services')
-          yaml['services'].each do |service, options|
-            unless options.is_a?(Hash)
-              result[:errors] << { service => { 'options' => 'must be a mapping not a string'}  }
-              next
-            end
-            option_errors = validate_options(options)
-            result[:errors] << { service => option_errors.errors } unless option_errors.valid?
-          end
-        else
-          result[:errors] << { 'file' => 'services missing' }
-        end
-        if yaml.key?('volumes')
-          result[:notifications] << { 'volumes' => 'Kontena does not support volumes yet. To persist data just define service as stateful (stateful: true)' }
-        end
-        if yaml.key?('networks')
-          result[:notifications] << { 'networks' => 'Kontena does not support multiple networks yet. You can reference services with Kontena\'s internal DNS (service_name.kontena.local)' }
-        end
-        result
-      end
-    end
-  end
-end