krates 1.6.0

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

@@ -0,0 +1,182 @@
+module Kontena::Cli::Grids
+  module Common
+
+    ##
+    # @param [Hash] grid
+    def print_grid(grid)
+      host = ENV['KONTENA_URL'] || self.current_master['url']
+      puts "#{grid['name']}:"
+      puts "  uri: #{host.sub('http', 'ws')}"
+      puts "  initial_size: #{grid['initial_size']}"
+      puts "  default_affinity: "
+      grid['default_affinity'].to_a.each do |a|
+        puts "    - #{a}"
+      end
+      puts "  subnet: #{grid['subnet']}"
+      puts "  supernet: #{grid['supernet']}"
+      root_dir = grid['engine_root_dir']
+      nodes = client(require_token).get("grids/#{grid['name']}/nodes")
+      nodes = nodes['nodes'].select{|n| n['connected'] == true }
+      node_count = nodes.size
+      puts "  stats:"
+      puts "    nodes: #{nodes.size} of #{grid['node_count']}"
+
+      cpu_total = nodes.map{|n| n['cpus'].to_i}.inject(:+)
+      puts "    cpus: #{cpu_total || 0}"
+
+      loads = calculate_loads(nodes, node_count)
+      puts "    load: #{(loads[:'1m'] || 0.0).round(2)} #{(loads[:'5m'] || 0.0).round(2)} #{(loads[:'15m'] || 0.0).round(2)}"
+
+      mem_total = nodes.map{|n| n['mem_total'].to_i}.inject(:+)
+      mem_used = calculate_mem_used(nodes)
+      puts "    memory: #{to_gigabytes(mem_used)} of #{to_gigabytes(mem_total)} GB"
+
+      total_fs = calculate_filesystem_stats(nodes)
+      puts "    filesystem: #{to_gigabytes(total_fs['used'])} of #{to_gigabytes(total_fs['total'])} GB"
+
+      puts "    users: #{grid['user_count']}"
+      puts "    services: #{grid['service_count']}"
+      puts "    containers: #{grid['container_count']}"
+      if statsd = grid.dig('stats', 'statsd')
+        puts "  exports:"
+        puts "    statsd: #{statsd['server']}:#{statsd['port']}"
+      end
+      if logs = grid.dig('logs')
+        puts "logs:"
+        puts "  forwarder: #{logs['forwarder']}"
+        logs['opts'].each do |k,v|
+          puts "  #{k}: #{v}"
+        end
+      end
+    end
+
+    def grids
+      @grids ||= client.get('grids')
+    end
+
+    # @param [Array<Hash>] nodes
+    # @param [Fixnum] node_count
+    # @return [Hash]
+    def calculate_loads(nodes, node_count)
+      loads = {:'1m' => 0.0, :'5m' => 0.0, :'15m' => 0.0}
+      return loads if node_count == 0
+
+      loads[:'1m'] = nodes.map{|n| n.dig('resource_usage', 'load', '1m').to_f }.inject(:+) / node_count
+      loads[:'5m'] = nodes.map{|n| n.dig('resource_usage', 'load', '5m').to_f }.inject(:+) / node_count
+      loads[:'15m'] = nodes.map{|n| n.dig('resource_usage', 'load', '15m').to_f }.inject(:+) / node_count
+      loads
+    end
+
+    # @param [Array<Hash>] nodes
+    # @return [Float]
+    def calculate_mem_used(nodes)
+      nodes.map{|n|
+        mem = n.dig('resource_usage', 'memory')
+        if mem
+          mem['used'] - (mem['cached'] + mem['buffers'])
+        else
+          0.0
+        end
+      }.inject(:+)
+    end
+
+    # @param [Array<Hash>] nodes
+    # @return [Hash]
+    def calculate_filesystem_stats(nodes)
+      total_fs = {
+        'used' => 0.0,
+        'total' => 0.0
+      }
+      nodes.each do |node|
+        root_dir = node['engine_root_dir']
+        filesystems = node.dig('resource_usage', 'filesystem') || []
+        root_fs = filesystems.find{|fs| fs['name'] == root_dir}
+        total_fs['used'] += root_fs['used']
+        total_fs['total'] += root_fs['total']
+      end
+
+      total_fs
+    end
+
+    def find_grid_by_name(name)
+      grids['grids'].find {|grid| grid['name'] == name }
+    end
+
+    def to_gigabytes(amount)
+      return 0.0 if amount.nil?
+      (amount.to_f / 1024 / 1024 / 1024).to_f.round(2)
+    end
+
+    # @return [Hash] /v1/grids/:grid JSON { ... }
+    def get_grid(name = nil)
+      if name
+        client(require_token).get("grids/#{name}")
+      elsif current_grid
+        client(require_token).get("grids/#{current_grid}")
+      else
+        exit_with_error "No grid given or selected"
+      end
+    end
+
+    module Parameters
+      def self.included(base)
+        base.option "--default-affinity", "[AFFINITY]", "Default affinity rule for the grid", multivalued: true
+        base.option "--statsd-server", "STATSD_SERVER", "Statsd server address (host:port)"
+        base.option "--log-forwarder", "LOG_FORWARDER", "Set grid wide log forwarder" do |log_forwarder|
+          if log_forwarder == 'none'
+            warn "[DEPRECATED] --log-forwarder none will be replaced with --no-log-forwarder"
+          end
+          log_forwarder
+        end
+        base.option "--no-log-forwarder", :flag, "Disable log forwarding"
+        base.option "--log-opt", "[LOG_OPT]", "Set log options (key=value)", multivalued: true
+      end
+
+      def validate_log_opts
+        if !log_opt_list.empty? && (log_forwarder.nil? || no_log_forwarder?)
+          raise Kontena::Errors::StandardError.new(1, "Need to specify --log-forwarder when using --log-opt")
+        end
+
+        if no_log_forwarder? && !log_forwarder.nil? && log_forwarder != "none"
+          exit_with_error "Can't use --log-forwarder and --no-log-forwarder together"
+        end
+      end
+
+      def parse_log_opts
+        opts = {}
+        log_opt_list.each do |opt|
+          key, value = opt.split('=')
+          opts[key.to_sym] = value
+        end
+        opts
+      end
+
+      def validate_grid_parameters
+        validate_log_opts
+      end
+
+      def build_grid_parameters(payload)
+        if statsd_server
+          server, port = statsd_server.split(':')
+          payload[:stats] = {
+            statsd: {
+              server: server,
+              port: port || 8125
+            }
+          }
+        end
+
+        if log_forwarder || no_log_forwarder?
+          payload[:logs] = {
+            forwarder: no_log_forwarder? ? 'none' : log_forwarder,
+            opts: parse_log_opts
+          }
+        end
+
+        unless default_affinity_list.empty?
+          payload[:default_affinity] = default_affinity_list
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,48 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class CreateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    parameter "NAME", "Grid name"
+
+    option "--initial-size", "INITIAL_SIZE", "Initial grid size (number of nodes)", default: 1
+    option "--silent", :flag, "Reduce output verbosity"
+    option "--token", "[TOKEN]", "Set grid token"
+    option "--subnet", "[CIDR]", "Configure grid overlay subnet"
+    option "--supernet", "[CIDR]", "Configure grid IPAM supernet"
+
+    include Common::Parameters
+
+    requires_current_master_token
+
+    def execute
+      validate_grid_parameters
+
+      if initial_size == 1
+        warning "Option --initial-size=1 is only recommended for test/dev usage" unless running_silent?
+      end
+
+      payload = {
+        name: name
+      }
+      payload[:token] = self.token if self.token
+      payload[:initial_size] = self.initial_size if self.initial_size
+      payload[:subnet] = subnet if subnet
+      payload[:supernet] = supernet if supernet
+
+      build_grid_parameters(payload)
+
+      grid = spinner "Creating #{pastel.cyan(name)} grid " do
+        client.post('grids', payload)
+      end
+      if grid
+        spinner "Switching scope to #{pastel.cyan(name)} grid " do
+          config.current_grid = grid['name']
+          config.write
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class CurrentCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    option ["--name"], :flag, "Show name only", default: false
+
+    def execute
+      require_api_url
+      if current_grid.nil?
+        exit_with_error 'No grid selected. To select grid, please run: kontena grid use <grid name>'
+      else
+
+        grid = client(require_token).get("grids/#{current_grid}")
+        if name?
+          puts "#{grid['name']}"
+        else
+          print_grid(grid)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,32 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class EnvCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    parameter "[NAME]", "Grid name"
+    option ["-e", "--export"], :flag, "Add export", default: false
+
+    def execute
+      require_api_url
+
+      name_or_current = name.nil? ? current_grid : name
+
+      if name_or_current.nil?
+        exit_with_error "No grid selected. Use: kontena grid env <name>, or select a grid with: kontena grid use <name>"
+      else
+        grid = find_grid_by_name(name_or_current)
+        exit_with_error("Grid not found") unless grid
+
+        grid_uri = self.current_master['url'].sub('http', 'ws')
+
+
+        prefix = export? ? 'export ' : ''
+
+        puts "#{prefix}KONTENA_URI=#{grid_uri}"
+        puts "#{prefix}KONTENA_TOKEN=#{grid['token']}"
+      end
+    end
+  end
+end

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

@@ -0,0 +1,50 @@
+require_relative '../helpers/log_helper'
+
+module Kontena::Cli::Grids
+  class EventsCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::Helpers::LogHelper
+
+    SKIP_TYPES = ['grid']
+
+    option "--node", "NODE", "Filter by node name", multivalued: true
+    option "--service", "SERVICE", "Filter by service name", multivalued: true
+
+    def execute
+      require_api_url
+
+      query_params = {}
+      query_params[:nodes] = node_list.join(",") unless node_list.empty?
+      query_params[:services] = service_list.join(",") unless service_list.empty?
+
+      titles = ['TIME', 'TYPE', 'RELATIONSHIPS', 'MESSAGE']
+      puts "%-25s %-25s %-40s %s" % titles
+      show_logs("grids/#{current_grid}/event_logs", query_params) do |log|
+        show_log(log)
+      end
+    end
+
+    def show_log(log)
+      msg = log['message']
+      rels = log['relationships'].
+        delete_if { |r| SKIP_TYPES.include?(r['type']) }.
+        map { |r|
+          id = r['id'].split('/')[1..-1].delete_if{ |s| s == 'null'}.join('/')
+          unless id.empty?
+            "#{r['type']}=#{id}"
+          end
+        }.compact
+
+      time = log['created_at']
+      if log['severity'] == 2
+        time = pastel.yellow(time)
+      elsif log['severity'] >= 3
+        time = pastel.red(time)
+      end
+
+      puts '%-25s %-25s %-40s %s' % [
+        time, log['type'], rels.join(','), msg
+      ]
+    end
+  end
+end

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

@@ -0,0 +1,69 @@
+require_relative 'common'
+require "kontena/cli/helpers/health_helper"
+
+module Kontena::Cli::Grids
+  class HealthCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::Helpers::HealthHelper
+    include Common
+
+    parameter "[NAME]", "Grid name"
+
+    def execute
+      require_api_url
+
+      grid = get_grid(name)
+      grid_nodes = client(require_token).get("grids/#{grid['name']}/nodes")
+
+      return show_grid_health(grid, grid_nodes['nodes'])
+    end
+
+    # Validate grid/nodes configuration for grid operation
+    #
+    # @return [Boolean] false if unhealthy
+    def show_grid_health(grid, nodes)
+      initial_size = grid['initial_size']
+      minimum_size = grid['initial_size'] / 2 + 1 # a majority is required for etcd quorum
+
+      grid_health = grid_health(grid, nodes)
+      initial_nodes = nodes.select{|node| node['initial_member']}
+      online_nodes = initial_nodes.select{|node| node['connected']}
+
+      # configuration and status
+      if initial_nodes.length == 0
+        puts "#{health_icon :error} Grid does not have any initial nodes, and requires at least #{minimum_size} of #{initial_size} initial nodes for operation"
+      elsif online_nodes.empty?
+        puts "#{health_icon :error} Grid does not have any initial nodes online, and requires at least #{minimum_size} of #{initial_size} initial nodes for operation"
+      elsif initial_nodes.length < minimum_size
+        puts "#{health_icon :error} Grid only has #{initial_nodes.length} initial nodes, and requires at least #{minimum_size} of #{initial_size} initial nodes for operation"
+      elsif online_nodes.length < minimum_size
+        puts "#{health_icon :error} Grid only has #{online_nodes.length} initial nodes online, and requires at least #{minimum_size} of #{initial_size} initial nodes for operation"
+      elsif initial_nodes.length < initial_size
+        puts "#{health_icon :warning} Grid only has #{initial_nodes.length} initial nodes of #{initial_size} required for high-availability"
+      elsif online_nodes.length < initial_size
+        puts "#{health_icon :warning} Grid only has #{online_nodes.length} initial nodes online of #{initial_size} required for high-availability"
+      elsif initial_nodes.length == 2
+        puts "#{health_icon :warning} Grid only has #{initial_nodes.length} initial nodes, and is not high-availability"
+      elsif initial_nodes.length == 1
+        puts "#{health_icon :warning} Grid only has #{initial_nodes.length} initial node, and is not high-availability"
+      else
+        puts "#{health_icon :ok} Grid has all #{online_nodes.length} of #{initial_size} initial nodes online"
+      end
+
+      nodes.each do |node|
+        node_health = node_health(node, grid_health)
+
+        if node['connected']
+
+        elsif node['initial_member']
+          puts "#{health_icon grid_health} Initial node #{node['name']} is offline"
+        else
+          puts "#{health_icon node_health} Grid node #{node['name']} is offline"
+        end
+      end
+
+      # operational if we have etcd quorum
+      return online_nodes.length >= minimum_size
+    end
+  end
+end

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

@@ -0,0 +1,59 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class ListCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::TableGenerator::Helper
+    include Common
+
+    option ['-u', '--use'], :flag, 'Automatically use first available grid sorted by user count', hidden: true
+    option ['-v', '--verbose'], :flag, 'Use a more verbose output', hidden: true
+
+    requires_current_master
+    requires_current_master_token
+
+    def fields
+      { name: 'name', nodes: 'node_count', services: 'service_count', users: 'user_count' }
+    end
+
+    def execute
+      if quiet?
+        puts grids['grids'].map { |grid| grid['name'] }.join("\n")
+        exit 0
+      end
+
+      vputs
+
+      gridlist = []
+
+      vspinner "Retrieving a list of available grids" do
+        gridlist = grids['grids'].sort_by{|grid| grid['user_count']}
+      end
+
+      if gridlist.size == 0
+        self.verbose? && puts
+        puts pastel.yellow("Kontena Master #{config.current_master.name} doesn't have any grids yet. Create one now using 'kontena grid create' command")
+        self.verbose? && puts
+      else
+        vputs
+        vputs "You have access to the following grids:"
+        vputs
+
+        if current_grid
+          current_grid_entry = gridlist.find { |grid| grid['name'] == current_grid }
+          current_grid_entry['name'] += pastel.yellow(' *') if current_grid_entry
+        end
+
+        print_table(gridlist)
+
+        if self.use?
+          vputs
+          vspinner "* Selecting '#{gridlist.first['name']}' as the current grid" do
+            config.current_master.grid = gridlist.first['name']
+            config.write
+          end
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative '../helpers/log_helper'
+
+module Kontena::Cli::Grids
+  class LogsCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::Helpers::LogHelper
+    option "--node", "NODE", "Filter by node name", multivalued: true
+    option "--service", "SERVICE", "Filter by service name", multivalued: true
+    option ["-c", "--container"], "CONTAINER", "Filter by container", multivalued: true
+
+    def execute
+      require_api_url
+
+      query_params = {}
+      query_params[:nodes] = node_list.join(",") unless node_list.empty?
+      query_params[:services] = service_list.join(",") unless service_list.empty?
+      query_params[:containers] = container_list.join(",") unless container_list.empty?
+
+      show_logs("grids/#{current_grid}/container_logs", query_params) do |log|
+        show_log(log)
+      end
+    end
+
+    def show_log(log)
+      color = color_for_container(log['name'])
+      if tail?
+        prefix = "#{log['name']} |"
+      else
+        prefix = "#{log['created_at']} #{log['name']}:"
+      end
+
+      puts "#{pastel.send(color, prefix)} #{log['data']}"
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class RemoveCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    parameter "NAME ...", "Grid name"
+    option "--force", :flag, "Force remove", default: false, attribute_name: :forced
+
+    def execute
+      require_api_url
+      token = require_token
+      name_list.each do |name|
+        confirm_command(name) unless forced?
+        grid = find_grid_by_name(name)
+
+        if !grid.nil?
+          spinner "removing #{pastel.cyan(name)} grid " do
+            response = client(token).delete("grids/#{grid['id']}")
+            if response
+              clear_current_grid if grid['id'] == current_grid
+            end
+          end
+        else
+          exit_with_error "Could not resolve grid by name [#{name}]. For a list of existing grids please run: kontena grid list"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,25 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class ShowCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    parameter "NAME", "Grid name"
+
+    option '--token', :flag, 'Just output grid token'
+
+    def execute
+      require_api_url
+
+      grid = find_grid_by_name(name)
+      exit_with_error("Grid not found") unless grid
+
+      if self.token?
+        puts grid['token']
+      else
+        print_grid(grid)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Kontena::Cli::Grids
+  class TrustedSubnetCommand < Kontena::Command
+    subcommand ["list", "ls"], "List trusted subnets", load_subcommand('grids/trusted_subnets/list_command')
+    subcommand "add", "Add trusted subnet", load_subcommand('grids/trusted_subnets/add_command')
+    subcommand ["remove", "rm"], "Remove trusted subnet", load_subcommand('grids/trusted_subnets/remove_command')
+
+    def execute
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+module Kontena::Cli::Grids::TrustedSubnets
+  class AddCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+
+    parameter "SUBNET", "Trusted subnet"
+
+    requires_current_master
+
+    def execute
+      grid = client.get("grids/#{current_grid}")
+      data = {trusted_subnets: grid['trusted_subnets'] + [self.subnet]}
+      spinner "Adding #{pastel.cyan(subnet)} as a trusted subnet in #{pastel.cyan(current_grid)} grid " do
+        client.put("grids/#{current_grid}", data)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'kontena/cli/grids/common'
+
+module Kontena::Cli::Grids::TrustedSubnets
+  class ListCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::Grids::Common
+
+    # the command outputs id info only anyway, this is here strictly for ignoring purposes
+    option ['-q', '--quiet'], :flag, "Output the identifying column only", hidden: true
+
+    requires_current_master
+
+    def execute
+      Array(get_grid['trusted_subnets']).map(&method(:puts))
+    end
+  end
+end

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

@@ -0,0 +1,26 @@
+module Kontena::Cli::Grids::TrustedSubnets
+  class RemoveCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+
+    parameter "SUBNET ...", "Trusted subnet", attribute_name: :subnets
+    option "--force", :flag, "Force remove", default: false, attribute_name: :forced
+
+    requires_current_master
+
+    def execute
+      subnets.each do |subnet|
+        grid = client.get("grids/#{current_grid}")
+        confirm_command(subnet) unless forced?
+        trusted_subnets = grid['trusted_subnets'] || []
+        unless trusted_subnets.delete(subnet)
+          exit_with_error("Grid #{pastel.cyan(current_grid)} does not have trusted subnet #{pastel.cyan(subnet)}")
+        end
+        data = {trusted_subnets: trusted_subnets}
+        spinner "Removing trusted subnet #{pastel.cyan(subnet)} from #{pastel.cyan(current_grid)} grid " do
+          client.put("grids/#{current_grid}", data)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+require_relative 'common'
+
+module Kontena::Cli::Grids
+  class UpdateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Common
+
+    parameter "NAME", "Grid name"
+
+    include Common::Parameters
+
+    option "--no-default-affinity", :flag, "Unset grid default affinity"
+    option "--no-statsd-server", :flag, "Unset statsd server setting"
+
+    requires_current_master_token
+
+    def execute
+      validate_grid_parameters
+
+      payload = {}
+
+      build_grid_parameters(payload)
+
+      if no_statsd_server?
+        payload[:stats] = { statsd:  nil }
+      end
+
+      if no_default_affinity?
+        payload[:default_affinity] = []
+      end
+
+      client.put("grids/#{name}", payload)
+    end
+  end
+end