krates 1.6.0

data/lib/kontena/cli/grids/use_command.rb

@@ -0,0 +1,26 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class UseCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    requires_current_master
+
+    parameter "NAME", "Grid name to use"
+
+    option ['--silent'], :flag, 'Reduce output verbosity'
+
+    def execute
+      grid = find_grid_by_name(name)
+      unless grid
+        exit_with_error pastel.red("Could not resolve grid by name [#{name}]. For a list of existing grids please run: kontena grid list")
+      end
+      config.current_master.grid = grid['name']
+      config.write
+      unless self.silent?
+        puts "Using grid: #{pastel.cyan(grid['name'])}"
+      end
+    end
+  end
+end

data/lib/kontena/cli/grids/user_command.rb

@@ -0,0 +1,9 @@
+module Kontena::Cli::Grids
+
+
+  class UserCommand < Kontena::Command
+    subcommand ["list", "ls"], "List grid users", load_subcommand('grids/users/list_command')
+    subcommand "add", "Add user to grid", load_subcommand('grids/users/add_command')
+    subcommand ["remove", "rm"], "Remove user from grid", load_subcommand('grids/users/remove_command')
+  end
+end

data/lib/kontena/cli/grids/users/add_command.rb

@@ -0,0 +1,18 @@
+require_relative '../common'
+
+module Kontena::Cli::Grids::Users
+  class AddCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::Grids::Common
+
+    parameter "EMAIL", "Email address"
+
+    def execute
+      require_api_url
+      token = require_token
+      data = { email: email }
+      client(token).post("grids/#{current_grid}/users", data)
+    end
+  end
+end

data/lib/kontena/cli/grids/users/list_command.rb

@@ -0,0 +1,20 @@
+require_relative '../common'
+
+module Kontena::Cli::Grids::Users
+  class ListCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::Grids::Common
+    include Kontena::Cli::TableGenerator::Helper
+    include Kontena::Cli::GridOptions
+
+    requires_current_master
+
+    def fields
+      quiet? ? %w(email) : %w(email name)
+    end
+
+    def execute
+      print_table(client.get("grids/#{current_grid}/users")['users'])
+    end
+  end
+end

data/lib/kontena/cli/grids/users/remove_command.rb

@@ -0,0 +1,20 @@
+require_relative '../common'
+
+module Kontena::Cli::Grids::Users
+  class RemoveCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::Grids::Common
+
+    parameter "EMAIL", "Email address"
+    option "--force", :flag, "Force remove", default: false, attribute_name: :forced
+
+    def execute
+      require_api_url
+      token = require_token
+      confirm_command(email) unless forced?
+
+      result = client(token).delete("grids/#{current_grid}/users/#{email}")
+    end
+  end
+end

data/lib/kontena/cli/helpers/exec_helper.rb

@@ -0,0 +1,209 @@
+require 'io/console'
+require 'tty-screen'
+require 'kontena-websocket-client'
+
+module Kontena::Cli::Helpers
+  module ExecHelper
+
+    websocket_log_level = if ENV["DEBUG"] == 'websocket'
+      Logger::DEBUG
+    elsif Kontena.debug?
+      Logger::INFO
+    else
+      Logger::WARN
+    end
+
+    Kontena::Websocket::Logging.initialize_logger(STDERR, websocket_log_level)
+
+    WEBSOCKET_CLIENT_OPTIONS = {
+      connect_timeout: ENV["EXCON_CONNECT_TIMEOUT"] ? ENV["EXCON_CONNECT_TIMEOUT"].to_f : 10.0,
+      open_timeout:    ENV["EXCON_CONNECT_TIMEOUT"] ? ENV["EXCON_CONNECT_TIMEOUT"].to_f : 10.0,
+      ping_interval:   ENV["EXCON_READ_TIMEOUT"]    ? ENV["EXCON_READ_TIMEOUT"].to_f    : 30.0,
+      ping_timeout:    ENV["EXCON_CONNECT_TIMEOUT"] ? ENV["EXCON_CONNECT_TIMEOUT"].to_f : 10.0,
+      close_timeout:   ENV["EXCON_CONNECT_TIMEOUT"] ? ENV["EXCON_CONNECT_TIMEOUT"].to_f : 10.0,
+      write_timeout:   ENV["EXCON_WRITE_TIMEOUT"]   ? ENV["EXCON_WRITE_TIMEOUT"].to_f   : 10.0,
+    }
+
+    # @param ws [Kontena::Websocket::Client]
+    # @param tty [Boolean] read stdin in raw mode, sending tty escapes for remote pty
+    # @raise [ArgumentError] not a tty
+    # @yield [data]
+    # @yieldparam data [String] unicode data from stdin
+    # @raise [ArgumentError] not a tty
+    # @return EOF on stdin (!tty)
+    def read_stdin(tty: nil)
+      if tty
+        # NOTE: This check has been disabled since tests in Jenkins are run without TTY allocation
+        # raise ArgumentError, "the input device is not a TTY" unless STDIN.tty?
+
+        STDIN.raw { |io|
+          # we do not expect EOF on a TTY, ^D sends a tty escape to close the pty instead
+          loop do
+            # raises EOFError, SyscallError or IOError
+            chunk = io.readpartial(1024)
+
+            # STDIN.raw does not use the ruby external_encoding, it returns binary strings (ASCII-8BIT encoding)
+            # however, we use websocket text frames with JSON, which expects unicode strings encodable as UTF-8, and does not handle arbitrary binary data
+            # assume all stdin input is using ruby's external_encoding... the JSON.dump will fail if not.
+            chunk.force_encoding(Encoding.default_external)
+
+            yield chunk
+          end
+        }
+      else
+        # line-buffered, using the default external_encoding (probably UTF-8)
+        while line = STDIN.gets
+          yield line
+        end
+      end
+    end
+
+    # @return [String]
+    def websocket_url(path, query = nil)
+      url = URI.parse(require_current_master.url)
+      url.scheme = url.scheme.sub('http', 'ws')
+      url.path = '/v1/' + path
+      url.query = (query && !query.empty?) ? URI.encode_www_form(query) : nil
+      url.to_s
+    end
+
+    # @param ws [Kontena::Websocket::Client]
+    # @raise [RuntimeError] exec error
+    # @return [Integer] exit code
+    def websocket_exec_read(ws)
+      ws.read do |msg|
+        msg = JSON.parse(msg)
+
+        logger.debug "websocket exec read: #{msg.inspect}"
+
+        if msg.has_key?('error')
+          raise msg['error']
+        elsif msg.has_key?('exit')
+          # breaks the read loop
+          return msg['exit'].to_i
+        elsif msg.has_key?('stream')
+          if msg['stream'] == 'stdout'
+            $stdout << msg['chunk']
+          else
+            $stderr << msg['chunk']
+          end
+        end
+      end
+    end
+
+    # @param ws [Kontena::Websocket::Client]
+    # @param msg [Hash]
+    def websocket_exec_write(ws, msg)
+      logger.debug "websocket exec write: #{msg.inspect}"
+
+      ws.send(JSON.dump(msg))
+    end
+
+    # Start thread to read from stdin, and write to websocket.
+    # Closes websocket on stdin read errors.
+    #
+    # @param ws [Kontena::Websocket::Client]
+    # @param tty [Boolean]
+    # @return [Thread]
+    def websocket_exec_write_thread(ws, tty: nil)
+      Thread.new do
+        begin
+          if tty
+            console_height, console_width = TTY::Screen.size
+            websocket_exec_write(ws, 'tty_size' => {
+              width: console_width, height: console_height
+            })
+          end
+          read_stdin(tty: tty) do |stdin|
+            logger.debug "websocket exec stdin with encoding=#{stdin.encoding}: #{stdin.inspect}"
+            websocket_exec_write(ws, 'stdin' => stdin)
+          end
+          websocket_exec_write(ws, 'stdin' => nil) # EOF
+        rescue => exc
+          logger.error exc
+          ws.close(1001, "stdin read #{exc.class}: #{exc}")
+        end
+      end
+    end
+
+    # Connect to server websocket, send from stdin, and write out messages
+    #
+    # @param paths [String]
+    # @param options [Hash] @see Kontena::Websocket::Client
+    # @param cmd [Array<String>] command to execute
+    # @param interactive [Boolean] Interactive TTY on/off
+    # @param shell [Boolean] Shell on/of
+    # @param tty [Boolean] TTY on/of
+    # @return [Integer] exit code
+    def websocket_exec(path, cmd, interactive: false, shell: false, tty: false)
+      exit_status = nil
+      write_thread = nil
+
+      query = {}
+      query[:interactive] = interactive if interactive
+      query[:shell] = shell if shell
+      query[:tty] = tty if tty
+
+      server = require_current_master
+      url = websocket_url(path, query)
+      token = require_token
+      options = WEBSOCKET_CLIENT_OPTIONS.dup
+      options[:headers] = {
+          'Authorization' => "Bearer #{token.access_token}"
+      }
+      options[:ssl_params] = {
+          verify_mode: ENV['SSL_IGNORE_ERRORS'].to_s == 'true' ? OpenSSL::SSL::VERIFY_NONE : OpenSSL::SSL::VERIFY_PEER,
+          ca_file: server.ssl_cert_path,
+      }
+      options[:ssl_hostname] = server.ssl_subject_cn
+
+      logger.debug { "websocket exec connect... #{url}" }
+
+      # we do not expect CloseError, because the server will send an 'exit' message first,
+      # and we return before seeing the close frame
+      # TODO: handle HTTP 404 errors
+      Kontena::Websocket::Client.connect(url, **options) do |ws|
+        logger.debug { "websocket exec open" }
+
+        # first frame contains exec command
+        websocket_exec_write(ws, 'cmd' => cmd)
+
+        if interactive
+          # start new thread to write from stdin to websocket
+          write_thread = websocket_exec_write_thread(ws, tty: tty)
+        end
+
+        # blocks reading from websocket, returns with exec exit code
+        exit_status = websocket_exec_read(ws)
+
+        fail ws.close_reason unless exit_status
+      end
+
+    rescue Kontena::Websocket::Error => exc
+      exit_with_error(exc)
+
+    rescue => exc
+      logger.error { "websocket exec error: #{exc}" }
+      raise
+
+    else
+      logger.debug { "websocket exec exit: #{exit_status}"}
+      return exit_status
+
+    ensure
+      if write_thread
+        write_thread.kill
+        write_thread.join
+      end
+    end
+
+    # Execute command on container using websocket API.
+    #
+    # @param id [String] Container ID (grid/host/name)
+    # @param cmd [Array<String>] command to execute
+    # @return [Integer] exit code
+    def container_exec(id, cmd, **exec_options)
+      websocket_exec("containers/#{id}/exec", cmd, **exec_options)
+    end
+  end
+end

data/lib/kontena/cli/helpers/health_helper.rb

@@ -0,0 +1,65 @@
+module Kontena::Cli::Helpers
+  module HealthHelper
+    def health_icon(health)
+      case health
+      when nil
+        " "
+      when :ok
+        pastel.green('⊛')
+      when :warning
+        pastel.yellow('⊙')
+      when :error
+        pastel.red('⊗')
+      when :offline
+        pastel.dark('⊝')
+      else
+        fail "Invalid health=#{health}"
+      end
+    end
+
+    # Validate grid nodes configuration and status
+    #
+    # @param grid [Hash] get(/grids/:grid) => { ... }
+    # @param nodes [Array<Hash>] get(/grids/:grid/nodes)[nodes] => [ { ... } ]
+    # @return [Symbol] health
+    def grid_health(grid, nodes)
+      initial = grid['initial_size']
+      minimum = grid['initial_size'] / 2 + 1 # a majority is required for etcd quorum
+
+      online = nodes.select{|node| node['initial_member'] && node['connected']}
+
+      if online.length < minimum
+        return :error
+      elsif online.length < initial
+        return :warning
+      else
+        return :ok
+      end
+    end
+
+    # Validate grid node status based on the grid health
+    #
+    # @param node [Hash] GET /nodes/:grid/:node
+    # @param grid_health [Symbol] @see #grid_health
+    # @return [Symbol] health
+    def node_health(node, grid_health)
+      if node['initial_member']
+        return node['connected'] ? grid_health : :offline
+      else
+        return node['connected'] ? :ok : :offline
+      end
+    end
+
+    # @param node_etcd_health [Hash{health: String, error: String}]
+    # @return [Symbol, String]
+    def node_etcd_health(node_etcd_health)
+      if node_etcd_health['health']
+        return :ok, "healthy"
+      elsif node_etcd_health['error']
+        return :error, "unhealthy: #{node_etcd_health['error']}"
+      else
+        return :error, "unhealthy"
+      end
+    end
+  end
+end

data/lib/kontena/cli/helpers/log_helper.rb

@@ -0,0 +1,113 @@
+module Kontena::Cli::Helpers
+  module LogHelper
+
+    def self.included(base)
+      if base.respond_to?(:option)
+        base.option ["-f", "--follow"], :flag, "Follow log output", :attribute_name => :tail, default: false
+        base.option ['--tail', '--lines'], "LINES", "Number of lines to show from the end of the logs", :attribute_name => :lines, default: 100 do |s|
+          Integer(s)
+        end
+        base.option "--since", "SINCE", "Show logs since given timestamp"
+      end
+    end
+
+    # @return [String]
+    def token
+      @token ||= require_token
+    end
+
+    def show_logs(url, query_params = { }, &block)
+      if tail?
+        stream_logs(url, query_params, &block)
+      else
+        get_logs(url, query_params, &block)
+      end
+    end
+
+    def get_logs(url, query_params)
+      query_params[:limit] = lines if lines
+      query_params[:since] = since if since
+
+      result = client(token).get(url, query_params)
+      result['logs'].each do |log|
+        yield log
+      end
+    end
+
+    # @param [String] url
+    # @param [Hash] query_params
+    def stream_logs(url, query_params)
+      query_params[:limit] = lines if lines
+      query_params[:since] = since if since
+      query_params[:follow] = 1
+
+      last_seen = nil
+      streamer = lambda do |chunk, remaining_bytes, total_bytes|
+        log = buffered_log_json(chunk)
+        if log
+          yield log
+          last_seen = log['id']
+        end
+      end
+
+      begin
+        query_params[:from] = last_seen if last_seen
+        client(token).get_stream(url, streamer, query_params)
+      rescue => exc
+        retry if exc.cause.is_a?(EOFError) # Excon wraps the EOFerror into SocketError
+        raise
+      end
+    end
+
+    # @param [String] chunk
+    # @return [Hash,NilClass]
+    def buffered_log_json(chunk)
+      @buffer = '' if @buffer.nil?
+      return if @buffer.empty? && chunk.strip.empty?
+      begin
+        orig_chunk = chunk
+        unless @buffer.empty?
+          chunk = @buffer + chunk
+        end
+        unless chunk.empty?
+          log = JSON.parse(chunk)
+        end
+        @buffer = ''
+        log
+      rescue
+        @buffer << orig_chunk
+        nil
+      end
+    end
+
+    def show_log(log)
+      color = color_for_container(log['name'])
+      prefix = "#{log['created_at']} #{log['name']}:"
+
+      puts "#{pastel.send(color, prefix)} #{log['data']}"
+    end
+
+    # @param [String] container_id
+    # @return [Symbol]
+    def color_for_container(container_id)
+      color_maps[container_id] = colors.shift unless color_maps[container_id]
+      color_maps[container_id].to_sym
+    end
+
+    # @return [Hash]
+    def color_maps
+      @color_maps ||= {}
+    end
+
+    # @return [Array<Symbol>]
+    def colors
+      if(@colors.nil? || @colors.size == 0)
+        @colors = %i(
+          red green yellow blue magenta cyan bright_red bright_green
+          bright_yellow bright_blue bright_magenta bright_cyan
+        )
+      end
+      @colors
+    end
+  end
+end

data/lib/kontena/cli/helpers/time_helper.rb

@@ -0,0 +1,29 @@
+module Kontena::Cli::Helpers
+  module TimeHelper
+    # Return an approximation of how long ago the given time was.
+    # @param time [String]
+    # @param terse [Boolean] very terse output (2-3 chars wide)
+    def time_since(time, terse: false)
+      return '' if time.nil? || time.empty?
+
+      dt = Time.now - Time.parse(time)
+
+      dt_s = dt.to_i
+      dt_m, dt_s = dt_s / 60, dt_s % 60
+      dt_h, dt_m = dt_m / 60, dt_m % 60
+      dt_d, dt_h = dt_h / 60, dt_h % 60
+
+      parts = []
+      parts << "%dd" % dt_d if dt_d > 0
+      parts << "%dh" % dt_h if dt_h > 0
+      parts << "%dm" % dt_m if dt_m > 0
+      parts << "%ds" % dt_s
+
+      if terse
+        return parts.first
+      else
+        return parts.join('')
+      end
+    end
+  end
+end

data/lib/kontena/cli/localhost_web_server.rb

@@ -0,0 +1,113 @@
+require 'socket'
+require 'uri'
+
+module Kontena
+  class LocalhostWebServer
+    # Serves one request to http://localhost:<random_port>/cb
+    #
+    # Used for local webserver browser authentication flow.
+    #
+    # @example
+    #   server = LocalhostWebServer.new
+    #   server.url
+    #    => "http://localhost:1234/cb"
+    #   response = server.serve_one
+    #   # <visit server.url?foo=bar&bar=123 on browser>
+    #    => { "foo" => "bar", "bar" => 123 }  # (it converts integers!)
+    attr_accessor :server, :success_response, :error_response, :port
+
+    DEFAULT_ERROR_MESSAGE   = "Bad request"
+    SUCCESS_URL             = "https://cloud.kontena.io/terminal-success"
+
+    # Get new server instance
+    #
+    # @param [String] success_response Returned for successful callback
+    # @param [String] error_response Returned for unsuccessful callback
+    def initialize(success_response: nil, error_response: nil, port: nil)
+      @success_response = success_response
+      @error_response   = error_response   || DEFAULT_ERROR_MESSAGE
+      @server = TCPServer.new('localhost', port || 0)
+      @port = @server.addr[1]
+    end
+
+    # The url to this service, send this as redirect_uri to auth provider.
+    def url
+      "http://localhost:#{port}/cb"
+    end
+
+    # Serve one request and return query params.
+    #
+    # @return [Hash] query_params
+    def serve_one
+      Kontena.logger.debug("LHWS") { "Waiting for connection on port #{port}.." }
+      socket = server.accept
+
+      content = socket.recvfrom(2048).first.split(/(?:\r)?\n/)
+
+      request = content.shift
+
+      headers = {}
+      while line = content.shift
+        break if line.nil?
+        break if line == ''
+        header, value = line.chomp.split(/:\s{0,}/, 2)
+        headers[header] = value
+      end
+
+      body = content.join("\n")
+
+      Kontena.logger.debug("LHWS") { "Got request: \"#{request.inspect}\n  Headers: #{headers.inspect}\n  Body: #{body}\"" }
+
+      get_request = request[/GET (\/cb.+?) HTTP/, 1]
+      if get_request
+        if success_response
+          socket.print [
+            'HTTP/1.1 200 OK',
+            'Content-Type: text/html',
+            "Content-Length: #{success_response.bytesize}",
+            "Connection: close",
+            '',
+            success_response
+          ].join("\r\n")
+        else
+          socket.print [
+            'HTTP/1.1 302 Found',
+            "Location: #{SUCCESS_URL}",
+            "Referrer-Policy: no-referrer",
+            "Connection: close",
+            ''
+          ].join("\r\n")
+        end
+
+        socket.close
+        server.close
+        uri = URI.parse("http://localhost#{get_request}")
+        Kontena.logger.debug("LHWS") { "  * Parsing params: \"#{uri.query}\"" }
+        params = {}
+        URI.decode_www_form(uri.query).each do |key, value|
+          if value.to_s == ''
+            next
+          elsif value.to_s =~ /\A\d+\z/
+            params[key] = value.to_i
+          else
+            params[key] = value
+          end
+        end
+        params
+      else
+        # Unless it's a query to /cb, send an error message and keep listening,
+        # it might have been something funny like fetching favicon.ico
+        socket.print [
+          'HTTP/1.1 400 Bad request',
+          'Content-Type: text/plain',
+          "Content-Length: #{error_response.bytesize}",
+          'Connection: close',
+          '',
+          error_response
+        ].join("\r\n")
+        socket.close
+        serve_one # serve more, this one was not proper.
+      end
+    end
+  end
+end

data/lib/kontena/cli/log_formatters/compact.rb

@@ -0,0 +1,65 @@
+require 'logger'
+
+module Kontena
+  module Cli
+    module LogFormatter
+      class Compact < Logger::Formatter
+        def self.ms_since_first
+          Time.now.to_f - @first_log
+        end
+
+        def self.ms_since_last
+          ((Time.now.to_f - @last_log) * 1000).to_i
+        ensure
+          @last_log = Time.now.to_f
+        end
+
+        def self.__init_timers__
+          @first_log = $KONTENA_START_TIME || Time.now.to_f
+          @last_log = @first_log
+        end
+
+        __init_timers__
+
+        DEBUG_INDICATOR = Kontena.pastel.inverse.bright_blue('DEBUG').freeze
+        WARN_INDICATOR  = Kontena.pastel.inverse.yellow('WARN ').freeze
+        INFO_INDICATOR  = Kontena.pastel.inverse.cyan('INFO ').freeze
+        ERROR_INDICATOR = Kontena.pastel.inverse.red('ERROR').freeze
+
+        def colorize_severity(severity)
+          case severity[0..0]
+          when 'D' then DEBUG_INDICATOR
+          when 'W' then WARN_INDICATOR
+          when 'I' then INFO_INDICATOR
+          when 'E', 'F' then ERROR_INDICATOR
+          else severity[0..0]
+          end
+        end
+
+        TS_FORMAT = '%4d'.freeze
+
+        def colorized_time
+          elapsed = self.class.ms_since_last
+          ts = TS_FORMAT % [elapsed]
+          if elapsed > 300
+            Kontena.pastel.red(ts)
+          elsif elapsed > 100
+            Kontena.pastel.yellow(ts)
+          else
+            ts
+          end
+        end
+
+        if ENV['DEBUG_PERF']
+          define_method :call do |severity, time, progname, msg|
+            "#{colorize_severity(severity)} #{colorized_time} #{msg2str(msg)}\n"
+          end
+        else
+          define_method :call do |severity, time, progname, msg|
+            "#{colorize_severity(severity)} #{msg2str(msg)}\n"
+          end
+        end
+      end
+    end
+  end
+end