krates 1.6.0

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

@@ -0,0 +1,209 @@
+require_relative 'yaml/reader'
+require_relative '../services/services_helper'
+require_relative 'service_generator_v2'
+require_relative '../../stacks_client'
+require_relative 'yaml/stack_file_loader'
+require 'yaml'
+
+module Kontena::Cli::Stacks
+  module Common
+    include Kontena::Cli::Services::ServicesHelper
+
+    # @return [StackFileLoader] a loader for the stack origin defined through command-line options
+    def loader
+      @loader ||= loader_class.for(source)
+    end
+
+    # @return [YAML::Reader] a YAML reader for the target file
+    def reader
+      @reader ||= loader.reader
+    end
+
+    # Stack name read from -n parameter or the stack file
+    # @return [String]
+    def stack_name
+      @stack_name ||= (self.respond_to?(:name) && self.name) ? self.name : loader.stack_name.stack
+    end
+
+    # An accessor to the YAML Reader outcome. Passes parent name, values from command line and
+    # the stackname to the reader.
+    #
+    # @return [Hash]
+    def stack
+      @stack ||= reader.execute(
+        name: stack_name,
+        parent_name: self.respond_to?(:parent_name) ? self.parent_name : nil,
+        values: (self.respond_to?(:values_from_options) ? self.values_from_options : {})
+      )
+    end
+
+    # @return [Class] an accessor to StackFileLoader constant, for testing purposes
+    def loader_class
+      ::Kontena::Cli::Stacks::YAML::StackFileLoader
+    end
+
+    module RegistryNameParam
+      def stack_name
+        @stack_name ||= Kontena::Cli::Stacks::StackName.new(source)
+      end
+
+      def self.included(where)
+        where.parameter "STACK_NAME", "Stack name, for example user/stackname or user/stackname:version", attribute_name: :source
+      end
+    end
+
+    module StackNameParam
+      # Include to add a STACK_NAME parameter
+      def self.included(where)
+        where.parameter "STACK_NAME", "Stack name, for example user/stackname or user/stackname:version", attribute_name: :source
+      end
+    end
+
+    module StackFileOrNameParam
+      # Include to add a stack file parameter
+      def self.included(where)
+        where.parameter "[FILE]", "Kontena stack file, registry stack name (user/stack or user/stack:version) or URL", default: "kontena.yml", attribute_name: :source
+      end
+    end
+
+    module StackNameOption
+      # Include to add a stack name parameter
+      def self.included(where)
+        where.option ['-n', '--name'], 'NAME', 'Define stack name (by default comes from stack file)'
+      end
+    end
+
+    module StackValuesToOption
+      attr_accessor :values
+      # Include to add --values-to variable value dumping feature
+      def self.included(where)
+        where.option '--values-to', '[FILE]', 'Output variable values as YAML to file'
+      end
+
+      # Writes a YAML file from the values received from YAML::Reader to a file defined through
+      # the --values-to option
+      def dump_variables
+        File.write(values_to, ::YAML.dump(reader.variable_values, without_defaults: true, without_vault: true))
+      end
+    end
+
+    module StackValuesFromOption
+      # Include to add --values-from option to read variable values from a YAML file
+      # and the -v variable=value option that can be used to pass variable values
+      # directly from command line
+      def self.included(where)
+        where.prepend InstanceMethods
+
+        where.option '--values-from', '[FILE]', 'Read variable values from a YAML file', multivalued: true do |filename|
+          values_from_file.merge!(::YAML.safe_load(File.read(filename), [], [], true, filename))
+          filename
+        end
+
+        where.option '--values-from-stack', '[STACK_NAME]', 'Read variable values from an installed stack', multivalued: true do |stackname|
+          variables = read_values_from_stacks(stackname)
+          Kontena.logger.debug { "Received variables from stack #{stackname} on Master: #{variables.inspect}" }
+          warn "Stack #{stackname} does not have any values for variables" if variables.empty?
+          values_from_installed_stacks.merge!(variables)
+          stackname
+        end
+
+        where.option '-v', "VARIABLE=VALUE", "Set stack variable values, example: -v domain=example.com. Can be used multiple times.", multivalued: true, attribute_name: :var_option do |var_pair|
+          var_name, var_value = var_pair.split('=', 2)
+          values_from_value_options.merge!(::YAML.safe_load(::YAML.dump(var_name => var_value)))
+          var_pair
+        end
+      end
+
+      module InstanceMethods
+        def read_values_from_stacks(stackname)
+          result = {}
+          response = client.get("stacks/#{current_grid}/#{stackname}")
+          result.merge!(response['variables']) if response['variables']
+          if response['children']
+            response['children'].each do |child_info|
+              result.merge!(
+                read_values_from_stacks(child_info['name']).tap do |child_result|
+                  child_result.keys.each do |key|
+                    new_key = child_info['name'].dup # foofoo-redis-monitor
+                    new_key.sub!("#{stackname}-", '') # monitor
+                    new_key.concat ".#{key}" # monitor.foovariable
+                    child_result[new_key] = child_result.delete(key)
+                  end
+                end
+              )
+            end
+          end
+          result
+        end
+
+        def values_from_file
+          @values_from_file ||= {}
+        end
+
+        def values_from_value_options
+          @values_from_value_options ||= {}
+        end
+
+        def values_from_installed_stacks
+          @values_from_installed_stacks ||= {}
+        end
+
+        def values_from_options
+          @values_from_options ||= values_from_installed_stacks.merge(values_from_file).merge(values_from_value_options)
+        end
+
+        # Transforms a hash
+        # dependency_values_from_options('foo.bar' => 1, 'foo')
+        #  => { 'bar' => 1 }
+        # Used for dependency variable injection
+        def dependency_values_from_options(name)
+          name_with_dot = name.to_s + '.'
+          values_from_options.each_with_object({}) do |kv_pair, obj|
+            key = kv_pair.first.to_s
+            value = kv_pair.last
+            next unless key.start_with?(name_with_dot)
+            obj[key.sub(name_with_dot, '')] = value
+          end
+        end
+      end
+    end
+
+    # Sets environment variables from parameters
+    # @param stack [String] current stack name
+    # @param grid [String] current grid name
+    # @param platform [String] current platform name, defaults to param grid value
+    def set_env_variables(stack, grid, platform = grid)
+      ENV['STACK'] = stack
+      ENV['GRID'] = grid
+      ENV['PLATFORM'] = platform
+    end
+
+    # @return [String]
+    def current_dir
+      File.basename(Dir.getwd)
+    end
+
+    def display_notifications(messages, color = :yellow)
+      $stderr.puts(pastel.send(color, messages.to_yaml.gsub(/^---$/, '')))
+    end
+
+    def hint_on_validation_notifications(notifications, filename = nil)
+      return if notifications.nil? || notifications.empty?
+      $stderr.puts pastel.yellow("#{"(#{filename}) " if filename}YAML contains the following unsupported options and they were rejected:")
+      display_notifications(notifications)
+    end
+
+    def abort_on_validation_errors(errors, filename = nil)
+      return if errors.nil? || errors.empty?
+      $stderr.puts pastel.red("#{"(#{filename}) " if filename} YAML validation failed! Aborting.")
+      display_notifications(errors, :red)
+      abort
+    end
+
+    # An accessor to stack registry client
+    # @return [Kontena::StacksClient]
+    def stacks_client
+      @stacks_client ||= Kontena::StacksClient.new(current_account.stacks_url, current_account.token, read_requires_token: current_account.stacks_read_authentication)
+    end
+  end
+end

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

@@ -0,0 +1,37 @@
+require_relative 'stacks_helper'
+
+module Kontena::Cli::Stacks
+  class DeployCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include StacksHelper
+
+    banner "Deploys all services of a stack"
+
+    parameter "NAME ...", "Stack name", attribute_name: :names
+
+    option '--[no-]wait', :flag, 'Wait for deployment to finish', default: true
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      names.each do |name|
+        deployment = nil
+        spinner "Triggering deployment of stack #{pastel.cyan(name)}" do
+          deployment = deploy_stack(name)
+        end
+        if wait?
+          spinner "Waiting for deployment to start" do
+            wait_for_deployment_to_start(deployment)
+          end
+          wait_for_deploy_to_finish(deployment)
+        end
+      end
+    end
+
+    def deploy_stack(name)
+      client.post("stacks/#{current_grid}/#{name}/deploy", {})
+    end
+  end
+end

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

@@ -0,0 +1,33 @@
+require_relative '../helpers/log_helper'
+
+module Kontena::Cli::Stacks
+  class EventsCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::Helpers::LogHelper
+
+    parameter "NAME", "Service name"
+
+    def execute
+      require_api_url
+
+      query_params = {}
+      titles = ['TIME', 'TYPE', 'MESSAGE']
+      puts "%-25s %-25s %s" % titles
+      show_logs("stacks/#{current_grid}/#{name}/event_logs", query_params) do |log|
+        show_log(log)
+      end
+    end
+
+    def show_log(log)
+      msg = log['message']
+      node = log['relationships'].find { |r| r['type'] == 'node' }
+      if node
+        msg = "#{msg} (#{node['id'].split('/')[-1]})"
+      end
+      puts '%-25s %-25s %s' % [
+        log['created_at'], log['type'], msg
+      ]
+    end
+  end
+end

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

@@ -0,0 +1,17 @@
+module Kontena::Cli::Stacks
+  class InspectCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+
+    banner "Shows the Stack YAML used to install the stack"
+
+    parameter "NAME", "Stack name"
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      puts client.get("stacks/#{current_grid}/#{name}")['source']
+    end
+  end
+end

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

@@ -0,0 +1,95 @@
+require_relative 'common'
+require_relative 'yaml/stack_file_loader'
+
+module Kontena::Cli::Stacks
+  class InstallCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    banner "Installs a stack to a grid on Kontena Master"
+
+    include Common::StackFileOrNameParam
+
+    include Common::StackNameOption
+    option '--[no-]deploy', :flag, 'Trigger deploy after installation', default: true
+
+    include Common::StackValuesToOption
+    include Common::StackValuesFromOption
+
+    option '--parent-name', '[PARENT_NAME]', "Set parent stack name", hidden: true
+    option '--skip-dependencies', :flag, "Do not install any stack dependencies"
+
+    option "--force", :flag, "Force install", default: false, attribute_name: :forced
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      install_dependencies unless skip_dependencies?
+
+      set_env_variables(stack_name, current_grid)
+
+      stack # runs validations
+
+      kontena_requirement = stack.dig('metadata', 'required_kontena_version')
+      unless kontena_requirement.nil?
+        master_version = Gem::Version.new(client.server_version)
+        unless Gem::Requirement.new(kontena_requirement).satisfied_by?(master_version)
+          puts "#{pastel.red("Warning: ")} Stack requires kontena version #{kontena_requirement} but Master version is #{master_version}"
+          confirm("Are you sure? You can skip this prompt by running this command with --force option") unless forced?
+        end
+      end
+
+      hint_on_validation_notifications(reader.notifications)
+      abort_on_validation_errors(reader.errors)
+
+      dump_variables if values_to
+
+      create_stack
+
+      if deploy?
+        deploy_dependencies
+        deploy_stack
+      end
+    end
+
+    def install_dependencies
+      dependencies = loader.dependencies
+      return if dependencies.nil?
+
+      dependencies.each do |dependency|
+        target_name = "#{stack_name}-#{dependency['name']}"
+        caret "Installing dependency #{pastel.cyan(dependency['stack'])} as #{pastel.cyan(target_name)}"
+        cmd = ['stack', 'install', '-n', target_name, '--parent-name', stack_name, '--no-deploy']
+
+        dependency['variables'].merge(dependency_values_from_options(dependency['name'])).each do |key, value|
+          cmd.concat ['-v', "#{key}=#{value}"]
+        end
+
+        cmd << dependency['stack']
+        Kontena.run!(cmd)
+      end
+    end
+
+    def deploy_dependencies
+      dependencies = loader.dependencies
+      return if dependencies.nil?
+
+      dependencies.each do |dependency|
+        target_name = "#{stack_name}-#{dependency['name']}"
+        Kontena.run!(['stack', 'deploy', target_name])
+      end
+    end
+
+    def create_stack
+      spinner "Creating stack #{pastel.cyan(stack['name'])} " do
+        client.post("grids/#{current_grid}/stacks", stack)
+      end
+    end
+
+    def deploy_stack
+      Kontena.run!(['stack', 'deploy', stack['name']])
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+module Kontena::Cli::Stacks
+  class LabelCommand < Kontena::Command
+    subcommand "add", "Add label to stack", load_subcommand('stacks/labels/add_command')
+    subcommand ["remove", "rm"], "Remove label from stack", load_subcommand('stacks/labels/remove_command')
+    subcommand ["list", "ls"], "List stack labels", load_subcommand('stacks/labels/list_command')
+
+    def execute
+    end
+  end
+end

data/lib/kontena/cli/stacks/labels/add_command.rb

@@ -0,0 +1,21 @@
+require_relative '../common'
+require_relative 'common'
+
+module Kontena::Cli::Stacks::Labels
+  class AddCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    parameter "NAME", "Stack name"
+    parameter "LABEL ...", "Labels"
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      original_labels = fetch_master_data(name)
+      update_stack(name, { 'labels' => original_labels | label_list })
+    end
+  end
+end

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

@@ -0,0 +1,19 @@
+module Kontena::Cli::Stacks::Labels
+  module Common
+    private
+
+    def update_stack(name, data)
+      client.patch(stack_url(name), data)
+    end
+
+    def stack_url(name)
+      "stacks/#{current_grid}/#{name}"
+    end
+
+    def fetch_master_data(stackname)
+      original_data = client.get(stack_url(stackname))
+      # ensure we always return either labels or an empty array
+      original_data['labels'] || []
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+require_relative '../common'
+require_relative 'common'
+
+module Kontena::Cli::Stacks::Labels
+  class ListCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    parameter "NAME", "Stack name"
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      stack = client.get(stack_url(name))
+      # safeguard from nil, since 'labels' field is optional
+      puts Array(stack['labels'] || []).join("\n")
+    end
+  end
+end

data/lib/kontena/cli/stacks/labels/remove_command.rb

@@ -0,0 +1,21 @@
+require_relative '../common'
+require_relative 'common'
+
+module Kontena::Cli::Stacks::Labels
+  class RemoveCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    parameter "NAME", "Stack name"
+    parameter "LABEL ...", "Labels"
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      original_labels = fetch_master_data(name)
+      update_stack(name, { 'labels' => (original_labels - label_list) })
+    end
+  end
+end

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

@@ -0,0 +1,154 @@
+require_relative 'common'
+
+module Kontena::Cli::Stacks
+  class ListCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::TableGenerator::Helper
+    include Common
+
+    banner "Lists all installed stacks on a grid in Kontena Master"
+
+    requires_current_master
+    requires_current_master_token
+
+    HEALTH_ICONS = {
+      unhealthy: Kontena.pastel.red('⊗').freeze,
+      partial:   Kontena.pastel.yellow('⊙').freeze,
+      healthy:   Kontena.pastel.green('⊛').freeze,
+      default:   Kontena.pastel.dim('⊝').freeze
+    }
+
+    def stacks_by_names(stacks, name_list)
+      name_list.map { |name| stacks.find { |stack| stack['name'] == name } }.compact
+    end
+
+    def build_depths(stacks)
+      stacks.sort_by { |s| s['name'] }.each do |stack|
+        stack['depth'] += 1
+        stacks_by_names(stacks, stack['children'].map { |n| n['name'] }).each do |child_stack|
+          child_stack['depth'] += stack['depth']
+        end
+      end
+      stacks
+    end
+
+    def get_stacks
+      client.get("grids/#{current_grid}/stacks")['stacks'].tap { |stacks| stacks.map { |stack| stack['depth'] = 0 } }
+    end
+
+    # Defines a set of columns for the command.
+    def fields
+      return ['name'] if quiet?
+      {
+        name: 'name',
+        stack: 'stack',
+        services: 'services_count',
+        state: 'state',
+        'exposed ports' => 'ports',
+        labels: 'labels'
+      }
+    end
+
+    def execute
+      stacks = build_depths(get_stacks)
+
+      print_table(stacks) do |row|
+        next if quiet?
+        row['name'] = health_icon(stack_health(row)) + " " + tree_icon(row) + " " + row['name']
+        row['stack'] = "#{row['stack']}:#{row['version']}"
+        row['services_count'] = row['services'].size
+        row['ports'] = stack_ports(row).join(',')
+        row['state'] = pastel.send(state_color(row['state']), row['state'])
+        row['labels'] = stack_labels(row)
+      end
+    end
+
+    def state_color(state)
+      case state
+      when 'running' then :green
+      when 'deploying', 'initialized' then :blue
+      when 'stopped' then :red
+      when 'partially_running' then :yellow
+      else :clear
+      end
+    end
+
+    def health_icon(health)
+      HEALTH_ICONS.fetch(health) { HEALTH_ICONS[:default] }
+    end
+
+    def tree_icon(row)
+      return '' unless $stdout.tty?
+      parent = row['parent']
+      children = row['children'] || []
+      if parent.nil? && children.empty?
+        # solo
+        char = ''
+      elsif parent.nil? && !children.empty?
+        char = ''
+      elsif !parent.nil?
+        char = '┗━'
+      end
+      left_pad = ' ' * (2 * (row['depth'] - 1))
+      left_pad + char
+    end
+
+    # Converts an array of stack labels into a comma-separated string
+    # or '-' when labels field is not defined.
+    #
+    # @param [Hash] stack
+    # @return [<String>]
+    def stack_labels(stack)
+      labels = (stack['labels'] || ['-']).join(',')
+      # trim labels to fit viewport when exceed 43 chars
+      labels.length > 43 && $stdout.isatty ? "#{labels[0..40]}..." : labels
+    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

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

@@ -0,0 +1,35 @@
+require_relative '../helpers/log_helper'
+
+module Kontena::Cli::Stacks
+  class LogsCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Kontena::Cli::Helpers::LogHelper
+
+    banner "Shows logs from services in a stack"
+
+    parameter "NAME", "Stack name"
+    parameter "[SERVICE] ...", "Service names"
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      if service_list.empty?
+        show_logs("stacks/#{current_grid}/#{name}/container_logs") do |log|
+          show_log(log)
+        end
+      else
+        show_logs("grids/#{current_grid}/container_logs", services: service_list.map {|s| [name, s].join('/')}.join(',')) do |log|
+          show_log(log)
+        end
+      end
+    end
+
+    def show_log(log)
+      color = color_for_container(log['name'])
+      prefix = pastel.send(color, "#{log['created_at']} [#{log['name']}]:")
+      puts "#{prefix} #{log['data']}"
+    end
+  end
+end