kontena-cli 1.4.0.pre6 → 1.4.0.pre7

data/lib/kontena/cli/plugins/show_command.rb

@@ -0,0 +1,17 @@
+require 'kontena/plugin_manager'
+
+module Kontena::Cli::Plugins
+  class ShowCommand < Kontena::Command
+    parameter 'NAME', 'Plugin name' do |name|
+      "kontena-plugin-#{name}"
+    end
+
+    def execute
+      require 'yaml'
+      plug = Gem::Specification.find { |g| g.name == name }
+      out = {}
+      out[:path] = plug.gem_dir
+      puts out.to_yaml
+    end
+  end
+end

data/lib/kontena/cli/plugins/uninstall_command.rb

@@ -1,26 +1,22 @@
-require 'open3'
+require 'kontena/plugin_manager'
 
 module Kontena::Cli::Plugins
   class UninstallCommand < Kontena::Command
     include Kontena::Util
     include Kontena::Cli::Common
+    include Kontena::PluginManager::Common
 
     parameter 'NAME', 'Plugin name'
 
-    option "--force", :flag, "Force remove", default: false, attribute_name: :forced
+    def uninstaller
+      Kontena::PluginManager::Uninstaller.new(name)
+    end
 
     def execute
-      exit_with_error "Plugin #{pastel.cyan(name)} is not installed" unless Kontena::PluginManager.instance.installed(name) && !ENV['NO_PLUGINS']
-      confirm unless forced?
-      spinner "Uninstalling plugin #{pastel.cyan(name)}" do |spin|
-        begin
-          Kontena::PluginManager.instance.uninstall_plugin(name)
-        rescue => ex
-          $stderr.puts pastel.red("#{ex.class.name} : #{ex.message}")
-          logger.error(ex)
-          spin.fail
-        end
+      exit_with_error "Plugin #{name} has not been installed" unless installed?(name)
+      spinner "Uninstalling plugin #{pastel.cyan(name)}" do
+        uninstaller.uninstall
       end
     end
   end
-end
+end

data/lib/kontena/cli/registry/create_command.rb

@@ -14,7 +14,7 @@ module Kontena::Cli::Registry
     option '--s3-region', 'S3_REGION', 'S3 region', default: 'eu-west-1'
     option '--s3-encrypt', :flag, 'Encrypt S3 objects', default: false
     option '--s3-secure', :flag, 'Use secure connection in S3', default: true
-    option '--s3-v4auth', :flag, 'Use v4auth on S3', default: false
+    option '--s3-v4auth', :flag, 'Use v4auth on S3', default: true
     option '--azure-account-name', 'AZURE_ACCOUNT_NAME', 'Azure account name'
     option '--azure-container-name', 'AZURE_CONTAINER_NAME', 'Azure container name'
 

data/lib/kontena/cli/services/create_command.rb

@@ -16,9 +16,13 @@ module Kontena::Cli::Services
     option ["-v", "--volume"], "VOLUME", "Add a volume or bind mount it from the host", multivalued: true
     option "--volumes-from", "VOLUMES_FROM", "Mount volumes from another container", multivalued: true
     option ["-a", "--affinity"], "AFFINITY", "Set service affinity", multivalued: true
+    option "--cpus", "CPUS", "Number of CPUs" do |cpus|
+      Float(cpus)
+    end
     option ["-c", "--cpu-shares"], "CPU_SHARES", "CPU shares (relative weight)"
     option ["-m", "--memory"], "MEMORY", "Memory limit (format: <number><optional unit>, where unit = b, k, m or g)"
     option ["--memory-swap"], "MEMORY_SWAP", "Total memory usage (memory + swap), set \'-1\' to disable swap (format: <number><optional unit>, where unit = b, k, m or g)"
+    option ["--shm-size"], "SHM_SIZE", "Size of /dev/shm (format: <number><optional unit>, where unit = b, k, m or g)"
     option "--cmd", "CMD", "Command to execute"
     option "--instances", "INSTANCES", "How many instances should be deployed"
     option ["-u", "--user"], "USER", "Username who executes first process inside container"
@@ -69,6 +73,8 @@ module Kontena::Cli::Services
       data[:volumes_from] = volumes_from_list unless volumes_from_list.empty?
       data[:memory] = parse_memory(memory) if memory
       data[:memory_swap] = parse_memory(memory_swap) if memory_swap
+      data[:shm_size] = parse_memory(shm_size) if shm_size
+      data[:cpus] = cpus if cpus
       data[:cpu_shares] = cpu_shares if cpu_shares
       data[:affinity] = affinity_list unless affinity_list.empty?
       data[:env] = env_list unless env_list.empty?

data/lib/kontena/cli/services/services_helper.rb

@@ -100,6 +100,15 @@ module Kontena
             end
           end
 
+          if service['certificates'].to_a.size > 0
+            puts "  certificates: "
+            service['certificates'].to_a.each do |c|
+              puts "    - subject: #{c['subject']}"
+              puts "      name: #{c['name']}"
+              puts "      type: #{c['type']}"
+            end
+          end
+
           if service['env'].to_a.size > 0
             puts "  env: "
             service['env'].to_a.each do |e|
@@ -161,6 +170,14 @@ module Kontena
             end
           end
 
+          unless service['cpus'].to_s.empty?
+            puts "  cpus: #{service['cpus']}"
+          end
+
+          unless service['cpu_shares'].to_s.empty?
+            puts "  cpu_shares: #{service['cpu_shares']}"
+          end
+
           unless service['memory'].to_s.empty?
             puts "  memory: #{int_to_filesize(service['memory'])}"
           end
@@ -169,6 +186,10 @@ module Kontena
             puts "  memory_swap: #{int_to_filesize(service['memory_swap'])}"
           end
 
+          unless service['shm_size'].to_s.empty?
+            puts "  shm_size: #{int_to_filesize(service['shm_size'])}"
+          end
+
           unless service['pid'].to_s.empty?
             puts "  pid: #{service['pid']}"
           end
@@ -361,13 +382,19 @@ module Kontena
         def parse_ports(port_options)
           port_regex = Regexp.new(/\A(?<ip>\d+\.\d+\.\d+\.\d+)?:?(?<node_port>\d+)\:(?<container_port>\d+)\/?(?<protocol>\w+)?\z/)
           port_options.map do |p|
-            match_data = port_regex.match(p.to_s)
-            raise ArgumentError, "Invalid port value #{p}" unless match_data
+            if p.kind_of?(Hash)
+              raise ArgumentError, "Missing or invalid node port" unless p['node_port'].to_i > 0
+              raise ArgumentError, "Missing or invalid container port" unless p['container_port'].to_i > 0
+              { ip: p['ip'] || '0.0.0.0', protocol: p['protocol'] || 'tcp', node_port: p['node_port'].to_i, container_port: p['container_port'].to_i }
+            else
+              match_data = port_regex.match(p.to_s)
+              raise ArgumentError, "Invalid port value #{p}" unless match_data
 
-            {
-              ip: '0.0.0.0',
-              protocol: 'tcp'
-            }.merge(match_data.names.map { |name| [name.to_sym, match_data[name]] }.to_h.reject { |_,v| v.nil? })
+              {
+                ip: '0.0.0.0',
+                protocol: 'tcp'
+              }.merge(match_data.names.map { |name| [name.to_sym, match_data[name]] }.to_h.reject { |_,v| v.nil? })
+            end
           end
         end
 

data/lib/kontena/cli/services/update_command.rb

@@ -14,9 +14,13 @@ module Kontena::Cli::Services
     option ["-e", "--env"], "ENV", "Set environment variables", multivalued: true
     option ["-l", "--link"], "LINK", "Add link to another service in the form of name:alias", multivalued: true
     option ["-a", "--affinity"], "AFFINITY", "Set service affinity", multivalued: true
+    option "--cpus", "CPUS", "Number of CPUs" do |cpus|
+      Float(cpus)
+    end
     option ["-c", "--cpu-shares"], "CPU_SHARES", "CPU shares (relative weight)"
     option ["-m", "--memory"], "MEMORY", "Memory limit (format: <number><optional unit>, where unit = b, k, m or g)"
     option ["--memory-swap"], "MEMORY_SWAP", "Total memory usage (memory + swap), set \'-1\' to disable swap (format: <number><optional unit>, where unit = b, k, m or g)"
+    option ["--shm-size"], "SHM_SIZE", "Size of /dev/shm (format: <number><optional unit>, where unit = b, k, m or g)"
     option "--cmd", "CMD", "Command to execute"
     option "--instances", "INSTANCES", "How many instances should be deployed"
     option ["-u", "--user"], "USER", "Username who executes first process inside container"
@@ -60,6 +64,8 @@ module Kontena::Cli::Services
       data[:links] = parse_links(link_list) unless link_list.empty?
       data[:memory] = parse_memory(memory) if memory
       data[:memory_swap] = parse_memory(memory_swap) if memory_swap
+      data[:shm_size] = parse_memory(shm_size) if shm_size
+      data[:cpus] = cpus if cpus
       data[:cpu_shares] = cpu_shares if cpu_shares
       data[:affinity] = affinity_list unless affinity_list.empty?
       data[:env] = env_list unless env_list.empty?

data/lib/kontena/cli/stacks/build_command.rb

@@ -8,7 +8,7 @@ module Kontena::Cli::Stacks
 
     banner "Build images listed in a stack file and push them to your image registry"
 
-    option ['-f', '--file'], 'FILE', 'Specify an alternate Kontena compose file', attribute_name: :filename, default: 'kontena.yml'
+    option ['-f', '--file'], 'FILE', 'Specify an alternate Kontena compose file', attribute_name: :source, default: 'kontena.yml'
 
     option ['--no-cache'], :flag, 'Do not use cache when building the image', default: false
     option ['--no-push'], :flag, 'Do not push images to registry', default: false
@@ -26,8 +26,8 @@ module Kontena::Cli::Stacks
     requires_current_master_token
 
     def execute
-      require_config_file(filename)
-      stack = stack_read_and_dump(filename, name: name, values: values)
+      set_env_variables(stack_name, current_grid)
+
       services = stack['services']
 
       unless service_list.empty?

data/lib/kontena/cli/stacks/common.rb

@@ -2,32 +2,72 @@ require_relative 'yaml/reader'
 require_relative '../services/services_helper'
 require_relative 'service_generator_v2'
 require_relative '../../stacks_client'
+require_relative 'yaml/stack_file_loader'
 require 'yaml'
 
 module Kontena::Cli::Stacks
   module Common
     include Kontena::Cli::Services::ServicesHelper
 
-    module StackNameParam
-      attr_accessor :stack_version
+    # @return [StackFileLoader] a loader for the stack origin defined through command-line options
+    def loader
+      @loader ||= loader_class.for(source)
+    end
+
+    # @return [YAML::Reader] a YAML reader for the target file
+    def reader
+      @reader ||= loader.reader
+    end
+
+    # Stack name read from -n parameter or the stack file
+    # @return [String]
+    def stack_name
+      @stack_name ||= (self.respond_to?(:name) && self.name) ? self.name : loader.stack_name.stack
+    end
+
+    # An accessor to the YAML Reader outcome. Passes parent name, values from command line and
+    # the stackname to the reader.
+    #
+    # @return [Hash]
+    def stack
+      @stack ||= reader.execute(
+        name: stack_name,
+        parent_name: self.respond_to?(:parent_name) ? self.parent_name : nil,
+        values: (self.respond_to?(:values_from_options) ? self.values_from_options : {})
+      )
+    end
+
+    # @return [Class] an accessor to StackFileLoader constant, for testing purposes
+    def loader_class
+      ::Kontena::Cli::Stacks::YAML::StackFileLoader
+    end
+
+    module RegistryNameParam
+      def stack_name
+        @stack_name ||= Kontena::Cli::Stacks::StackName.new(source)
+      end
 
       def self.included(where)
-        where.parameter "STACK_NAME", "Stack name, for example user/stackname or user/stackname:version" do |name|
-          if name.include?(':')
-            name, @stack_version = name.split(':',2 )
-          end
-          name
-        end
+        where.parameter "STACK_NAME", "Stack name, for example user/stackname or user/stackname:version", attribute_name: :source
+      end
+    end
+
+    module StackNameParam
+      # Include to add a STACK_NAME parameter
+      def self.included(where)
+        where.parameter "STACK_NAME", "Stack name, for example user/stackname or user/stackname:version", attribute_name: :source
       end
     end
 
     module StackFileOrNameParam
+      # Include to add a stack file parameter
       def self.included(where)
-        where.parameter "[FILE]", "Kontena stack file, registry stack name (user/stack or user/stack:version) or URL", default: "kontena.yml", attribute_name: :filename
+        where.parameter "[FILE]", "Kontena stack file, registry stack name (user/stack or user/stack:version) or URL", default: "kontena.yml", attribute_name: :source
       end
     end
 
     module StackNameOption
+      # Include to add a stack name parameter
       def self.included(where)
         where.option ['-n', '--name'], 'NAME', 'Define stack name (by default comes from stack file)'
       end
@@ -35,102 +75,73 @@ module Kontena::Cli::Stacks
 
     module StackValuesToOption
       attr_accessor :values
+      # Include to add --values-to variable value dumping feature
       def self.included(where)
         where.option '--values-to', '[FILE]', 'Output variable values as YAML to file'
       end
 
-      def dump_variables(reader)
-        vals = reader.variables.to_h(values_only: true).reject {|k,_| k == 'STACK' || k == 'GRID' }
-        File.write(values_to, ::YAML.dump(vals))
+      # Writes a YAML file from the values received from YAML::Reader to a file defined through
+      # the --values-to option
+      def dump_variables
+        File.write(values_to, ::YAML.dump(reader.variable_values, without_defaults: true, without_vault: true))
       end
     end
 
     module StackValuesFromOption
-      attr_accessor :values
+      # Include to add --values-from option to read variable values from a YAML file
+      # and the -v variable=value option that can be used to pass variable values
+      # directly from command line
       def self.included(where)
+        where.prepend InstanceMethods
+
         where.option '--values-from', '[FILE]', 'Read variable values from YAML' do |filename|
-          if filename
-            require_config_file(filename)
-            @values = ::YAML.safe_load(File.read(filename))
-          end
-          filename
+          values_from_file.merge!(::YAML.safe_load(File.read(filename)))
+          true
+        end
+
+        where.option '-v', "VARIABLE=VALUE", "Set stack variable values, example: -v domain=example.com. Can be used multiple times.", multivalued: true, attribute_name: :var_option do |var_pair|
+          var_name, var_value = var_pair.split('=', 2)
+          values_from_value_options.merge!(::YAML.safe_load(::YAML.dump(var_name => var_value)))
         end
       end
-    end
 
-    def stack_name
-      @stack_name ||= self.name || stack_name_from_yaml(filename)
-    end
+      module InstanceMethods
+        def values_from_file
+          @values_from_file ||= {}
+        end
 
-    def reader_from_yaml(filename, name: nil, values: nil, defaults: nil)
-      reader = Kontena::Cli::Stacks::YAML::Reader.new(filename, values: values, defaults: defaults)
-      if reader.stack_name.nil?
-        exit_with_error "Stack MUST have stack name in YAML top level field 'stack'! Aborting."
-      end
-      set_env_variables(name || reader.stack_name, current_grid)
-      reader
-    end
-
-    def stack_from_reader(reader)
-      outcome = reader.execute
-
-      hint_on_validation_notifications(outcome[:notifications]) unless outcome[:notifications].empty?
-      abort_on_validation_errors(outcome[:errors]) unless outcome[:errors].empty?
-      kontena_services = generate_services(outcome[:services])
-      kontena_volumes = generate_volumes(outcome[:volumes])
-      stack = {
-        'name' => outcome[:name],
-        'stack' => outcome[:stack],
-        'expose' => outcome[:expose],
-        'version' => outcome[:version],
-        'source' => reader.raw_content,
-        'registry' => outcome[:registry],
-        'services' => kontena_services,
-        'volumes' => kontena_volumes,
-        'variables' => outcome[:variables]
-      }
-      stack
-    end
-
-    def stack_from_yaml(filename, name: nil, values: nil, defaults: nil)
-      reader = reader_from_yaml(filename, name: name, values: values, defaults: defaults)
-      stack_from_reader(reader)
-    end
-
-    def stack_read_and_dump(filename, name: nil, values: nil, defaults: nil)
-      reader = reader_from_yaml(filename, name: name, values: values, defaults: defaults)
-      stack = stack_from_reader(reader)
-      dump_variables(reader) if values_to
-      stack
-    end
-
-    def require_config_file(filename)
-      exit_with_error("File #{filename} does not exist") unless File.exists?(filename)
-    end
-
-    def generate_volumes(yaml_volumes)
-      return [] unless yaml_volumes
-      yaml_volumes.map do |name, config|
-        if config['external'].is_a?(TrueClass)
-          config['external'] = name
-        elsif config['external']['name']
-          config['external'] = config['external']['name']
+        def values_from_value_options
+          @values_from_value_options ||= {}
         end
-        config.merge('name' => name)
-      end
-    end
 
-    def generate_services(yaml_services)
-      return [] unless yaml_services
-      yaml_services.map do |name, config|
-        exit_with_error("Image is missing for #{name}. Aborting.") unless config['image'] # why isn't this a validation?
-        ServiceGeneratorV2.new(config).generate.merge('name' => name)
+        def values_from_options
+          @values_from_options ||= values_from_file.merge(values_from_value_options)
+        end
+
+        # Transforms a hash
+        # dependency_values_from_options('foo.bar' => 1, 'foo')
+        #  => { 'bar' => 1 }
+        # Used for dependency variable injection
+        def dependency_values_from_options(name)
+          name_with_dot = name.to_s + '.'
+          values_from_options.each_with_object({}) do |kv_pair, obj|
+            key = kv_pair.first.to_s
+            value = kv_pair.last
+            next unless key.start_with?(name_with_dot)
+            obj[key.sub(name_with_dot, '')] = value
+          end
+        end
       end
     end
 
-    def set_env_variables(stack, grid)
+    # Sets environment variables from parameters
+    # @param stack [String] current stack name
+    # @param grid [String] current grid name
+    # @param platform [String] current platform name, defaults to param grid value
+    def set_env_variables(stack, grid, platform = grid)
       ENV['STACK'] = stack
       ENV['GRID'] = grid
+      ENV['PLATFORM'] = platform
     end
 
     # @return [String]
@@ -139,20 +150,24 @@ module Kontena::Cli::Stacks
     end
 
     def display_notifications(messages, color = :yellow)
-      $stderr.puts(Kontena.pastel.send(color, messages.to_yaml.gsub(/^---$/, '')))
+      $stderr.puts(pastel.send(color, messages.to_yaml.gsub(/^---$/, '')))
     end
 
-    def hint_on_validation_notifications(errors)
-      $stderr.puts "YAML contains the following unsupported options and they were rejected:".colorize(:yellow)
-      display_notifications(errors)
+    def hint_on_validation_notifications(notifications, filename = nil)
+      return if notifications.nil? || notifications.empty?
+      $stderr.puts pastel.yellow("#{"(#{filename}) " if filename}YAML contains the following unsupported options and they were rejected:")
+      display_notifications(notifications)
     end
 
-    def abort_on_validation_errors(errors)
-      $stderr.puts "YAML validation failed! Aborting.".colorize(:red)
+    def abort_on_validation_errors(errors, filename = nil)
+      return if errors.nil? || errors.empty?
+      $stderr.puts pastel.red("#{"(#{filename}) " if filename} YAML validation failed! Aborting.")
       display_notifications(errors, :red)
       abort
     end
 
+    # An accessor to stack registry client
+    # @return [Kontena::StacksClient]
     def stacks_client
       @stacks_client ||= Kontena::StacksClient.new(current_account.stacks_url, current_account.token, read_requires_token: current_account.stacks_read_authentication)
     end