krates 1.6.0

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

@@ -0,0 +1,87 @@
+require_relative 'services_helper'
+
+module Kontena::Cli::Services
+  class StatsCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include ServicesHelper
+
+    MEM_MAX_LIMITS = [
+      2**64,
+      2**63 - 4096
+    ]
+
+    parameter "NAME", "Service name"
+    option ["-t", "--tail"], :flag, "Tail (follow) stats in real time", default: false
+
+    def execute
+      require_api_url
+      token = require_token
+      if tail?
+        system('clear')
+        render_header
+      end
+      loop do
+        fetch_stats(token, name, tail?)
+        break unless tail?
+        sleep(2)
+      end
+    end
+
+    private
+
+    def fetch_stats(token, service_id, follow)
+      result = client(token).get("services/#{parse_service_id(service_id)}/stats")
+      system('clear') if follow
+      render_header
+      result['stats'].each do |stat|
+        render_stat_row(stat)
+      end
+    end
+
+    def render_header
+      puts '%-30.30s %-15s %-20s %-15s %-15s' % ['INSTANCE', 'CPU %', 'MEM USAGE/LIMIT', 'MEM %', 'NET I/O']
+    end
+
+    def render_stat_row(stat)
+      memory = stat['memory'].nil? ? 'N/A' : filesize_to_human(stat['memory']['usage'])
+      if !stat['memory'].nil? && (stat['memory']['limit'] && !MEM_MAX_LIMITS.include?(stat['memory']['limit']))
+        memory_limit = filesize_to_human(stat['memory']['limit'])
+        memory_pct = "#{(stat['memory']['usage'].to_f / stat['memory']['limit'].to_f * 100).round(2)}%"
+      else
+        memory_limit = 'N/A'
+        memory_pct = 'N/A'
+      end
+
+      cpu = stat['cpu'].nil? ? 'N/A' : stat['cpu']['usage']
+
+      network_in = stat['network'].nil? ? 'N/A' : filesize_to_human(network_bytes(stat['network'], 'rx_bytes'))
+      network_out = stat['network'].nil? ? 'N/A' : filesize_to_human(network_bytes(stat['network'], 'tx_bytes'))
+
+      prefix = self.name.split('/')[0]
+      instance_name = stat['container_id'].gsub("#{prefix}-", "")
+      puts '%-30.30s %-15s %-20s %-15s %-15s' % [ instance_name, "#{cpu}%", "#{memory} / #{memory_limit}", "#{memory_pct}", "#{network_in}/#{network_out}"]
+    end
+
+    ##
+    # @param [Integer] size
+    # @return [String]
+    def filesize_to_human(size)
+      return '0B' if size.to_f == 0.0
+      units = %w{B K M G T}
+      e = (Math.log(size) / Math.log(1000)).floor
+      s = '%.2f' % (size.to_f / 1000**e)
+      s.sub(/\.?0*$/, units[e])
+    rescue FloatDomainError
+      'N/A'
+    end
+
+    ##
+    # @param [Hash] network
+    # @param [String] key
+    # @return [Integer]
+    def network_bytes(network, key)
+      (network.dig('internal', key) || 0) + (network.dig('external', key) || 0)
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative 'services_helper'
+
+module Kontena::Cli::Services
+  class StopCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include ServicesHelper
+
+    parameter "NAME ...", "Service name", attribute_name: :names
+
+    def execute
+      require_api_url
+      token = require_token
+      names.each do |name|
+        spinner "Sending stop signal to #{pastel.cyan(name)} service " do
+          stop_service(token, name)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,30 @@
+require_relative 'services_helper'
+
+module Kontena::Cli::Services
+  class UnlinkCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include ServicesHelper
+
+    parameter "NAME", "Service name"
+    parameter "TARGET", "Link target service name"
+
+    def execute
+      require_api_url
+      token = require_token
+      target_service = target
+      target_service = "null/#{target_service}" unless target_service.include?('/')
+      target_id = "#{current_grid}/#{target_service}"
+      service = client(token).get("services/#{parse_service_id(name)}")
+      links = service['links']
+      unless links.find { |l| l['id'] == target_id }
+        exit_with_error("Service is not linked to #{target.to_s}")
+      end
+      links.delete_if { |l| l['id'] == target_id }
+      data = {links: links}
+      spinner "Unlinking #{pastel.cyan(name)} from #{pastel.cyan(target)} " do
+        update_service(token, name, data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,94 @@
+require_relative 'services_helper'
+require 'shellwords'
+
+module Kontena::Cli::Services
+  class UpdateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include ServicesHelper
+
+    parameter "NAME", "Service name"
+
+    option "--image", "IMAGE", "Docker image to use"
+    option ["-p", "--ports"], "PORT", "Publish a service's port to the host", multivalued: true
+    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"
+    option "--privileged", :flag, "Give extended privileges to this service", default: false
+    option "--cap-add", "CAP_ADD", "Add capabitilies", multivalued: true, default: nil
+    option "--cap-drop", "CAP_DROP", "Drop capabitilies", multivalued: true, default: nil
+    option "--net", "NET", "Network mode"
+    option "--log-driver", "LOG_DRIVER", "Set logging driver"
+    option "--log-opt", "LOG_OPT", "Add logging options", multivalued: true, default: nil
+    option "--deploy-strategy", "STRATEGY", "Deploy strategy to use (ha, daemon, random)"
+    option "--deploy-wait-for-port", "PORT", "Wait for port to respond when deploying"
+    option "--deploy-min-health", "FLOAT", "The minimum percentage (0.0 - 1.0) of healthy instances that do not sacrifice overall service availability while deploying"
+    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", "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"
+    option "--stop-signal", "STOP_SIGNAL", "Alternative signal to stop container"
+    option "--stop-timeout", "STOP_TIMEOUT", "Timeout (duration) to stop a container"
+
+    def execute
+      require_api_url
+      token = require_token
+
+      data = parse_service_data_from_options
+      spinner "Updating #{pastel.cyan(name)} service " do
+        update_service(token, name, data)
+      end
+    end
+
+    ##
+    # parse given options to hash
+    # @return [Hash]
+    def parse_service_data_from_options
+      data = {}
+      data[:strategy] = deploy_strategy if deploy_strategy
+      data[:ports] = parse_ports(ports_list) unless ports_list.empty?
+      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[:secrets] = parse_secrets(secret_list) unless secret_list.empty?
+      data[:container_count] = instances if instances
+      data[:cmd] = Shellwords.split(cmd) if cmd
+      data[:user] = user if user
+      data[:image] = parse_image(image) if image
+      data[:privileged] = privileged?
+      data[:cap_add] = cap_add_list if cap_add_list
+      data[:cap_drop] = cap_drop_list if cap_drop_list
+      data[:net] = net if net
+      data[:log_driver] = log_driver if log_driver
+      data[:log_opts] = parse_log_opts(log_opt_list) if log_opt_list
+      deploy_opts = parse_deploy_opts
+      data[:deploy_opts] = deploy_opts unless deploy_opts.empty?
+      health_check = parse_health_check
+      data[:health_check] = health_check unless health_check.empty?
+      data[:pid] = pid if pid
+      data[:stop_signal] = stop_signal if stop_signal
+      data[:stop_grace_period] = stop_timeout if stop_timeout
+      data
+    end
+  end
+end

data/lib/kontena/cli/spinner.rb

@@ -0,0 +1,205 @@
+module Kontena
+  module Cli
+    SpinAbort = Class.new(StandardError)
+
+    class SpinnerStatus
+      attr_reader :thread, :result
+
+      def initialize(thread)
+        @thread = thread
+        @result = :done
+      end
+
+      def set_title(message)
+        if $stdout.tty?
+          thread['update_msg'] = message
+        else
+          Kernel.puts "- #{message}"
+        end
+      end
+
+      def warn?
+        @result == :warn
+      end
+
+      def failed?
+        @result == :fail
+      end
+
+      def fail
+        @result = :fail
+      end
+
+      def fail!
+        @result = :fail
+        thread['abort'] = true
+        raise SpinAbort
+      end
+
+      def warn
+        @result = :warn
+      end
+    end
+
+    class Spinner
+      CHARS = ['\\', '|', '/', '-']
+      CHARS_LENGTH = CHARS.length
+
+      def self.spin_no_tty(msg, &block)
+        unless block_given?
+          Kernel.puts "\r [" + Kontena.pastel.green("done") + "] #{msg}"
+          return
+        end
+
+        Kernel.puts "* #{msg}.. "
+        result = nil
+        status = nil
+        begin
+          spin_status = SpinnerStatus.new(Thread.current)
+          result = yield spin_status
+          Kernel.puts "* #{msg}.. #{spin_status.result}"
+        rescue SpinAbort
+          Kernel.puts "* #{msg}.. fail"
+        rescue SystemExit => ex
+          status = ex.status
+          if status == 0
+            Kernel.puts "* #{msg}.. done"
+          else
+            Kernel.puts "* #{msg}.. fail"
+          end
+        rescue Exception => ex
+          Kernel.puts "* #{msg}.. fail"
+          Kontena.logger.error(ex)
+          raise ex
+        end
+        exit(status) if status
+        result
+      end
+
+      def self.spin(msg, &block)
+        return spin_no_tty(msg, &block) unless $stdout.tty?
+
+        unless block_given?
+          Kernel.puts "\r [" + Kontena.pastel.green("done") + "] #{msg}"
+          return
+        end
+
+        Thread.main['spinners'] ||= []
+        unless Thread.main['spinners'].empty?
+          Thread.main['spinners'].each do |thread|
+            thread['pause'] = true
+          end
+          Kernel.puts "\r [#{Kontena.pastel.yellow('....')}] #{Thread.main['spinners'].last['msg']}"
+        end
+
+        Thread.main['spinner_msgs'] = []
+        spin_thread = Thread.new do
+          Thread.current['msg'] = msg
+          message = "    *   #{msg} .. "
+          Kernel.print(message + CHARS.first)
+          curr_index = 0
+          loop do
+            if Thread.current['pause']
+              until !Thread.current['pause'] || Thread.current['abort']
+                sleep 0.1
+              end
+              Kernel.print "\r#{message}#{CHARS[curr_index]}"
+            end
+
+            if Thread.current['update_msg']
+              msg = Thread.current['update_msg']
+              Thread.current['update_msg'] = nil
+              Thread.current['msg'] = msg
+              message = "    *   #{msg} .. "
+              Kernel.print "\r#{message}#{CHARS[curr_index]}"
+            end
+
+            break if Thread.current['abort']
+
+            if Thread.main['spinner_msgs']
+              Kernel.print "\r#{' ' * (message.gsub(/\e.+?m/, '').length + 1)}\r"
+              while Thread.main['spinner_msgs'].size > 0
+                Kernel.puts "\r#{Thread.main['spinner_msgs'].shift}"
+              end
+              Kernel.print "\r#{message + CHARS[curr_index]}"
+            end
+            sleep 0.1
+            Kernel.print "\b#{CHARS[curr_index]}"
+            curr_index = curr_index == CHARS_LENGTH - 1 ? 0 : curr_index + 1
+          end
+        end
+
+        Thread.main['spinners'] << spin_thread
+
+        status = nil
+        result = nil
+        begin
+          spin_status = SpinnerStatus.new(spin_thread)
+          result = yield spin_status
+          spin_thread.kill
+          case spin_status.result
+          when :warn
+            Kernel.puts "\r [" + Kontena.pastel.yellow("warn") + "] #{msg}     "
+          when :fail
+            Kernel.puts "\r [" + Kontena.pastel.red("fail") + "] #{msg}     "
+          else
+            Kernel.puts "\r [" + Kontena.pastel.green("done") + "] #{msg}     "
+          end
+        rescue SystemExit => ex
+          spin_thread.kill
+          if ex.status == 0
+            Kernel.puts "\r [" + Kontena.pastel.green("done")   + "] #{msg}     "
+          else
+            Kernel.puts "\r [" + Kontena.pastel.red("fail")   + "] #{msg}     "
+          end
+          status = ex.status
+        rescue SpinAbort
+          spin_thread.kill
+          Kernel.puts "\r [" + Kontena.pastel.red("fail")   + "] #{msg}     "
+          Kontena.logger.debug { "Spin aborted through fail!" }
+        rescue Exception => ex
+          spin_thread.kill
+          Kernel.puts "\r [" + Kontena.pastel.red("fail")   + "] #{msg}     "
+          Kontena.logger.error(ex)
+          raise ex
+        ensure
+          unless Thread.main['spinner_msgs'].empty?
+            while msg = Thread.main['spinner_msgs'].shift
+              Kernel.puts msg
+            end
+          end
+          Thread.main['spinners'].delete(spin_thread)
+        end
+
+        exit(status) if status
+        Thread.main['spinners'].pop
+        unless Thread.main['spinners'].empty?
+          Thread.main['spinners'].last['pause'] = false
+        end
+        result
+      end
+    end
+
+    module ShellSpinner
+      def spinner(msg = "", &block)
+        Kontena::Cli::Spinner.spin(msg, &block)
+      end
+
+      def puts(*msgs)
+        if Thread.main['spinners'] && !Thread.main['spinners'].empty?
+          msgs.each { |msg| Thread.main['spinner_msgs'] << msg }
+        else
+          super(*msgs)
+        end
+      end
+
+      def print(*msgs)
+        if Thread.main['spinners'] && !Thread.main['spinners'].empty?
+          Thread.main['spinner_msgs'] << msgs.join
+        else
+          super(*msgs)
+        end
+      end
+    end
+  end
+end

data/lib/kontena/cli/stack_command.rb

@@ -0,0 +1,21 @@
+class Kontena::Cli::StackCommand < Kontena::Command
+  subcommand "install", "Install a stack to a grid", load_subcommand('stacks/install_command')
+  subcommand ["ls", "list"], "List installed stacks in a grid", load_subcommand('stacks/list_command')
+  subcommand ["remove","rm"], "Remove a deployed stack from a grid", load_subcommand('stacks/remove_command')
+  subcommand "show", "Show details about a stack in a grid", load_subcommand('stacks/show_command')
+  subcommand "inspect", "Show the Stack YAML of an installed stack", load_subcommand('stacks/inspect_command')
+  subcommand "upgrade", "Upgrade a stack in a grid", load_subcommand('stacks/upgrade_command')
+  subcommand ["start", "deploy"], "Deploy an installed stack in a grid", load_subcommand('stacks/deploy_command')
+  subcommand "logs", "Show logs from services in a stack", load_subcommand('stacks/logs_command')
+  subcommand "events", "Show events from services in a stack", load_subcommand('stacks/events_command')
+  subcommand "monitor", "Monitor services in a stack", load_subcommand('stacks/monitor_command')
+  subcommand "build", "Build images listed in a stack file and push them to an image registry", load_subcommand('stacks/build_command')
+  subcommand ["reg", "registry"], "Stack registry related commands", load_subcommand('stacks/registry_command')
+  subcommand "validate", "Process and validate a stack file", load_subcommand('stacks/validate_command')
+  subcommand "stop", "Stop stacks services", load_subcommand('stacks/stop_command')
+  subcommand "restart", "Restart stacks services", load_subcommand('stacks/restart_command')
+  subcommand "label", "Stack label related commands", load_subcommand('stacks/label_command')
+
+  def execute
+  end
+end

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

@@ -0,0 +1,125 @@
+require_relative 'common'
+require 'shellwords'
+
+module Kontena::Cli::Stacks
+  class BuildCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    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: :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
+    option ['--no-pull'], :flag, 'Do not attempt to pull a newer version of the image', default: false
+    option ['--[no-]sudo'], :flag, 'Run docker using sudo', hidden: Kontena.on_windows?, environment_variable: 'KONTENA_SUDO', default: false
+
+    option ['-n', '--name'], 'NAME', 'Define stack name (by default comes from stack file)'
+
+    include Common::StackValuesToOption
+    include Common::StackValuesFromOption
+
+    parameter "[SERVICE] ...", "Services to build"
+
+    requires_current_master # the stack may use a vault resolver
+    requires_current_master_token
+
+    def execute
+      set_env_variables(stack_name, current_grid)
+      stack # runs validations
+
+      services = stack['services']
+
+      unless service_list.empty?
+        services.select! { |service| service_list.include?(service['name']) }
+      end
+
+      if services.none?{ |service| service['build'] }
+        abort pastel.red("Didn't find any services to build")
+      end
+      build_docker_images(services)
+      push_docker_images(services) unless no_push?
+    end
+
+    # @param [Hash] services
+    def build_docker_images(services)
+      services.each do |service|
+        if service['build']
+          dockerfile = service['build']['dockerfile'] || 'Dockerfile'
+          abort("'#{service['image']}' is not valid Docker image name") unless valid_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 pastel.cyan("Running pre_build hook")
+            run_pre_build_hook(service['hooks']['pre_build'])
+          end
+          puts "Building image #{pastel.cyan(service['image'])}"
+          build_docker_image(service)
+        end
+      end
+    end
+
+    # @param [Hash] services
+    def push_docker_images(services)
+      services.each do |service|
+        if service['build']
+          puts "Pushing image #{pastel.cyan(service['image'])}"
+          push_docker_image(service['image'])
+        end
+      end
+    end
+
+    # @param [Hash] service
+    # @return [Integer]
+    def build_docker_image(service)
+      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?
+      cmd.unshift('sudo') if sudo?
+
+      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 #{pastel.cyan(service['image'])}") unless ret
+      ret
+    end
+
+    # @param [String] image
+    # @return [Integer]
+    def push_docker_image(image)
+      cmd = ['docker', 'push', image]
+      cmd.unshift('sudo') if sudo?
+      ret = system(*cmd)
+      raise ("Failed to push image #{pastel.cyan(image)}") unless ret
+      ret
+    end
+
+    # @param [String] name
+    # @return [Boolean]
+    def valid_image_name?(name)
+      !(/\A[\w.\/\-:]+:?+[\w+.]+\z/ =~ name).nil?
+    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