krates 1.6.0

data/lib/kontena/command.rb

@@ -0,0 +1,251 @@
+require 'clamp'
+require 'kontena/cli/subcommand_loader'
+require 'kontena/util'
+require 'kontena/cli/bytes_helper'
+require 'kontena/cli/grid_options'
+require 'excon/error'
+
+Clamp.allow_options_after_parameters = true
+
+class Kontena::Command < Clamp::Command
+  option ['-D', '--[no-]debug'], :flag, "Enable debug", environment_variable: 'DEBUG', attribute_name: :debug_option do |debug|
+    unless debug.kind_of?(String)
+      ENV['DEBUG'] = debug.to_s
+      Kontena.reset_logger
+    end
+  end
+
+  attr_accessor :arguments
+  attr_reader :result
+  attr_reader :exit_code
+
+  module Finalizer
+    def self.extended(obj)
+      # Tracepoint is used to trigger finalize once the command is completely
+      # loaded. If done through def self.inherited the finalizer and
+      # after_load callbacks would run before the options are defined.
+      TracePoint.trace(:end) do |t|
+        if obj == t.self
+          obj.finalize
+          t.disable
+        end
+      end
+    end
+
+    def finalize
+      return if self.has_subcommands?
+      return if self.callback_matcher
+
+      name_parts = self.name.split('::')[-2, 2]
+
+      unless name_parts.compact.empty?
+        # 1: Remove trailing 'Command' from for example AuthCommand
+        # 2: Convert the string from CamelCase to under_score
+        # 3: Convert the string into a symbol
+        #
+        # In comes: ['ExternalRegistry', 'UseCommand']
+        # Out goes: [:external_registry, :use]
+        name_parts = name_parts.map { |np|
+          np.gsub(/Command$/, '').
+          gsub(/([A-Z]+)([A-Z][a-z])/,'\1_\2').
+          gsub(/([a-z\d])([A-Z])/,'\1_\2').
+          tr("-", "_").
+          downcase.
+          to_sym
+        }
+        self.callback_matcher(*name_parts)
+      end
+
+      # Run all #after_load callbacks for this command.
+      [name_parts.last, :all].compact.uniq.each do |cmd_type|
+        [name_parts.first, :all].compact.uniq.each do |cmd_class|
+          if Kontena::Callback.callbacks.fetch(cmd_class, {}).fetch(cmd_type, nil)
+            Kontena::Callback.callbacks[cmd_class][cmd_type].each do |cb|
+              if cb.instance_methods.include?(:after_load)
+                cb.new(self).after_load
+              end
+            end
+          end
+        end
+      end
+    end
+  end
+
+  def self.load_subcommand(path)
+    Kontena::Cli::SubcommandLoader.new(path)
+  end
+
+  def self.inherited(where)
+    where.extend Finalizer
+  end
+
+  def self.callback_matcher(cmd_class = nil, cmd_type = nil)
+    unless cmd_class
+      if @command_class.nil?
+        return nil
+      else
+        return [@command_class, @command_type]
+      end
+    end
+    @command_class = cmd_class.to_sym
+    @command_type = cmd_type.to_sym
+    [@command_class, @command_type]
+  end
+
+  def run_callbacks(state)
+    if self.class.respond_to?(:callback_matcher) && !self.class.callback_matcher.nil? && !self.class.callback_matcher.compact.empty?
+      Kontena::Callback.run_callbacks(self.class.callback_matcher, state, self)
+    end
+  end
+
+  # Overwrite Clamp's banner command. Calling banner multiple times
+  # will now add lines to the banner message instead of overwriting
+  # the whole message. This is useful if callbacks add banner messages.
+  #
+  # @param [String] message
+  def self.banner(msg, extra_feed = true)
+    self.description = [self.description, extra_feed ? "\n#{msg}" : msg].compact.join("\n")
+  end
+
+  def self.requires_current_master
+    unless Kontena::Cli::Config.current_master
+      banner "#{Kontena.pastel.green("Requires current master")}: This command requires that you have selected a current master using 'kontena master login' or 'kontena master use'. You can also use the environment variable KONTENA_URL to specify the master address or KONTENA_MASTER=master_name to override the current_master setting."
+    end
+    @requires_current_master = true
+  end
+
+  def self.requires_current_grid
+    unless Kontena::Cli::Config.current_grid
+      banner "#{Kontena.pastel.green("Requires current grid")}: This command requires that you have selected a grid as the current grid using 'kontena grid use' or by setting KONTENA_GRID environment variable."
+    end
+    @requires_current_grid = true
+  end
+
+  def self.requires_current_account_token
+    unless Kontena::Cli::Config.current_account && Kontena::Cli::Config.current_account.token && Kontena::Cli::Config.current_account.token.access_token
+      banner "#{Kontena.pastel.green("Requires account authentication")}: This command requires that you have authenticated to Kontena Cloud using 'kontena cloud auth'"
+    end
+    @requires_current_account_token = true
+  end
+
+
+  def self.requires_current_master?
+    @requires_current_master ||= false
+  end
+
+  def verify_current_master
+    Kontena::Cli::Config.instance.require_current_master if self.class.requires_current_master?
+  end
+
+  def self.requires_current_grid?
+    @requires_current_grid ||= false
+  end
+
+  def verify_current_grid
+    Kontena::Cli::Config.instance.require_current_grid if self.class.requires_current_grid?
+  end
+
+  def self.requires_current_account_token?
+    @requires_current_account_token ||= false
+  end
+
+  def verify_current_account_token
+    retried ||= false
+    Kontena::Cli::Config.instance.require_current_account_token if self.class.requires_current_account_token?
+  end
+
+  def self.requires_current_master_token
+    @requires_current_master_token = true
+  end
+
+  def self.requires_current_master_token?
+    @requires_current_master_token ||= false
+  end
+
+  def verify_current_master_token
+    return nil unless self.class.requires_current_master_token?
+    retried ||= false
+    Kontena::Cli::Config.instance.require_current_master_token
+  rescue Kontena::Cli::Config::TokenExpiredError
+    server = Kontena::Cli::Config.instance.current_master
+    success = Kontena::Client.new(server.url, server.token,
+      ssl_cert_path: server.ssl_cert_path,
+      ssl_subject_cn: server.ssl_subject_cn,
+    ).refresh_token
+    if success && !retried
+      retried = true
+      retry
+    else
+      raise Kontena::Cli::Config::TokenExpiredError, "The access token has expired and refresh failed. Try authenticating again, use: kontena master login"
+    end
+  end
+
+  def help_requested?
+    return true if @arguments.include?('--help')
+    return true if @arguments.include?('-h')
+    false
+  end
+
+  # Returns an instance of the command, just like with Kontena.run! but before calling "execute"
+  # You can use it for specs or reuse of instancemethods.
+  # Example:
+  #   cmd = Kontena::FooCommand.instance(['-n', 'foo'])
+  #   cmd.fetch_stuff
+  def instance(arguments)
+    @arguments = arguments
+    parse @arguments
+    self
+  end
+
+  def run(arguments)
+    Kontena.logger.debug { "Running #{self.class.name} with #{arguments.inspect} -- 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?
+
+    parse @arguments
+
+    unless help_requested?
+      verify_current_master
+      verify_current_master_token
+      verify_current_grid
+      run_callbacks :before
+    end
+
+    begin
+      @result = execute
+      @exit_code = @result.kind_of?(FalseClass) ? 1 : 0
+    rescue SystemExit => exc
+      @result = exc.status == 0
+      @exit_code = exc.status
+    end
+    run_callbacks :after unless help_requested?
+    exit(@exit_code) if @exit_code.to_i > 0
+    @result
+  rescue Excon::Error::Socket => 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 "         If kontena cannot find your system ca bundle, you can set #{Kontena.pastel.yellow('SSL_CERT_DIR=/etc/ssl/certs')} env variable to load them from another location."
+      $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(ex.message)
+    end
+  rescue Kontena::Errors::StandardError => ex
+    raise ex if Kontena.debug?
+    Kontena.logger.error(ex)
+    abort(" [#{Kontena.pastel.red('error')}] #{ex.status} : #{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 => ex
+    raise ex if Kontena.debug?
+    Kontena.logger.error(ex)
+    abort(" [#{Kontena.pastel.red('error')}] #{ex.class.name} : #{ex.message}\n         See #{Kontena.log_target} or run the command again with environment DEBUG=true set to see the full exception")
+  end
+end
+
+require 'kontena/callback'

data/lib/kontena/debug_instrumentor.rb

@@ -0,0 +1,80 @@
+require 'uri'
+module Kontena
+  class DebugInstrumentor
+    def self.instrument(name, params = {}, &block)
+      result = []
+      params = params.dup
+
+      direction = name.split('.').last.capitalize
+
+      if direction == 'Request'
+        uri = URI.parse("#{params[:scheme]}://#{params[:host]}:#{params[:port]}")
+        uri.path = params[:path].nil? ? '/' : params[:path].split('?', 2).first
+        uri.query = URI.encode_www_form(params[:query]) if params[:query] && !params[:query].empty?
+        str = "#{params[:method].to_s.upcase} #{uri}"
+        str << " (ssl_verify: #{params[:ssl_verify_peer]}) " if params[:scheme] == 'https'
+        result << str
+      end
+
+      if params[:headers]
+        str = "Headers: {"
+        heads = []
+        heads << "Accept: #{params[:headers]['Accept']}" if params[:headers]['Accept']
+        heads << "Accept-Encoding: #{params[:headers]['Accept-Encoding']}" if params[:headers]['Accept-Encoding']
+        heads << "Content-Type: #{params[:headers]['Content-Type']}" if params[:headers]['Content-Type']
+        heads << "Content-Encoding: #{params[:headers]['Content-Encoding']}" if params[:headers]['Content-Encoding']
+        heads << "Authorization: #{params[:headers]['Authorization'].split(' ', 2).first}" if params[:headers]['Authorization']
+        heads << "X-Kontena-Version: #{params[:headers]['X-Kontena-Version']}" if params[:headers]['X-Kontena-Version']
+        str << heads.join(', ')
+        str << "} "
+        result << str
+      end
+
+      if params[:status]
+        str = "Status: "
+        if params[:status] < 299
+          str << Kontena.pastel.green(params[:status])
+        else
+          str << Kontena.pastel.red(params[:status])
+        end
+        result << str
+      end
+
+      if params[:body] && !params[:body].empty?
+        if params[:headers]['Content-Encoding'].to_s =~ /gzip/
+          body_content = Zlib::GzipReader.new(StringIO.new(params[:body])).read
+          body = "(GZIPPED 1:%d) %s" % [body_content.bytesize / params[:body].bytesize, body_content]
+        else
+          body = params[:body]
+        end
+
+        str = "Body: "
+        if ENV["DEBUG"] == "api"
+          str << "\n"
+          str << body
+        else
+          body = body.inspect.strip
+          str << body[0,80]
+          if body.length > 80
+            str << "...\""
+          end
+        end
+        result << str
+      elsif params[:error]
+        result << params[:error]
+      end
+
+      color = case direction
+              when 'Request' then :blue
+              when 'Response' then :magenta
+              else :red
+              end
+
+      Kontena.logger.debug("CLIENT") { Kontena.pastel.send(color, "[#{direction}]: #{result.join(" | ")}") }
+
+      if block_given?
+        yield
+      end
+    end
+  end
+end

data/lib/kontena/errors.rb

@@ -0,0 +1,50 @@
+module Kontena
+  module Errors
+    class StandardError < ::StandardError
+
+      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")
+        require 'yaml'
+        @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/light_prompt.rb

@@ -0,0 +1,103 @@
+require 'tty-prompt'
+require 'pastel'
+
+module Kontena
+  class LightPrompt
+
+    attr_reader :prompt
+
+    extend Forwardable
+
+    class Menu
+      attr_reader :choices, :calls
+
+      def initialize
+        @choices = []
+        @calls = {}
+      end
+
+      def choice(text, label)
+        choices << [text, label]
+      end
+
+      def add_quit_choice
+        choice('(done)', :done)
+      end
+
+      def remove_choice(value)
+        choices.reject! { |c| c.last == value }
+      end
+
+      def remove_choices(values)
+        values.each { |v| remove_choice(v) }
+      end
+
+      def method_missing(meth, *args)
+        calls[meth] = args
+      end
+
+      def respond_to_missing?(meth, privates = false)
+        prompt.respond_to?(meth, privates)
+      end
+    end
+
+    def initialize(options={})
+      @prompt = TTY::Prompt.new(options)
+    end
+
+    def select(*args, &block)
+      choice_collector = Menu.new
+      yield choice_collector
+
+      prompt.enum_select(*args) do |menu|
+        choice_collector.calls.each do |meth, args|
+          if menu.respond_to?(meth)
+            menu.send(meth, *args)
+          end
+        end
+        choice_collector.choices.each do |choice|
+          menu.choice choice.first, choice.last
+        end
+      end
+    end
+
+    def multi_select(*args, &block)
+      choice_collector = Menu.new
+      yield choice_collector
+      choice_collector.add_quit_choice
+
+      selections = []
+
+      loop do
+        choice_collector.remove_choices(selections)
+
+        answer = prompt.enum_select(*args) do |menu|
+          choice_collector.calls.each do |meth, args|
+            if menu.respond_to?(meth)
+              menu.send(meth, *args)
+            end
+          end
+          choice_collector.choices.each do |choice|
+            menu.choice choice.first, choice.last
+          end
+        end
+
+        break if answer == :done
+        selections << answer
+      end
+
+      selections
+    end
+
+
+    def_delegators :prompt, :ask, :yes?, :error
+
+    def method_missing(meth, *args)
+      prompt.send(meth, *args)
+    end
+
+    def respond_to_missing?(meth, privates = false)
+      prompt.respond_to?(meth, privates)
+    end
+  end
+end

data/lib/kontena/machine/cert_helper.rb

@@ -0,0 +1,43 @@
+require 'openssl'
+
+module Kontena
+  module Machine
+    module CertHelper
+
+      def certificate_public_key(cert)
+        cert[/(-----BEGIN CERTIFICATE-----.+?-----END CERTIFICATE-----)/m, 1]
+      end
+
+      def generate_self_signed_cert
+        key = OpenSSL::PKey::RSA.new(2048)
+        public_key = key.public_key
+
+        subject = "/C=FI/O=Test/OU=Test/CN=Test"
+
+        cert = OpenSSL::X509::Certificate.new
+        cert.subject = cert.issuer = OpenSSL::X509::Name.parse(subject)
+        cert.not_before = Time.now
+        cert.not_after = Time.now + (10 * 365 * 24 * 60 * 60)
+        cert.public_key = public_key
+        cert.serial = 0x0
+        cert.version = 2
+
+        ef = OpenSSL::X509::ExtensionFactory.new
+        ef.subject_certificate = cert
+        ef.issuer_certificate = cert
+        cert.extensions = [
+          ef.create_extension("basicConstraints","CA:TRUE", true),
+          ef.create_extension("subjectKeyIdentifier", "hash")
+        ]
+        cert.add_extension ef.create_extension("authorityKeyIdentifier",
+                                               "keyid:always,issuer:always")
+
+        cert.sign key, OpenSSL::Digest::SHA1.new
+
+        pem = cert.to_pem
+        pem << key.to_s
+        pem
+      end
+    end
+  end
+end

data/lib/kontena/machine/cloud_config/cloudinit.yml

@@ -0,0 +1,82 @@
+#cloud-config
+write_files:
+  - path: /etc/kontena-agent.env
+    permissions: 0600
+    owner: root
+    content: |
+      KONTENA_URI="<%= master_uri %>"
+      KONTENA_TOKEN="<%= grid_token %>"
+      KONTENA_PEER_INTERFACE=<%= peer_interface %>
+      KONTENA_VERSION=<%= version %>
+  - path: /etc/systemd/system/docker.service.d/50-kontena.conf
+    content: |
+        [Service]
+        Environment='DOCKER_OPTS=--insecure-registry="<%= grid_subnet %>" --bip="<%= docker_bip %>"'
+  - path: /etc/sysctl.d/99-inotify.conf
+    owner: root
+    permissions: 0644
+    content: |
+      fs.inotify.max_user_instances = 8192
+coreos:
+  units:
+    - name: 50-weave.network
+      content: |
+        [Match]
+        Name=weave datapath vxlan-6784
+
+        [Network]
+        Description=Network interfaces managed by weave
+
+        [Link]
+        Unmanaged=true
+    - name: 90-dummy.network
+      content: |
+        [Match]
+        Name=dummy0
+
+        [Link]
+        Unmanaged=true
+    - name: zz-default.network
+      content: |
+        # default should not match virtual Docker/weave bridge/veth network interfaces
+        [Match]
+        Name=<%= match_default_network_name %>
+
+        [Network]
+        DHCP=yes
+        <% dns_servers.each do |dns| %>DNS=<%= dns %>
+        <% end %>
+        Domains=kontena.local
+
+        [DHCP]
+        UseMTU=true
+        UseDNS=false
+
+    - name: kontena-agent.service
+      command: start
+      enable: true
+      content: |
+        [Unit]
+        Description=kontena-agent
+        After=network-online.target
+        After=docker.service
+        Description=Kontena Agent
+        Documentation=http://www.kontena.io/
+        Requires=network-online.target
+        Requires=docker.service
+
+        [Service]
+        Restart=always
+        RestartSec=5
+        EnvironmentFile=/etc/kontena-agent.env
+        ExecStartPre=-/usr/bin/docker stop kontena-agent
+        ExecStartPre=-/usr/bin/docker rm kontena-agent
+        ExecStartPre=/usr/bin/docker pull kontena/agent:${KONTENA_VERSION}
+        ExecStart=/usr/bin/docker run --name kontena-agent \
+            -e KONTENA_URI=${KONTENA_URI} \
+            -e KONTENA_TOKEN=${KONTENA_TOKEN} \
+            -e KONTENA_PEER_INTERFACE=${KONTENA_PEER_INTERFACE} \
+            -v=/var/run/docker.sock:/var/run/docker.sock \
+            -v=/etc/kontena-agent.env:/etc/kontena.env \
+            --net=host \
+            kontena/agent:${KONTENA_VERSION}

data/lib/kontena/machine/cloud_config/node_generator.rb

@@ -0,0 +1,28 @@
+require 'fileutils'
+require 'erb'
+
+module Kontena
+  module Machine
+    module CloudConfig
+      class NodeGenerator
+
+        # @param [Hash] opts
+        def generate(opts)
+          user_data(opts)
+        end
+
+        # @param [Hash] vars
+        def user_data(vars)
+          cloudinit_template = File.join(__dir__ , '/cloudinit.yml')
+          erb(File.read(cloudinit_template), vars)
+        end
+
+        # @param [String] template
+        # @param [Hash] vars
+        def erb(template, vars)
+          ERB.new(template).result(OpenStruct.new(vars).instance_eval { binding })
+        end
+      end
+    end
+  end
+end

data/lib/kontena/machine/common.rb

@@ -0,0 +1,17 @@
+module Kontena
+  module Machine
+    module Common
+
+      def which(cmd)
+        exts = ENV['PATHEXT'] ? ENV['PATHEXT'].split(';') : ['']
+        ENV['PATH'].split(File::PATH_SEPARATOR).each do |path|
+          exts.each { |ext|
+            exe = File.join(path, "#{cmd}#{ext}")
+            return exe if File.executable?(exe) && !File.directory?(exe)
+          }
+        end
+        return nil
+      end
+    end
+  end
+end