krates 1.6.0

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

@@ -0,0 +1,168 @@
+require_relative 'common'
+require 'yaml'
+
+module Kontena::Cli::Stacks
+  class ShowCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    banner "Show information and status of a stack in a grid on Kontena Master"
+
+    parameter "NAME", "Stack name"
+
+    requires_current_master
+    requires_current_master_token
+
+    option '--values', :flag, 'Output the variable-value pairs as YAML'
+    include Common::StackValuesToOption
+
+    def execute
+      write_variables if values_to
+      values? ? show_variables : show_stack
+    end
+
+    def variables
+      @variables ||= stack['variables'] || {}
+    end
+
+    def metadata
+      @metadata ||= stack['metadata'] || {}
+    end
+
+    def stack
+      @stack ||= client.get("stacks/#{current_grid}/#{name}")
+    end
+
+    def show_variables
+      puts variable_yaml
+    end
+
+    def variable_yaml
+      ::YAML.dump(variables)
+    end
+
+    def write_variables
+      File.write(values_to, variable_yaml)
+    end
+
+    def show_stack
+      puts "#{stack['name']}:"
+      puts "  created: #{stack['created_at']}"
+      puts "  updated: #{stack['updated_at']}"
+      puts "  state: #{stack['state']}"
+      puts "  stack: #{stack['stack']}"
+      puts "  version: #{stack['version']}"
+      puts "  revision: #{stack['revision']}"
+      puts "  expose: #{stack['expose'] || '-'}"
+
+      puts "  variables:#{' -' if variables.empty?}"
+      variables.each do |var, val|
+        puts "    #{var}: #{val}"
+      end
+
+      puts "  metadata:#{' -' if metadata.empty?}"
+      unless metadata.empty?
+        output_lines = ::YAML.dump(metadata).split(/[\r\n]/)
+        output_lines.shift # get rid of "---"
+        puts output_lines.map { |line| '    %s' % line }.join("\n")
+      end
+
+      puts "  parent: #{stack['parent'] ? stack['parent']['name'] : '-'}"
+      if stack['children'] && !stack['children'].empty?
+        puts "  children:"
+        stack['children'].each do |child|
+          puts "    - #{child['name']}"
+        end
+      end
+
+      puts "  services:"
+      stack['services'].each do |service|
+        show_service(service['id'])
+      end
+    end
+
+    # @param [String] service_id
+    def show_service(service_id)
+      token = require_token
+      service = get_service(token, service_id)
+      pad = '    '.freeze
+      puts "#{pad}#{service['name']}:"
+      puts "#{pad}  created: #{service['created_at']}"
+      puts "#{pad}  updated: #{service['updated_at']}"
+      puts "#{pad}  image: #{service['image']}"
+      puts "#{pad}  revision: #{service['stack_revision']}"
+      puts "#{pad}  state: #{service['state'] }"
+      if service['health_status']
+        puts "#{pad}  health_status:"
+        puts "#{pad}    healthy: #{service['health_status']['healthy']}"
+        puts "#{pad}    total: #{service['health_status']['total']}"
+      end
+      puts "#{pad}  stateful: #{service['stateful'] == true ? 'yes' : 'no' }"
+      puts "#{pad}  scaling: #{service['instances'] }"
+      puts "#{pad}  strategy: #{service['strategy']}"
+      puts "#{pad}  read_only: #{service['read_only'] == true ? 'yes' : 'no'}"
+      puts "#{pad}  deploy_opts:"
+      puts "#{pad}    min_health: #{service['deploy_opts']['min_health']}"
+      if service['deploy_opts']['wait_for_port']
+        puts "#{pad}  wait_for_port: #{service['deploy_opts']['wait_for_port']}"
+      end
+      if service['deploy_opts']['interval']
+        puts "#{pad}  interval: #{service['deploy_opts']['interval']}"
+      end
+      puts "#{pad}  dns: #{service['dns']}"
+
+      if service['affinity'].to_a.size > 0
+        puts "#{pad}  affinity: "
+        service['affinity'].to_a.each do |a|
+          puts "#{pad}    - #{a}"
+        end
+      end
+
+      if service['secrets'].to_a.size > 0
+        puts "#{pad}  secrets: "
+        service['secrets'].to_a.each do |s|
+          puts "#{pad}    - secret: #{s['secret']}"
+          puts "#{pad}      name: #{s['name']}"
+          puts "#{pad}      type: #{s['type']}"
+        end
+      end
+
+      unless service['cmd'].to_s.empty?
+        if service['cmd']
+          puts "#{pad}  cmd: #{service['cmd'].join(' ')}"
+        else
+          puts "#{pad}  cmd: "
+        end
+      end
+
+      if service['ports'].to_a.size > 0
+        puts "#{pad}  ports:"
+        service['ports'].to_a.each do |p|
+          puts "#{pad}    - #{p['node_port']}:#{p['container_port']}/#{p['protocol']}"
+        end
+      end
+
+      if service['volumes'].to_a.size > 0
+        puts "#{pad}  volumes:"
+        service['volumes'].to_a.each do |v|
+          puts "#{pad}    - #{v}"
+        end
+      end
+
+      if service['volumes_from'].to_a.size > 0
+        puts "#{pad}  volumes_from:"
+        service['volumes_from'].to_a.each do |v|
+          puts "#{pad}    - #{v}"
+        end
+      end
+
+      if service['links'].to_a.size > 0
+        puts "#{pad}  links: "
+        service['links'].to_a.each do |l|
+          puts "#{pad}    - #{l['alias']} => #{l['id']}"
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+require 'semantic'
+
+module Kontena::Cli::Stacks
+  class StackName
+    # A class for parsing stack name strings, such as kontena/foo:1.0.0
+
+    attr_reader :user, :stack, :version
+
+    # @param definition [String] such as kontena/foo:1.0.0
+    # @param version [String] set version separately
+    # @return [StackName]
+    # @example
+    #   name = StackName.new('kontena/foo:0.1.0')
+    #   name.user => 'kontena'
+    #   name.stack => 'foo'
+    #   name.version => '0.1.0'
+    #   name.stack_name => 'kontena/foo'
+    #   name.to_s => 'kontena/foo:0.1.0
+    def initialize(definition = nil, version = nil)
+      if definition.kind_of?(Hash)
+        @user = definition[:user] || definition['user']
+        @stack = definition[:stack] || definition['stack']
+        @version = definition[:version] || definition['version'] || version
+      elsif definition.kind_of?(String)
+        parsed = parse(definition)
+        @user = parsed[:user]
+        @stack = parsed[:stack]
+        @version = parsed[:version] || version
+      end
+    end
+
+    # Stack name without version
+    # @return [String] example: kontena/foo
+    def stack_name
+      [user, stack].compact.join('/')
+    end
+
+    # Full stack name including version if present
+    # @return [String] example: kontena/foo:0.1.0
+    def to_s
+      version ? "#{stack_name}:#{version}" : stack_name
+    end
+    alias to_str to_s
+
+    # True when version is a prerelease
+    # @return [NilClass,TrueClass,FalseClass] nil when no version, true when prerelease, false when not.
+    def pre?
+      return nil if version.nil?
+      !Semantic::Version.new(version).pre.nil?
+    end
+
+    private
+
+    def parse(definition)
+      return {} if definition.empty?
+      name, version = definition.split(':', 2)
+      if name.include?('/')
+        user, stack = name.split('/', 2)
+      else
+        user = nil
+        stack = name
+      end
+      {
+        user: user,
+        stack: stack,
+        version: version
+      }
+    end
+
+  end
+end

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

@@ -0,0 +1,83 @@
+module Kontena::Cli::Stacks
+  module StacksHelper
+
+    def wait_for_deployment_to_start(deployment, timeout = 600)
+      started = false
+      Timeout::timeout(timeout) do
+        while deployment['state'] == 'created'
+          sleep 1
+          deployment = client.get("stacks/#{deployment['stack_id']}/deploys/#{deployment['id']}")
+        end
+        if deployment['state'] == 'error'
+          puts "Stack deploy failed"
+          deployment['service_deploys'].each do |service_deploy|
+            if service_deploy['state'] == 'error'
+              puts " - #{service_deploy['reason']}"
+            end
+          end
+
+          abort
+        end
+      end
+
+      started
+    rescue Timeout::Error
+      raise 'deploy timed out'
+    end
+
+    # @param [Hash] deployment
+    # @return [Boolean]
+    def wait_for_deploy_to_finish(deployment, timeout = 600)
+      deployed = false
+      states = %w(success error)
+      tracked_services = []
+      Timeout::timeout(timeout) do
+        until deployed
+          deployment = client.get("stacks/#{deployment['stack_id']}/deploys/#{deployment['id']}")
+          service_deploy = deployment['service_deploys'].find{ |s| s['state'] == 'ongoing' }
+          if service_deploy
+            tracked_services << service_deploy['id']
+            wait_for_service_deploy(service_deploy)
+          end
+          if states.include?(deployment['state'])
+            deployed = true
+            deployment['service_deploys'].select{ |s| !tracked_services.include?(s['id']) }.each do |s|
+              wait_for_service_deploy(s)
+            end
+          else
+            sleep 1
+          end
+        end
+        if deployment['state'] == 'error'
+          deployment['service_deploys'].each do |service_deploy|
+            if service_deploy['state'] == 'error'
+              $stderr.puts "Deployment of service #{pastel.cyan(service_deploy['service_id'])} failed:"
+              $stderr.puts "  - #{service_deploy['reason'].strip}"
+              service_deploy['instance_deploys'].each do |instance_deploy|
+                if instance_deploy['state'] == 'error'
+                  $stderr.puts "  - " + "#{instance_deploy['error'].strip} (on node #{pastel.cyan(instance_deploy['node'])})"
+                end
+              end
+            end
+          end
+          abort
+        end
+      end
+
+      deployed
+    rescue Timeout::Error
+      raise 'deploy timed out'
+    end
+
+    def wait_for_service_deploy(service_deploy)
+      name = service_deploy['service_id'].split('/')[-1]
+      spinner "Deploying service #{pastel.cyan(name)}" do |spin|
+        until service_deploy['finished_at']
+          sleep 1
+          service_deploy = client.get("services/#{service_deploy['service_id']}/deploys/#{service_deploy['id']}")
+        end
+        spin.fail if service_deploy['state'] == 'error'
+      end
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require_relative 'common'
+
+module Kontena::Cli::Stacks
+  class StopCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    banner "Stops all services of a stack"
+
+    parameter "NAME ...", "Stack name", attribute_name: :names
+
+    requires_current_master
+    requires_current_master_token
+
+    def execute
+      names.each do |name|
+        spinner "Sending stop signal for stack #{name} services" do
+          client.post("stacks/#{current_grid}/#{name}/stop", {})
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,264 @@
+require 'json'
+require 'kontena/stacks/change_resolver'
+require_relative 'common'
+
+module Kontena::Cli::Stacks
+  class UpgradeCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    banner "Upgrades a stack in a grid on Kontena Master"
+
+    parameter "NAME", "Stack name"
+
+    include Common::StackFileOrNameParam
+
+    include Common::StackValuesToOption
+    include Common::StackValuesFromOption
+
+    option '--[no-]deploy', :flag, 'Trigger deploy after upgrade', default: true
+
+    option '--force', :flag, 'Force upgrade'
+    option '--skip-dependencies', :flag, "Do not upgrade any stack dependencies", default: false
+    option '--reuse-values', :flag, "Reuse existing values"
+    option '--dry-run', :flag, "Simulate upgrade"
+
+    requires_current_master
+    requires_current_master_token
+
+    # @return [Kontena::Stacks::ChangeResolver]
+    def execute
+      old_data = spinner "Reading stack #{pastel.cyan(stack_name)} from master" do
+        gather_master_data(stack_name)
+      end
+
+      kontena_requirement = loader.yaml.dig('meta', '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 force?
+        end
+      end
+
+      new_data = spinner "Parsing #{pastel.cyan(source)}" do
+        loader.flat_dependencies(
+          stack_name,
+          variables: values_from_options
+        )
+      end
+
+      changes = process_data(old_data, new_data)
+
+      display_report(changes)
+
+      return if dry_run?
+
+      get_confirmation(changes)
+
+      deployable_stacks = []
+      deployable_stacks.concat run_installs(changes)
+      deployable_stacks.concat run_upgrades(changes)
+
+      run_deploys(deployable_stacks) if deploy?
+
+      run_removes(changes.removed_stacks)
+
+      changes
+    end
+
+    private
+
+    # Recursively fetch master data in StackFileLoader#flat_dependencies format
+    # @return [Hash{string => Hash}] stackname => hash
+    def gather_master_data(stackname)
+      response = fetch_master_data(stackname)
+      children = response.delete('children') || []
+      result = { stackname => { stack_data: response } }
+      children.each do |child|
+        result.merge!(gather_master_data(child['name']))
+      end
+      result
+    end
+
+    # Preprocess data and return a ChangeResolver
+    # @param old_data [Hash] data from master
+    # @param new_data [Hash] data from files
+    # @return [Kontena::Cli::Stacks::ChangeRsolver]
+    def process_data(old_data, new_data)
+      logger.debug { "Master stacks: #{old_data.keys.join(",")} YAML stacks: #{new_data.keys.join(",")}" }
+
+      new_data.reverse_each do |stackname, data|
+        spinner "Processing stack #{pastel.cyan(stackname)}"
+        process_stack_data(stackname, data, old_data)
+        hint_on_validation_notifications(reader.notifications, reader.loader.source)
+        abort_on_validation_errors(reader.errors, reader.loader.source)
+      end
+
+      old_set = Kontena::Stacks::StackDataSet.new(old_data)
+      new_set = Kontena::Stacks::StackDataSet.new(new_data)
+      if skip_dependencies?
+        [old_set, new_set].each(&:remove_dependencies)
+      end
+      spinner "Analyzing upgrade" do
+        Kontena::Stacks::ChangeResolver.new(old_set, new_set)
+      end
+    end
+
+    # @param stackname [String]
+    # @param data [Hash]
+    # @param old_data [Hash]
+    def process_stack_data(stackname, data, old_data)
+      prev_env = ENV.clone
+      reader = data[:loader].reader
+      values = data[:variables]
+      if reuse_values? && old_data[stackname]
+        old_vars = old_data[stackname][:stack_data]['variables']
+        values = old_vars.merge(values)
+      end
+      set_env_variables(stackname, current_grid) # set envs for execution time
+      parsed_stack = reader.execute(
+        values: values,
+        defaults: old_data[stackname].nil? ? nil : old_data[stackname][:stack_data]['variables'],
+        parent_name: data[:parent_name],
+        name: data[:name]
+      )
+      data[:stack_data] = parsed_stack
+    ensure
+      prev_env.each { |k, v| ENV[k] = v }
+    end
+
+    # @param changes [Kontena::Stacks::ChangeResolver]
+    def display_report(changes)
+      puts
+      caret "Calculated changes:", dots: false
+
+      unless changes.removed_stacks.empty?
+        changes.removed_stacks.each { |stack|
+          puts "  #{pastel.red('-')} #{stack}"
+          changes.removed_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.red('-')} #{s}"
+          end
+        }
+      end
+
+      unless changes.replaced_stacks.empty?
+        changes.replaced_stacks.each { |stack|
+          puts "  #{pastel.yellow('-/+')} #{stack}"
+          changes.upgraded_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.cyan('~')} #{s}"
+          end
+          changes.added_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.green('+')} #{s}"
+          end
+          changes.removed_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.red('-')} #{s}"
+          end
+        }
+        changes.replaced_stacks.each do |installed_name, data|
+          puts "- #{pastel.yellow(installed_name)} from #{pastel.cyan(data[:from])} to #{pastel.cyan(data[:to])}"
+        end
+        puts
+      end
+
+      unless changes.added_stacks.empty?
+        changes.added_stacks.each { |stack|
+          puts "  #{pastel.green('+')} #{stack}"
+          changes.added_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.green('+')} #{s}"
+          end
+        }
+      end
+
+      unless changes.upgraded_stacks.empty?
+        changes.upgraded_stacks.each { |stack|
+          puts "  #{pastel.cyan('~')} #{stack}"
+          changes.upgraded_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.cyan('~')} #{s}"
+          end
+          changes.added_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.green('+')} #{s}"
+          end
+          changes.removed_services.select { |s| s.split('/')[0] == stack }.each do |s|
+            puts "    #{pastel.red('-')} #{s}"
+          end
+        }
+      end
+      puts
+    end
+
+    # requires heavier confirmation when something very dangerous is going to happen
+    def get_confirmation(changes)
+      unless force?
+        unless changes.safe?
+          puts "#{pastel.red('Warning:')} This can not be undone, data will be lost."
+          confirm
+        end
+      end
+    end
+
+    def deployable_stacks
+      @deployable_stacks ||= []
+    end
+
+    # @param removed_stacks [Array<String>]
+    def run_removes(removed_stacks)
+      removed_stacks.reverse_each do |removed_stack|
+        Kontena.run!('stack', 'remove', '--force', '--keep-dependencies', removed_stack)
+      end
+    end
+
+    # @param changes [Kontena::Stacks::ChangeResolver]
+    # @return [Array] an array of stack names that have been installed, but not yet deployed
+    def run_installs(changes)
+      deployable_stacks = []
+      changes.added_stacks.reverse_each do |added_stack|
+        data = changes.new_data[added_stack]
+        cmd = ['stack', 'install', '--name', added_stack, '--no-deploy']
+        cmd.concat ['--parent-name', data.parent] unless data.root?
+        data.variables.each do |k,v|
+          cmd.concat ['-v', "#{k}=#{v}"]
+        end
+        cmd << data.loader.source
+        caret "Installing new dependency #{cmd.last} as #{added_stack}"
+        deployable_stacks << added_stack
+        Kontena.run!(cmd)
+      end
+      deployable_stacks
+    end
+
+    # @param changes [Kontena::Stacks::ChangeResolver]
+    # @return [Array] an array of stack names that have been upgraded, but not yet deployed
+    def run_upgrades(changes)
+      deployable_stacks = []
+      changes.upgraded_stacks.reverse_each do |upgraded_stack|
+        data = changes.new_data[upgraded_stack]
+        spinner "Upgrading #{data.root? ? 'stack' : 'dependency'} #{pastel.cyan(upgraded_stack)}" do |spin|
+          deployable_stacks << upgraded_stack
+          update_stack(upgraded_stack, data.data) || spin.fail!
+        end
+      end
+      deployable_stacks
+    end
+
+    # @param deployable_stacks [Array<String>] an array of stack names that should be deployed
+    def run_deploys(deployable_stacks)
+      deployable_stacks.each do |deployable_stack|
+        Kontena.run!(['stack', 'deploy', deployable_stack])
+      end
+    end
+
+    def update_stack(name, data)
+      client.put(stack_url(name), data)
+    end
+
+    def stack_url(name)
+      "stacks/#{current_grid}/#{name}"
+    end
+
+    def fetch_master_data(stackname)
+      client.get(stack_url(stackname))
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+require_relative 'common'
+require 'yaml'
+
+module Kontena::Cli::Stacks
+  class ValidateCommand < Kontena::Command
+    include Kontena::Cli::Common
+    include Kontena::Cli::GridOptions
+    include Common
+
+    banner "Validates a YAML file"
+
+    include Common::StackFileOrNameParam
+    include Common::StackNameOption
+
+    include Common::StackValuesToOption
+    include Common::StackValuesFromOption
+
+    option '--online', :flag, "Enable connections to current master", default: false
+    option '--dependency-tree', :flag, "Show dependency tree"
+    option '--[no-]dependencies', :flag, "Validate dependencies", default: true
+    option '--parent-name', '[PARENT_NAME]', "Set parent name", hidden: true
+    option '--format', 'yaml|api-json', "Output Format", default: 'yaml'
+
+    def validate_dependencies
+      dependencies = loader.dependencies
+      return if dependencies.nil?
+      dependencies.each do |dependency|
+        target_name = "#{stack_name}-#{dependency['name']}"
+        cmd = ['stack', 'validate']
+        cmd << '--online' if online?
+        cmd.concat ['--parent-name', stack_name]
+
+        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 execute
+      if dependency_tree?
+        puts ::YAML.dump('name' => stack_name, 'stack' => source, 'depends' => stack['dependencies'])
+        exit 0
+      end
+
+      validate_dependencies if dependencies?
+
+      if online?
+        set_env_variables(stack_name, require_current_grid)
+      else
+        config.current_master = nil
+        set_env_variables(stack_name, 'validate', 'validate-platform')
+      end
+
+      stack # runs validations
+
+      hint_on_validation_notifications(reader.notifications, dependencies? ? loader.source : nil)
+      abort_on_validation_errors(reader.errors, dependencies? ? loader.source : nil)
+
+      dump_variables if values_to
+
+      case self.format
+      when 'api-json'
+        puts JSON.pretty_generate(stack)
+      when 'yaml'
+        result = ::YAML.dump(reader.fully_interpolated_yaml)
+        result = result.sub(/\A---$/, "---\n# #{loader.source}") if dependencies?
+        puts result
+      else
+        exit_with_error "Unknown --format=#{self.format}"
+      end
+    end
+  end
+end