kontena-cli 1.2.0.pre1 → 1.2.0.pre2

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

@@ -1,4 +1,5 @@
-require_relative '../../../util'
+require 'kontena/cli/common'
+require 'kontena/util'
 
 module Kontena::Cli::Stacks
   module YAML
@@ -73,8 +74,8 @@ module Kontena::Cli::Stacks
             )
           )
         )
-      rescue Psych::SyntaxError => e
-        raise "Error while parsing #{file}".colorize(:red)+ " " + e.message
+      rescue Psych::SyntaxError => ex
+        raise ex, "Error while parsing #{file} : #{ex.message}"
       end
 
       def fully_interpolated_yaml
@@ -92,8 +93,8 @@ module Kontena::Cli::Stacks
             )
           )
         )
-      rescue Psych::SyntaxError => e
-        raise "Error while parsing #{file}".colorize(:red)+ " " + e.message
+      rescue Psych::SyntaxError => ex
+        raise ex, "Error while parsing #{file} : #{ex.message}"
       end
 
       def raw_yaml
@@ -141,12 +142,13 @@ module Kontena::Cli::Stacks
           result[:expose]        = fully_interpolated_yaml['expose']
           result[:errors]        = errors unless skip_validation?
           result[:notifications] = notifications
-          result[:services]      = errors.count == 0 ? parse_services(service_name) : {}
+          result[:services]      = errors.count.zero? ? parse_services(service_name) : {}
           unless skip_variables?
             result[:variables]     = variables.to_h(values_only: true).reject do |k,_|
               k == 'GRID' || k == 'STACK' || variables.option(k).to.has_key?(:vault) || variables.option(k).from.has_key?(:vault)
             end
           end
+          result[:volumes]       = errors.count.zero? ? parse_volumes : {}
         end
         result
       end
@@ -208,6 +210,19 @@ module Kontena::Cli::Stacks
         @validator ||= YAML::ValidatorV3.new
       end
 
+      def parse_volumes
+        volumes.each do |name, config|
+          if process_hash?(config)
+            volumes[name].delete('only_if')
+            volumes[name].delete('skip_if')
+            volumes[name] = process_volume(config)
+          else
+            volumes.delete(name)
+          end
+        end
+        volumes
+      end
+
       ##
       # @param [String] service_name - optional service to parse
       # @return [Hash]
@@ -264,9 +279,17 @@ module Kontena::Cli::Stacks
         service_config
       end
 
+      def process_volume(volume_config)
+        volume_config
+      end
+
+      def volumes
+        @volumes ||= fully_interpolated_yaml['volumes'] || {}
+      end
+
       # @return [Hash] - services from YAML file
       def services
-        @services ||= fully_interpolated_yaml['services']
+        @services ||= fully_interpolated_yaml['services'] || {}
       end
 
       def from_external_file(filename, service_name)

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

@@ -69,5 +69,15 @@ module Kontena::Cli::Stacks::YAML
     def validate_options(service_config)
       HashValidator.validate(service_config, @schema, true)
     end
+
+    def validate_volume_options(volume_config)
+      HashValidator.validate(volume_config, volume_schema, true)
+    end
+
+    def volume_schema
+      {
+        'external' => optional(-> (value) { value.is_a?(TrueClass) || (value.is_a?(Hash) && value['name'].is_a?(String)) })
+      }
+    end
   end
 end

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

@@ -6,6 +6,19 @@ module Kontena::Cli::Stacks
       require_relative 'validations'
       include Validations
 
+      KNOWN_TOP_LEVEL_KEYS = %w(
+        services
+        errors
+        volumes
+        networks
+        variables
+        stack
+        version
+        data
+        description
+        expose
+      )
+
       def initialize
         @schema = common_validations
         @schema['build'] = optional('stacks_valid_build')
@@ -27,24 +40,91 @@ module Kontena::Cli::Stacks
           errors: [],
           notifications: []
         }
+
+        result[:notifications] += (yaml.keys - KNOWN_TOP_LEVEL_KEYS).map do |key|
+          { key => "unknown top level key" }
+        end
+
         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
+          if yaml['services'].is_a?(Hash)
+            yaml['services'].each do |service, options|
+              unless options.is_a?(Hash)
+                result[:errors] << { 'services' => { service => { 'options' => "must be a mapping not a #{options.class}"}  } }
+                next
+              end
+              option_errors = validate_options(options)
+              result[:errors] << { 'services' => { service => option_errors.errors } } unless option_errors.valid?
+              if options['volumes']
+                mount_points = options['volumes'].inject(Hash.new(0)) { |hsh, vol| hsh[vol.split(':').last] += 1; hsh }
+                mount_points.each do |mount_point, occurences|
+                  next unless occurences > 1
+                  result[:errors] << { 'services' => { service => { 'volumes' => { mount_point => "mount point defined #{occurences} times" } } } }
+                end
+
+                options['volumes'].each do |volume|
+                  if volume.include?(':')
+                    volume_name, mount_point = volume.split(':', 2)
+                    unless mount_point
+                      result[:errors] << { 'services' => { service => { 'volumes' => { volume => 'mount point missing' } } } }
+                    end
+                    if volume_name
+                      if yaml.key?('volumes')
+                        unless yaml['volumes'][volume_name]
+                          result[:errors] << { 'services' => { service => { 'volumes' => { volume_name => 'not found in top level volumes list' } } } }
+                        end
+                      else
+                        result[:errors] << { 'services' => { service => { 'volumes' => { volume => 'defines volume name, but file does not contain volumes definitions' } } } }
+                      end
+                    end
+                  end
+                end
+              end
             end
-            option_errors = validate_options(options)
-            result[:errors] << { service => option_errors.errors } unless option_errors.valid?
+          else
+            result[:errors] << { 'services' => "must be a mapping, not #{yaml['services'].class}" }
           end
         else
-          result[:errors] << { 'file' => 'services missing' }
+          result[:notifications] << { 'file' => 'does not define any services' }
         end
+
         if yaml.key?('volumes')
-          result[:notifications] << { 'volumes' => 'Kontena does not support volumes yet. To persist data just define service as stateful (stateful: true)' }
+          if yaml['volumes'].is_a?(Hash)
+            yaml['volumes'].each do |volume, options|
+              if options.is_a?(Hash)
+                option_errors = validate_volume_options(options)
+                if option_errors.valid?
+                  if !options.key?('driver') && options.key?('driver_opts')
+                    result[:errors] << { 'volumes' => { volume => { 'driver_opts' => 'defined without defining driver' } } }
+                  end
+                  if options.key?('external')
+                    unless options['external'].is_a?(FalseClass)
+                      ['driver', 'driver_opts', 'scope'].each do |key|
+                        result[:errors] << { 'volumes' => { volume => { key => 'specified together with external' } } } if options.key?(key)
+                      end
+                    end
+                  end
+                  if options.key?('driver') && !options.key?('scope')
+                    result[:errors] << { 'volumes' => { volume => { 'scope' => 'required value missing' } } }
+                  end
+                else
+                  result[:errors] << { 'volumes' => { volume => option_errors.errors } }
+                end
+              else
+                result[:errors] << { 'volumes' => { volume => { 'options' => "must be a mapping, not #{options.class}" } } }
+              end
+            end
+          else
+            result[:errors] << { 'volumes' => "must be a mapping, not #{yaml['volumes'].class}" }
+          end
         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
+
+        if (yaml['volumes'].nil? || yaml['volumes'].empty?) && (yaml['services'].nil? || yaml['services'].empty?)
+          result[:errors] << { 'file' => 'does not list any services or volumes' }
+        end
         result
       end
     end

data/lib/kontena/client.rb

@@ -47,7 +47,7 @@ module Kontena
       uri = URI.parse(@api_url)
       @host = uri.host
 
-      @logger = Logger.new(ENV["DEBUG"] ? STDERR : STDOUT)
+      @logger = Logger.new(ENV["DEBUG"] ? $stderr : $stdout)
       @logger.level = ENV["DEBUG"].nil? ? Logger::INFO : Logger::DEBUG
       @logger.progname = 'CLIENT'
 
@@ -139,8 +139,8 @@ module Kontena
       logger.debug "Requesting user info from #{final_path}"
       request(path: final_path)
       true
-    rescue
-      logger.debug "Authentication verification exception: #{$!} #{$!.message} #{$!.backtrace}"
+    rescue => ex
+      logger.debug "Authentication verification exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
       false
     end
 
@@ -172,8 +172,8 @@ module Kontena
     # @return [String] version_string
     def server_version
       request(auth: false, expects: 200)['version']
-    rescue
-      logger.debug "Server version exception: #{$!} #{$!.message}"
+    rescue => ex
+      logger.debug "Server version exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
       nil
     end
 
@@ -369,8 +369,8 @@ module Kontena
       else
         {}
       end
-    rescue
-      logger.debug "Access token refresh exception: #{$!} - #{$!.message} #{$!.backtrace}"
+    rescue => ex
+      logger.debug "Access token refresh exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
       false
     end
 
@@ -418,8 +418,8 @@ module Kontena
         logger.debug "Got null or bad response to refresh request: #{last_response.inspect}"
         false
       end
-    rescue
-      logger.debug "Access token refresh exception: #{$!} - #{$!.message} #{$!.backtrace}"
+    rescue => ex
+      logger.debug "Access token refresh exception: #{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}"
       false
     end
 
@@ -509,8 +509,8 @@ module Kontena
     # @return [Hash,Object,NilClass]
     def parse_json(json)
       JSON.parse(json)
-    rescue
-      logger.debug "JSON parse exception: #{$!} : #{$!.message}"
+    rescue => ex
+      logger.debug "JSON parse exception: #{ex.class.name} : #{ex.message}"
       nil
     end
 
@@ -531,7 +531,9 @@ module Kontena
     def handle_error_response(response)
       data = parse_response(response)
 
-      if data.is_a?(Hash) && data.has_key?('error')
+      if data.is_a?(Hash) && data.has_key?('error') && data['error'].is_a?(Hash)
+        raise Kontena::Errors::StandardErrorHash.new(response.status, response.reason_phrase, data['error'])
+      elsif data.is_a?(Hash) && data.has_key?('error')
         raise Kontena::Errors::StandardError.new(response.status, data['error'])
       elsif data.is_a?(String) && !data.empty?
         raise Kontena::Errors::StandardError.new(response.status, data)

data/lib/kontena/command.rb

@@ -178,7 +178,7 @@ class Kontena::Command < Clamp::Command
   end
 
   def run(arguments)
-    ENV["DEBUG"] && STDERR.puts("Running #{self} -- callback matcher = '#{self.class.callback_matcher.nil? ? "nil" : self.class.callback_matcher.map(&:to_s).join(' ')}'")
+    ENV["DEBUG"] && $stderr.puts("Running #{self} -- callback matcher = '#{self.class.callback_matcher.nil? ? "nil" : self.class.callback_matcher.map(&:to_s).join(' ')}'")
     @arguments = arguments
 
     run_callbacks :before_parse unless help_requested?
@@ -202,29 +202,26 @@ class Kontena::Command < Clamp::Command
     run_callbacks :after unless help_requested?
     exit(@exit_code) if @exit_code.to_i > 0
     @result
-  rescue Excon::Errors::SocketError => exc
-    if exc.message.include?('Unable to verify certificate')
+  rescue Excon::Errors::SocketError => ex
+    if ex.message.include?('Unable to verify certificate')
       $stderr.puts " [#{Kontena.pastel.red('error')}] The server uses a certificate signed by an unknown authority."
       $stderr.puts "         You can trust this server by copying server CA pem file to: #{Kontena.pastel.yellow("~/.kontena/certs/<hostname>.pem")}"
       $stderr.puts "         Protip: you can bypass the certificate check by setting #{Kontena.pastel.yellow('SSL_IGNORE_ERRORS=true')} env variable, but any data you send to the server could be intercepted by others."
       abort
     else
-      abort(exc.message)
+      abort(ex.message)
     end
-  rescue Kontena::Errors::StandardError => exc
-    raise exc if ENV['DEBUG']
-    $stderr.puts " [#{Kontena.pastel.red('error')}] #{exc.message}"
-    abort
+  rescue Kontena::Errors::StandardError => ex
+    raise ex if ENV['DEBUG']
+    abort(" [#{Kontena.pastel.red('error')}] #{ex.class.name} : #{ex.message}")
   rescue Errno::EPIPE
     # If user is piping the command outputs to some other command that might exit before CLI has outputted everything
     abort
   rescue Clamp::HelpWanted, Clamp::UsageError
     raise
-  rescue => exc
-    raise exc if ENV['DEBUG']
-    $stderr.puts " [#{Kontena.pastel.red('error')}] #{exc.message}"
-    $stderr.puts "         Rerun the command with environment DEBUG=true set to get the full exception"
-    abort
+  rescue => ex
+    raise ex if ENV['DEBUG']
+    abort(" [#{Kontena.pastel.red('error')}] #{ex.class.name} : #{ex.message}\n         Rerun the command with environment DEBUG=true set to get the full exception")
   end
 end
 

data/lib/kontena/errors.rb

@@ -4,10 +4,46 @@ module Kontena
 
       attr_reader :status
 
+      # @param status [Fixnum] HTTP response status
+      # @param message [String] short error message
       def initialize(status, message)
         @status = status
         super(message)
       end
     end
+
+    # The normal {error: {foo: "invalid foo"}} error response format used by the API
+    class StandardErrorHash < StandardError
+      attr_reader :errors
+
+      # @param errors [Hash]
+      def initialize(status, message, errors)
+        super(status, message)
+        @errors = errors
+      end
+
+      # Render as indented YAML
+      def errors_message(indent: "\t")
+        @errors.to_yaml.lines[1..-1].map{|line| "#{indent}#{line}" }.join
+      end
+
+      # Render the full multi-line message including YAML-formatted errors
+      def message
+        "#{super}:\n#{errors_message}"
+      end
+    end
+
+    # An error with an array of additional details
+    class StandardErrorArray < Kontena::Errors::StandardError
+      # @param details [Array<String>]
+      def initialize(status, message, details)
+        super(status, message)
+        @details = details
+      end
+
+      def message
+        "#{super}:\n#{@details.map{|msg| "\t" + msg}.join("\n")}"
+      end
+    end
   end
 end

data/lib/kontena/plugin_manager.rb

@@ -171,23 +171,21 @@ module Kontena
                 plugins << spec
               else
                 plugin_name = spec.name.sub('kontena-plugin-', '')
-                STDERR.puts " [#{Kontena.pastel.red('error')}] Plugin #{Kontena.pastel.cyan(plugin_name)} (#{spec.version}) is not compatible with the current cli version."
-                STDERR.puts "         To update the plugin, run 'kontena plugin install #{plugin_name}'"
-              end
-            rescue LoadError => exc
-              STDERR.puts " [#{Kontena.pastel.red('error')}] Failed to load plugin: #{spec.name}"
-              if ENV['DEBUG']
-                STDERR.puts exc.message
-                STDERR.puts exc.backtrace.join("\n")
+                $stderr.puts " [#{Kontena.pastel.red('error')}] Plugin #{Kontena.pastel.cyan(plugin_name)} (#{spec.version}) is not compatible with the current cli version."
+                $stderr.puts "         To update the plugin, run 'kontena plugin install #{plugin_name}'"
               end
+            rescue LoadError => ex
+              $stderr.puts " [#{Kontena.pastel.red('error')}] Failed to load plugin: #{spec.name}"
+              ENV['DEBUG'] && $stderr.puts("#{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}")
               exit 1
             end
           end
         end
       end
       plugins
-    rescue => exc
-      STDERR.puts exc.message
+    rescue => ex
+      $stderr.puts Kontena.pastel.red(ex.message)
+      ENV['DEBUG'] && $stderr.puts("#{ex.class.name} : #{ex.message}\n#{ex.backtrace.join("\n  ")}")
     end
 
     def prefix(plugin_name)

data/lib/kontena/stacks_cache.rb

@@ -69,7 +69,7 @@ module Kontena
       end
 
       def dputs(msg)
-        ENV["DEBUG"] && STDERR.puts(msg)
+        ENV["DEBUG"] && $stderr.puts(msg)
       end
 
       def cache(stack, version = nil)

data/lib/kontena_cli.rb

@@ -19,11 +19,11 @@ module Kontena
     ENV["DEBUG"] && puts("Command completed, result: #{result.inspect} status: 0")
     return 0 if returning == :status
     return result if returning == :result
-  rescue SystemExit
-    ENV["DEBUG"] && STDERR.puts("Command completed with failure, result: #{result.inspect} status: #{$!.status}")
+  rescue SystemExit => ex
+    ENV["DEBUG"] && $stderr.puts("Command completed with failure, result: #{result.inspect} status: #{ex.status}")
     returning == :status ? $!.status : nil
-  rescue
-    ENV["DEBUG"] && STDERR.puts("Command raised #{$!} with message: #{$!.message}\n  #{$!.backtrace.join("  \n")}")
+  rescue => ex
+    ENV["DEBUG"] && $stderr.puts("Command raised #{ex} with message: #{ex.message}\n#{ex.backtrace.join("\n  ")}")
     returning == :status ? 1 : nil
   end
 
@@ -95,7 +95,7 @@ require 'retriable'
 Retriable.configure do |c|
   c.on_retry = Proc.new do |exception, try, elapsed_time, next_interval|
     return true unless ENV["DEBUG"]
-    puts "Retriable retry: #{try} - Exception: #{exception} - #{exception.message}. Elapsed: #{elapsed_time} Next interval: #{next_interval}"
+    puts "Retriable retry: #{try} - Exception: #{exception.class.name} - #{exception.message}. Elapsed: #{elapsed_time} Next interval: #{next_interval}"
   end
 end