kontena-cli 0.16.3 → 0.17.0.pre1

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

@@ -13,6 +13,7 @@ module Kontena::Cli::Services
       token = require_token
 
       show_service(token, name)
+      show_service_instances(token, name)
     end
   end
 end

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

@@ -32,12 +32,12 @@ module Kontena::Cli::Services
     option "--deploy-interval", "TIME", "Auto-deploy with given interval (format: <number><unit>, where unit = min, h, d)"
     option "--pid", "PID", "Pid namespace to use"
     option "--secret", "SECRET", "Import secret from Vault (format: <secret>:<name>:<type>)", multivalued: true
-    option "--health-check-uri", "HEALTH CHECK URI", "URI path for HTTP health check"
-    option "--health-check-timeout", "HEALTH CHECK TIMEOUT", "Timeout for HTTP health check"
-    option "--health-check-interval", "HEALTH CHECK INTERVAL", "Interval for HTTP health check"
-    option "--health-check-initial-delay", "HEALTH CHECK INITIAL DELAY", "Initial for HTTP health check"
-    option "--health-check-port", "HEALTH CHECK PORT", "Port for HTTP health check"
-    option "--health-check-protocol", "HEALTH CHECK PROTOCOL", "Protocol of health check"
+    option "--health-check-uri", "URI", "URI path for HTTP health check"
+    option "--health-check-timeout", "TIMEOUT", "Timeout for HTTP health check"
+    option "--health-check-interval", "INTERVAL", "Interval for HTTP health check"
+    option "--health-check-initial-delay", "DELAY", "Initial for HTTP health check"
+    option "--health-check-port", "PORT", "Port for HTTP health check"
+    option "--health-check-protocol", "PROTOCOL", "Protocol of health check"
 
     def execute
       require_api_url

data/lib/kontena/cli/stack_command.rb

@@ -1,19 +1,25 @@
-require_relative 'stacks/create_command'
+require_relative 'stacks/install_command'
 require_relative 'stacks/remove_command'
 require_relative 'stacks/deploy_command'
-require_relative 'stacks/update_command'
+require_relative 'stacks/upgrade_command'
 require_relative 'stacks/list_command'
 require_relative 'stacks/show_command'
+require_relative 'stacks/build_command'
+require_relative 'stacks/monitor_command'
+require_relative 'stacks/logs_command'
 
 class Kontena::Cli::StackCommand < Kontena::Command
 
-  subcommand "create", "Create stack", Kontena::Cli::Stacks::CreateCommand
+  subcommand "install", "Install a stack", Kontena::Cli::Stacks::InstallCommand
+  subcommand "build", "Build stack file images", Kontena::Cli::Stacks::BuildCommand
   subcommand ["ls", "list"], "List stacks", Kontena::Cli::Stacks::ListCommand
   subcommand "show", "Show stack details", Kontena::Cli::Stacks::ShowCommand
-  subcommand "update", "Update stack", Kontena::Cli::Stacks::UpdateCommand
-  subcommand "deploy", "Deploy Kontena stack", Kontena::Cli::Stacks::DeployCommand
+  subcommand "upgrade", "Upgrade installed stack", Kontena::Cli::Stacks::UpgradeCommand
+  subcommand "deploy", "Deploy stack", Kontena::Cli::Stacks::DeployCommand
+  subcommand "logs", "Show stack logs from stack services", Kontena::Cli::Stacks::LogsCommand
+  subcommand "monitor", "Monitor stack", Kontena::Cli::Stacks::MonitorCommand
   subcommand ["remove","rm"], "Remove stack", Kontena::Cli::Stacks::RemoveCommand
-  
+
   def execute
 
   end

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

@@ -0,0 +1,110 @@
+require_relative 'common'
+
+module Kontena::Cli::Stacks
+  class BuildCommand < Clamp::Command
+    include Kontena::Cli::Common
+    include Common
+
+    option ['-f', '--file'], 'FILE', 'Specify an alternate Kontena compose file', attribute_name: :filename, 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
+    option ['--no-pull'], :flag, 'Do not attempt to pull a newer version of the image', default: false
+    parameter "[SERVICE] ...", "Services to build"
+
+    def execute
+      require_config_file(filename)
+      services = services_from_yaml(filename, service_list, service_prefix)
+      if services.none?{ |name, service| service['build'] }
+        abort 'Not found any service with a build option'.colorize(:red)
+      end
+      build_docker_images(services, no_cache?, no_pull?)
+      push_docker_images(services) unless no_push?
+    end
+
+    # @param [Hash] services
+    # @param [Boolean] no_cache
+    # @param [Boolean] no_pull
+    def build_docker_images(services, no_cache = false, no_pull = false)
+      services.each do |name, service|
+        if service['build']
+          dockerfile = service['build']['dockerfile'] || 'Dockerfile'
+          abort("'#{service['image']}' is not valid Docker image name") unless validate_image_name(service['image'])
+          abort("'#{service['build']['context']}' does not have #{dockerfile}") unless dockerfile_exist?(service['build']['context'], dockerfile)
+          if service['hooks'] && service['hooks']['pre_build']
+            puts "Running pre_build hook".colorize(:cyan)
+            run_pre_build_hook(service['hooks']['pre_build'])
+          end
+          puts "Building image #{service['image'].colorize(:cyan)}"
+          build_docker_image(service, no_cache, no_pull)
+        end
+      end
+    end
+
+    # @param [Hash] services
+    def push_docker_images(services)
+      services.each do |name, service|
+        if service['build']
+          puts "Pushing image #{service['image'].colorize(:cyan)}"
+          push_docker_image(service['image'])
+        end
+      end
+    end
+
+    # @param [Hash] service
+    # @param [Boolean] no_cache
+    # @param [Boolean] no_pull
+    # @return [Integer]
+    def build_docker_image(service, no_cache = false, no_pull = false)
+      dockerfile = dockerfile = service['build']['dockerfile'] || 'Dockerfile'
+      build_context = service['build']['context']
+      cmd = ['docker', 'build', '-t', service['image']]
+      cmd << ['-f', File.join(File.expand_path(build_context), dockerfile)] if dockerfile != "Dockerfile"
+      cmd << '--no-cache' if no_cache
+      cmd << '--pull' unless no_pull
+      args = service['build']['args'] || {}
+      args.each do |k, v|
+        cmd << "--build-arg=#{k}=#{v}"
+      end
+      cmd << build_context
+      ret = system(*cmd.flatten)
+      raise ("Failed to build image #{service['image'].colorize(:cyan)}") unless ret
+      ret
+    end
+
+    # @param [String] image
+    # @return [Integer]
+    def push_docker_image(image)
+      ret = system('docker', 'push', image)
+      raise ("Failed to push image #{image.colorize(:cyan)}") unless ret
+      ret
+    end
+
+    # @param [String] name
+    # @return [Boolean]
+    def validate_image_name(name)
+      !(/^[\w.\/\-:]+:?+[\w+.]+$/ =~ name).nil?
+    end
+
+    # @param [String] image
+    # @return [Boolean]
+    def image_exist?(image)
+      system("docker history '#{image}' >/dev/null 2>/dev/null")
+    end
+
+    # @param [String] path
+    # @param [String] dockerfile
+    # @return [Boolean]
+    def dockerfile_exist?(path, dockerfile)
+      file = File.join(File.expand_path(path), dockerfile)
+      File.exist?(file)
+    end
+
+    # @param [Hash] hook
+    def run_pre_build_hook(hook)
+      hook.each do |h|
+        ret = system(h['cmd'])
+        raise ("Failed to run pre_build hook: #{h['name']}!") unless ret
+      end
+    end
+  end
+end

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

@@ -1,37 +1,102 @@
-require_relative '../apps/yaml/reader'
+require 'yaml'
+require_relative 'yaml/reader'
+require_relative '../services/services_helper'
+require_relative 'service_generator_v2'
 
 module Kontena::Cli::Stacks
   module Common
-    include Kontena::Cli::Apps::Common
+    include Kontena::Cli::Services::ServicesHelper
 
-    def service_prefix
-      @service_prefix ||= project_name_from_yaml(filename)
-    end
-
-    def stack_from_yaml(filename)
-      set_env_variables(service_prefix, current_grid)
-      outcome = read_yaml(filename)
-      if outcome[:version] != '2'
-        exit_with_error "Stack supported only in v2 YAML! Aborting."
-      end
-      if outcome[:name].nil?
+    def stack_from_yaml(filename, skip_validation = false)
+      reader = Kontena::Cli::Stacks::YAML::Reader.new(filename, skip_validation)
+      if reader.stack_name.nil?
         exit_with_error "Stack MUST have name in YAML! Aborting."
       end
+      set_env_variables(self.name || reader.stack_name, current_grid)
+      reader.reload
+      outcome = reader.execute
+
       hint_on_validation_notifications(outcome[:notifications]) if outcome[:notifications].size > 0
       abort_on_validation_errors(outcome[:errors]) if outcome[:errors].size > 0
       kontena_services = generate_services(outcome[:services], outcome[:version])
-      # services now as hash, needs to be array in stacks API
-      services = []
-      kontena_services.each do |name, service|
-        service['name'] = prefixed_name(name)
-        services << service
-      end
       stack = {
         'name' => outcome[:name],
-        'services' => services
+        'stack' => outcome[:stack],
+        'expose' => outcome[:expose],
+        'version' => outcome[:version],
+        'source' => reader.raw,
+        'registry' => 'file://',
+        'services' => kontena_services
       }
       stack
     end
 
+    def require_config_file(filename)
+      exit_with_error("File #{filename} does not exist") unless File.exists?(filename)
+    end
+
+
+    ##
+    # @param [Hash] yaml
+    # @param [String] version
+    # @return [Hash]
+    def generate_services(yaml_services, version)
+      services = []
+      generator_klass = ServiceGeneratorV2
+      yaml_services.each do |service_name, config|
+        exit_with_error("Image is missing for #{service_name}. Aborting.") unless config['image']
+        service = generator_klass.new(config).generate
+        service['name'] = service_name
+        services << service
+      end
+      services
+    end
+
+    def read_yaml(filename, skip_validation = false)
+      reader = Kontena::Cli::Stacks::YAML::Reader.new(filename)
+      outcome = reader.execute
+      outcome
+    end
+
+    def set_env_variables(stack, grid)
+      ENV['STACK'] = stack
+      ENV['GRID'] = grid
+    end
+
+    # @return [String]
+    def current_dir
+      File.basename(Dir.getwd)
+    end
+
+    def display_notifications(messages, color = :yellow)
+      messages.each do |files|
+        files.each do |file, services|
+          STDERR.puts "#{file}:".colorize(color)
+          services.each do |service|
+            service.each do |name, errors|
+              STDERR.puts "  #{name}:".colorize(color)
+              if errors.is_a?(String)
+                STDERR.puts "    - #{errors}".colorize(color)
+              else
+                errors.each do |key, error|
+                  STDERR.puts "    - #{key}: #{error.to_json}".colorize(color)
+                end
+              end
+            end
+          end
+        end
+      end
+    end
+
+    def hint_on_validation_notifications(errors)
+      STDERR.puts "YAML contains the following unsupported options and they were rejected:".colorize(:yellow)
+      display_notifications(errors)
+    end
+
+    def abort_on_validation_errors(errors)
+      STDERR.puts "YAML validation failed! Aborting.".colorize(:red)
+      display_notifications(errors, :red)
+      abort
+    end
   end
 end

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

@@ -10,17 +10,40 @@ module Kontena::Cli::Stacks
 
     def execute
       require_api_url
-      require_token
-
-      deploy_stack(name)
+      token = require_token
+
+      deployment = nil
+      spinner "Deploying stack #{pastel.cyan(name)}" do
+        deployment = deploy_stack(token, name)
+        deployment['service_deploys'].each do |service_deploy|
+          wait_for_deploy_to_finish(token, service_deploy)
+        end
+      end
     end
 
-    private
-
-
-    def deploy_stack
+    def deploy_stack(token, name)
       client(token).post("stacks/#{current_grid}/#{name}/deploy", {})
     end
 
+    # @param [String] token
+    # @param [Hash] deployment
+    # @return [Boolean]
+    def wait_for_deploy_to_finish(token, deployment, timeout = 600)
+      deployed = false
+      Timeout::timeout(timeout) do
+        until deployed
+          deployment = client(token).get("services/#{deployment['service_id']}/deploys/#{deployment['id']}")
+          deployed = true if deployment['finished_at']
+          sleep 1
+        end
+        if deployment['state'] == 'error'
+          raise deployment['reason']
+        end
+      end
+
+      deployed
+    rescue Timeout::Error
+      raise 'deploy timed out'
+    end
   end
 end

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

@@ -0,0 +1,30 @@
+require_relative 'common'
+
+module Kontena::Cli::Stacks
+  class InstallCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    parameter "[FILE]", "Kontena stack file", default: "kontena.yml", attribute_name: :filename
+
+    option ['-n', '--name'], 'NAME', 'Define stack name (by default comes from stack file)'
+    option '--deploy', :flag, 'Deploy after installation'
+
+    def execute
+      require_api_url
+      token = require_token
+      require_config_file(filename)
+      stack = stack_from_yaml(filename)
+      stack['name'] = name if name
+      spinner "Creating stack #{pastel.cyan(stack['name'])} " do
+        create_stack(token, stack)
+      end
+      Kontena.run("stack deploy #{stack['name']}") if deploy?
+    end
+
+    def create_stack(token, stack)
+      client(token).post("grids/#{current_grid}/stacks", stack)
+    end
+  end
+end

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

@@ -6,33 +6,93 @@ module Kontena::Cli::Stacks
     include Kontena::Cli::GridOptions
     include Common
 
-    COLUMNS = "%-30s %-10s %-10s".freeze
-
     def execute
       require_api_url
-      require_token
+      token = require_token
 
-      list_stacks
+      list_stacks(token)
     end
 
-    private
+    def list_stacks(token)
+      response = client(token).get("grids/#{current_grid}/stacks")
 
-    def list_stacks
-      response = client(token).get("stacks/#{current_grid}")
-      
-      titles = ['NAME', 'SERVICES', 'STATE']
-      puts COLUMNS % titles
+      titles = ['NAME', 'VERSION', 'SERVICES', 'STATE', 'EXPOSED PORTS']
+      puts "%-60s %-10s %-10s %-10s %-50s" % titles
 
       response['stacks'].each do |stack|
+        ports = stack_ports(stack)
+        health = stack_health(stack)
+        if health == :unhealthy
+          icon = '⊗'.freeze
+          color = :red
+        elsif health == :partial
+          icon = '⊙'.freeze
+          color = :yellow
+        elsif health == :healthy
+          icon = '⊛'.freeze
+          color = :green
+        else
+          icon = '⊝'.freeze
+          color = :dim
+        end
+
         vars = [
-          stack['name'],
-          stack['grid_services'].size,
-          stack['state']
+          icon.colorize(color),
+          "#{stack['name']}",
+          "#{stack['version']}",
+          stack['services'].size,
+          stack['state'],
+          ports.join(",")
         ]
 
-        puts COLUMNS % vars
+        puts "%s %-58s %-10s %-10s %-10s %-50s" % vars
       end
     end
 
+    # @param [Hash] stack
+    # @return [Array<String>]
+    def stack_ports(stack)
+      ports = []
+      stack['services'].each{|s|
+        service_ports = s['ports'].map{|p|
+          p['ip'] = '*' if p['ip'] == '0.0.0.0'
+          "#{p['ip']}:#{p['node_port']}->#{p['container_port']}/#{p['protocol']}"
+        }
+        ports = ports + service_ports unless service_ports.empty?
+      }
+      ports
+    end
+
+    # @param [Hash] stack
+    # @return [Symbol]
+    def stack_health(stack)
+      services_count = stack['services'].size
+      return :unknown if services_count == 0
+
+      fully_healthy_count = 0
+      partial_healthy_count = 0
+      unhealthy_count = 0
+      unknown_count = 0
+      stack['services'].each { |s|
+        total = s.dig('health_status', 'total').to_i
+        healthy = s.dig('health_status', 'healthy').to_i
+        if total > 0 && healthy == total
+          fully_healthy_count += 1
+        elsif healthy < total && healthy > 0
+          partial_healthy_count += 1
+        elsif healthy == 0 && total > 0
+          unhealthy_count += 1
+        else
+          unknown_count += 1
+        end
+      }
+      return :partial if partial_healthy_count > 0
+      return :partial if unhealthy_count > 0 && fully_healthy_count > 0
+      return :unhealthy if unhealthy_count == services_count
+      return :healthy if fully_healthy_count == services_count
+      return :healthy if fully_healthy_count > 0 && unknown_count > 0
+
+      :unknown
+    end
   end
 end