krates 1.6.0

data/lib/kontena/stacks_cache.rb

@@ -0,0 +1,110 @@
+module Kontena
+  autoload :StacksClient, 'kontena/stacks_client'
+
+  class StacksCache
+    class CachedStack
+
+      attr_reader :stack_name
+
+      def initialize(stack_name)
+        @stack_name = stack_name
+      end
+
+      def read
+        File.read(path)
+      end
+
+      def load
+        ::YAML.safe_load(read, [], [], true, path)
+      end
+
+      def write(content)
+        raise ArgumentError, "Stack name and version required" unless stack_name.stack_name && stack_name.version
+        unless File.directory?(File.dirname(path))
+          require 'fileutils'
+          FileUtils.mkdir_p(File.dirname(path))
+        end
+        File.write(path, content)
+      end
+
+      def delete
+        File.unlink(path)
+      end
+
+      def cached?
+        return false unless stack_name.version
+        File.exist?(path)
+      end
+
+      def path
+        path = File.expand_path(File.join(base_path, "#{stack_name.stack_name}-#{stack_name.version}.yml"))
+        raise "Path traversal attempted" unless path.start_with?(base_path)
+        path
+      end
+
+      private
+
+      def base_path
+        Kontena::StacksCache.base_path
+      end
+    end
+
+    class RegistryClientFactory
+      require 'kontena/cli/common'
+      require 'kontena/cli/stacks/common'
+      include Kontena::Cli::Common
+      include Kontena::Cli::Stacks::Common
+    end
+
+    class << self
+      def pull(stack_name)
+        cache(stack_name).read
+      end
+
+      def dputs(msg)
+        Kontena.logger.debug { msg }
+      end
+
+      def cache(stack_name)
+        stack = CachedStack.new(stack_name)
+        if stack.cached?
+          dputs "Reading from cache: #{stack.path}"
+        else
+          dputs "Retrieving #{stack.stack_name} from registry"
+          content = client.pull(stack_name)
+          yaml    = ::YAML.safe_load(content, [], [], true, stack.stack_name.to_s)
+          new_stack_name = Kontena::Cli::Stacks::StackName.new(yaml['stack'], yaml['version'])
+          new_stack = CachedStack.new(new_stack_name)
+          if new_stack.cached?
+            dputs "Already cached"
+            stack = new_stack
+          else
+            dputs "Writing #{stack.path}"
+            new_stack.write(content)
+            dputs "#{new_stack.stack_name} cached to #{new_stack.path}"
+            stack = new_stack
+          end
+        end
+        stack
+      end
+
+      def registry_url(stack_name)
+        client.full_uri(stack_name)
+      end
+
+      def client
+        @client ||= RegistryClientFactory.new.stacks_client
+      end
+
+      def base_path
+        return @base_path if @base_path
+        @base_path = File.join(Dir.home, '.kontena/cache/stacks')
+        unless File.directory?(@base_path)
+          require 'fileutils'
+          FileUtils.mkdir_p(@base_path)
+        end
+        @base_path
+      end
+    end
+  end
+end

data/lib/kontena/stacks_client.rb

@@ -0,0 +1,177 @@
+require 'kontena/client'
+
+module Kontena
+  class StacksClient < Client
+
+    ACCEPT_JSON    = { 'Accept' => 'application/json' }
+    ACCEPT_YAML    = { 'Accept' => 'application/yaml' }
+    ACCEPT_JSONAPI = { 'Accept' => 'application/vnd.api+json' }
+    CT_YAML        = { 'Content-Type' => 'application/yaml' }
+    CT_JSONAPI     = { 'Content-Type' => 'application/vnd.api+json' }
+
+    def raise_unless_token
+      unless token && token['access_token']
+        raise Kontena::Errors::StandardError.new(401, "Stack registry write operations require authentication")
+      end
+    end
+
+    def raise_unless_read_token
+      return false unless options[:read_requires_token]
+      unless token && token['access_token']
+        raise Kontena::Errors::StandardError.new(401, "Stack registry requires authentication")
+      end
+    end
+
+    def full_uri(stack_name)
+      URI.join(api_url, path_to_version(stack_name)).to_s
+    end
+
+    def path_to_version(stack_name)
+      path_to_stack(stack_name) + "/stack-versions/%s" % (stack_name.version || 'latest')
+    end
+
+    def path_to_stack(stack_name)
+      "/v2/organizations/%s/stacks/%s" % [stack_name.user, stack_name.stack]
+    end
+
+    def push(stack_name, data)
+      raise_unless_token
+      post(
+        '/v2/stack-files',
+        {
+          'data' => {
+            'type' => 'stack-files',
+            'attributes' => { 'content' => data }
+          }
+        },
+        {},
+        CT_JSONAPI,
+        true
+      )
+    end
+
+    def show(stack_name, include_prerelease: true)
+      raise_unless_read_token
+      result = get("#{path_to_stack(stack_name)}", { 'include' => 'latest-version', 'include-prerelease' => include_prerelease }, ACCEPT_JSONAPI)
+      if result['included']
+        latest = result['included'].find { |i| i['type'] == 'stack-versions' }
+        return result unless latest
+        result['data']['attributes']['latest-version'] = {}
+        result['data']['attributes']['latest-version']['version'] = latest['attributes']['version']
+        result['data']['attributes']['latest-version']['description'] = latest['attributes']['description']
+        result['data']['attributes']['latest-version']['meta'] = latest['meta']
+      end
+      result
+    end
+
+    def versions(stack_name, include_prerelease: true, include_deleted: false)
+      raise_unless_read_token
+      get("#{path_to_stack(stack_name)}/stack-versions", { 'include-prerelease' => include_prerelease, 'include-deleted' => include_deleted}, ACCEPT_JSONAPI).dig('data')
+    end
+
+    def pull(stack_name)
+      raise_unless_read_token
+      get(path_to_version(stack_name) + '/yaml', nil, ACCEPT_YAML)
+    rescue StandardError => ex
+      ex.message << " : #{path_to_version(stack_name)}"
+      raise ex, ex.message
+    end
+
+    def search(query, tags: [], include_prerelease: true, include_private: true, include_versionless: true)
+      raise_unless_read_token
+      if tags.empty?
+        result = get('/v2/stacks', { 'query' => query, 'include' => 'latest-version', 'include-prerelease' => include_prerelease, 'include-private' => include_private, 'include-versionless' => include_versionless }, ACCEPT_JSONAPI)
+      else
+        result = get('/v2/tags/%s/stacks' % tags.join(','), { 'query' => query, 'include' => 'latest-version', 'include-prerelease' => include_prerelease, 'include-private' => include_private }, ACCEPT_JSONAPI)
+      end
+
+      data = result.dig('data')
+      included = result.dig('included')
+      if included
+        data.each do |row|
+          name = '%s/%s' % [row.fetch('attributes', {}).fetch('organization-id'), row.fetch('attributes', {}).fetch('name')]
+          next if name.nil?
+          included_version = included.find { |i| i.fetch('attributes', {}).fetch('name') == name }
+          if included_version
+            row['attributes']['latest-version'] = {}
+            row['attributes']['latest-version']['version'] = included_version['attributes']['version']
+            row['attributes']['latest-version']['description'] = included_version['attributes']['description']
+          end
+        end
+      end
+      data
+    end
+
+    def destroy(stack_name)
+      raise_unless_token
+      if stack_name.version
+        id = stack_version_id(stack_name)
+        if id.nil?
+          raise Kontena::Errors::StandardError.new(404, 'Not found')
+        end
+        delete('/v2/stack-versions/%s' % id, nil, {}, ACCEPT_JSONAPI)
+      else
+        id = stack_id(stack_name)
+        if id.nil?
+          raise Kontena::Errors::StandardError.new(404, 'Not found')
+        end
+        delete('/v2/stacks/%s' % id, nil, {}, ACCEPT_JSONAPI)
+      end
+    end
+
+    def make_private(stack_name)
+      change_visibility(stack_name, is_private: true)
+    end
+
+    def make_public(stack_name)
+      change_visibility(stack_name, is_private: false)
+    end
+
+    def create(stack_name, is_private: true)
+      post(
+        '/v2/stacks',
+        stack_data(stack_name, is_private: is_private),
+        {},
+        CT_JSONAPI.merge(ACCEPT_JSONAPI)
+      )
+    end
+
+    private
+
+    def stack_id(stack_name)
+      show(stack_name).dig('data', 'id')
+    end
+
+    def stack_version_id(stack_name)
+      version = versions(stack_name, include_prerelease: true).find { |v| v.dig('attributes', 'version') == stack_name.version }
+      if version
+        version['id']
+      else
+        nil
+      end
+    end
+
+    def change_visibility(stack_name, is_private: true)
+      raise_unless_token
+      put(
+        '/v2/stacks/%s' % stack_id(stack_name),
+        stack_data(stack_name, is_private: is_private),
+        {},
+        CT_JSONAPI.merge(ACCEPT_JSONAPI)
+      )
+    end
+
+    def stack_data(stack_name, is_private: true)
+      {
+        data: {
+          type: 'stacks',
+          attributes: {
+            'name' => stack_name.stack,
+            'organization-id' => stack_name.user,
+            'is-private' => is_private
+          }
+        }
+      }
+    end
+  end
+end

data/lib/kontena/util.rb

@@ -0,0 +1,116 @@
+module Kontena
+  module Util
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    def symbolize_keys(obj)
+      case obj
+      when Hash
+        obj.map { |k,v| [k.to_sym, symbolize_keys(v)] }.to_h
+      when Array
+        obj.map { |v| symbolize_keys(v) }
+      else
+        obj
+      end
+    end
+    module_function :symbolize_keys
+
+    def symbolize_keys!(obj)
+      case obj
+      when Hash
+        obj.keys.each { |k| obj[k.to_sym] = symbolize_keys!(obj.delete(k)) }
+      when Array
+        obj.map! { |v| symbolize_keys!(v) }
+      else
+      end
+      obj
+    end
+    module_function :symbolize_keys!
+
+    def stringify_keys(obj)
+      case obj
+      when Hash
+        obj.map { |k,v| [k.to_s, stringify_keys(v)] }.to_h
+      when Array
+        obj.map { |v| stringify_keys(v) }
+      else
+        obj
+      end
+    end
+    module_function :stringify_keys
+
+    def stringify_keys!(obj)
+      case obj
+      when Hash
+        obj.keys.each { |k| obj[k.to_s] = stringify_keys!(obj.delete(k)) }
+      when Array
+        obj.map! { |v| stringify_keys!(v) }
+      else
+      end
+      obj
+    end
+    module_function :stringify_keys!
+
+    # @param [String] cmd
+    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
+
+    # Compatibility between ruby_dig and Ruby 2.3. Ruby_dig returns
+    # nil when trying to dig into a string, Ruby 2.3 dig raises
+    # TypeError.
+    #
+    # @param [Hash] source_hash
+    # @param [*keys] list_of_keys
+    def safe_dig(hash, *keys)
+      hash.dig(*keys)
+    rescue TypeError
+      nil
+    end
+
+    def time_ago(time)
+      now = Time.now.to_i
+      time = time.kind_of?(Integer) ? time : DateTime.parse(time).to_time.to_i
+      diff = now - time
+      seconds_to_human(diff) + ' ago'
+    end
+
+    def time_until(seconds)
+      'in ' + seconds_to_human(seconds)
+    end
+
+    def seconds_to_human(seconds)
+      if seconds > 60 * 60 * 24
+        result = "#{seconds / 60 / 60 / 24} days"
+      elsif seconds > 60 * 60
+        result = "#{seconds / 60 / 60} hours"
+      elsif seconds > 60
+        result = "#{seconds / 60} minutes"
+      else
+        result = "#{seconds} seconds"
+      end
+      result.start_with?('1 ') ? result[0..-2] : result
+    end
+
+    def longest_string_in_array(array)
+      array.max_by(&:length).length
+    end
+
+    module_function(:which)
+
+    module ClassMethods
+      def experimental?
+        ENV.has_key?('KONTENA_EXPERIMENTAL')
+      end
+    end
+
+  end
+end

data/lib/kontena_cli.rb

@@ -0,0 +1,190 @@
+require 'kontena/autoload_core'
+require 'set'
+
+$KONTENA_START_TIME = Time.now.to_f
+at_exit do
+  Kontena.logger.debug { "Execution took #{(Time.now.to_f - $KONTENA_START_TIME).round(3)} seconds" }
+  Kontena.logger.debug { "#{$!.class.name}" + ($!.respond_to?(:status) ? " status #{$!.status}" : "") } if $!
+end
+
+module Kontena
+  module Cli
+    autoload :Config, 'kontena/cli/config'
+    autoload :ShellSpinner, 'kontena/cli/spinner'
+    autoload :Spinner, 'kontena/cli/spinner'
+    autoload :Common, 'kontena/cli/common'
+    autoload :TableGenerator, 'kontena/cli/table_generator'
+  end
+
+  autoload :Command, 'kontena/command'
+  autoload :Client, 'kontena/client'
+  autoload :StacksCache, 'kontena/stacks_cache'
+  autoload :PluginManager, 'kontena/plugin_manager'
+  autoload :MainCommand, 'kontena/main_command'
+  autoload :Errors, 'kontena/errors'
+  autoload :Util, 'kontena/util'
+
+  # Run a kontena command like it was launched from the command line. Re-raises any exceptions,
+  # except a SystemExit with status 0, which is considered a success.
+  #
+  # @param [String,Array<String>] command_line
+  # @return command result or nil
+  def self.run!(*cmdline)
+    if cmdline.first.kind_of?(Array)
+      command = cmdline.first
+    elsif cmdline.size == 1 && cmdline.first.include?(' ')
+      command = cmdline.first.shellsplit
+    else
+      command = cmdline
+    end
+    logger.debug { "Running Kontena.run(#{command.inspect})" }
+    result = Kontena::MainCommand.new(File.basename(__FILE__)).run(command)
+    logger.debug { "Command completed, result: #{result.inspect} status: 0" }
+    result
+  rescue SystemExit => ex
+    logger.debug { "Command caused SystemExit, status: #{ex.status}" }
+    return true if ex.status.zero?
+    raise ex
+  rescue => ex
+    logger.error { "Command #{cmdline.inspect} exception" }
+    logger.error { ex }
+    raise ex
+  end
+
+  # Run a kontena command and return true if the command did not raise or exit with a non-zero exit code. Raises nothing.
+  # @param [String,Array<String>] command_line
+  # @return [TrueClass,FalseClass] success
+  def self.run(*cmdline)
+    result = run!(*cmdline)
+    result.nil? ? true : result
+  rescue SystemExit => ex
+    ex.status.zero?
+  rescue
+    false
+  end
+
+  def self.log_target
+    return @log_target if @log_target
+
+    @log_target = ENV['LOG_TARGET']
+
+    if debug?
+      @log_target ||= $stderr
+    elsif @log_target.nil?
+      @log_target = File.join(home, 'krates.log')
+    end
+  end
+
+  def self.reset_logger
+    @log_target, @logger = nil
+  end
+
+  def self.home
+    return @home if @home
+    @home = File.join(Dir.home, '.krates')
+    Dir.mkdir(@home, 0700) unless File.directory?(@home)
+    @home
+  end
+
+  # @return [String] x.y
+  def self.minor_version
+    Kontena::Cli::VERSION.split('.')[0..1].join('.')
+  end
+
+  def self.version
+    "krates/#{Kontena::Cli::VERSION}"
+  end
+
+  def self.on_windows?
+    ENV['OS'] == 'Windows_NT' && RUBY_PLATFORM !~ /cygwin/
+  end
+
+  def self.browserless?
+    !!(RUBY_PLATFORM =~ /linux|(?:free|net|open)bsd|solaris|aix|hpux/ && ENV['DISPLAY'].to_s.empty?)
+  end
+
+  def self.simple_terminal?
+    ENV['KONTENA_SIMPLE_TERM'] || !$stdout.tty?
+  end
+
+  def self.pastel
+    return @pastel if @pastel
+    require 'pastel'
+    @pastel = Pastel.new(enabled: !simple_terminal?)
+  end
+
+  def self.prompt
+    return @prompt if @prompt
+    if simple_terminal?
+      require_relative 'kontena/light_prompt'
+      klass = Kontena::LightPrompt
+    else
+      require 'tty-prompt'
+      klass = TTY::Prompt
+    end
+
+    @prompt = klass.new(
+      active_color: :cyan,
+      help_color: :white,
+      error_color: :red,
+      interrupt: :exit,
+      prefix: pastel.green('> ')
+    )
+  end
+
+  def self.reset_prompt
+    @prompt = nil
+  end
+
+  def self.root
+    File.dirname(__dir__)
+  end
+
+  def self.cli_root(*joinables)
+    if joinables.empty?
+      File.join(Kontena.root, 'lib/kontena/cli')
+    else
+      File.join(Kontena.root, 'lib/kontena/cli', *joinables)
+    end
+  end
+
+  def self.logger
+    return @logger if @logger
+    if log_target.respond_to?(:tty?) && log_target.tty?
+      logger = Logger.new(log_target)
+      require 'kontena/cli/log_formatters/compact'
+      logger.formatter = Kontena::Cli::LogFormatter::Compact.new
+    else
+      logger = Logger.new(log_target, 1, 1_048_576)
+      require 'kontena/cli/log_formatters/strip_color'
+      logger.formatter = Kontena::Cli::LogFormatter::StripColor.new
+    end
+    logger.level = debug? ? Logger::DEBUG : Logger::INFO
+    logger.progname = 'CLI'
+    @logger = logger
+  end
+
+  def self.debug?
+    !['', 'false'].include?(ENV['DEBUG'].to_s)
+  end
+end
+
+# Monkeypatching string to mimick 'colorize' gem
+class String
+  def colorize(color_sym)
+    ::Kontena.pastel.send(color_sym, self)
+  end
+end
+
+
+require 'retriable'
+Retriable.configure do |c|
+  c.on_retry = Proc.new do |exception, try, elapsed_time, next_interval|
+    Kontena.logger.debug { "Retriable retry: #{try} - Exception: #{exception.class.name} - #{exception.message}. Elapsed: #{elapsed_time} Next interval: #{next_interval}" }
+  end
+end
+
+require 'ruby_dig'
+require 'shellwords'
+require 'kontena/cli/version'
+Kontena.logger.debug { "Krates #{Kontena::Cli::VERSION} (ruby-#{RUBY_VERSION}+#{RUBY_PLATFORM})" }