kontena-cli 0.15.5 → 0.16.0.pre1

data/lib/kontena/cli/master/config/unset_command.rb

@@ -0,0 +1,20 @@
+module Kontena::Cli::Master::Config
+  class UnsetCommand < Kontena::Command
+
+    include Kontena::Cli::Common
+
+    requires_current_master
+    requires_current_master_token
+
+    parameter "KEY ...", "Key(s) to unset", required: true
+
+    banner "Clears a configuration value from Master"
+
+    def execute
+      self.key_list.each do |key|
+        client.delete("config/#{key}")
+      end
+    end
+  end
+end
+

data/lib/kontena/cli/master/config_command.rb

@@ -0,0 +1,24 @@
+require_relative 'config/set_command'
+require_relative 'config/get_command'
+require_relative 'config/unset_command'
+require_relative 'config/export_command'
+require_relative 'config/import_command'
+
+module Kontena
+  module Cli
+    module Master
+      class ConfigCommand < Kontena::Command
+
+        subcommand "set", "Set a config value", Kontena::Cli::Master::Config::SetCommand
+        subcommand "get", "Get a config value", Kontena::Cli::Master::Config::GetCommand
+        subcommand "unset", "Clear a config value", Kontena::Cli::Master::Config::UnsetCommand
+        subcommand ["load", "import"], "Upload config to Master", Kontena::Cli::Master::Config::ImportCommand
+        subcommand ["dump", "export"], "Download config from Master", Kontena::Cli::Master::Config::ExportCommand
+
+        def execute
+        end
+      end
+    end
+  end
+end
+

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

@@ -0,0 +1,76 @@
+module Kontena::Cli::Master
+  class CreateCommand < Kontena::Command
+    include Kontena::Cli::Common
+
+    callback_matcher :master, :create_with_plugin_select
+
+    def subcommand_tree(command = nil)
+      command ||= Kontena::MainCommand
+
+      real_command = command.respond_to?(:subcommand_class) ? command.subcommand_class : command
+
+      tree = {}
+      real_command.recognised_subcommands.each do |sub_command|
+        sub_command.names.each do |command_name|
+          if sub_command.subcommand_class.has_subcommands?
+            tree[command_name] = subcommand_tree(sub_command)
+          else
+            tree[command_name] = sub_command.subcommand_class
+          end
+        end
+      end
+      tree
+    end
+
+    def master_create_subcommands(tree)
+      creators = []
+      tree.each do |k,cmd|
+        if cmd.kind_of?(Hash)
+          creators += master_create_subcommands(cmd)
+        elsif cmd.respond_to?(:callback_matcher) && cmd.callback_matcher == [:master, :create]
+          creators << cmd
+        end
+      end
+      creators
+    end
+
+    def execute
+
+      require 'shellwords'
+
+      tree = master_create_subcommands(subcommand_tree)
+
+      if tree.empty?
+        abort "Install platform plugins first, use: kontena plugin"
+      end
+      cmd_class = prompt.select("Choose target platform") do |menu|
+        tree.each do |cmd_class|
+          plugin_name = cmd_class.to_s[/Plugin::(.+?)::/, 1]
+          next unless plugin_name
+          menu.choice plugin_name, cmd_class
+        end
+      end
+      skip_options = ['--no-prompt', '--silent', '--help', '--version']
+      options = []
+      cmd_class.recognised_options.each do |option|
+        next if option.switches.any?{ |sw| skip_options.include?(sw) }
+        if option.type == :flag
+          answer = prompt.yes?(option.description)
+          if answer
+            options << option.switches.first
+          end
+        else
+          answer = prompt.ask("#{option.description}: ", required: option.required?, default: option.default_value)
+          if answer
+            options << "#{option.switches.first} #{answer.shellescape}"
+          end
+        end
+      end
+      command = cmd_class.to_s[/Plugin::(.+?)::/, 1].downcase
+      command << " master create #{options.join(" ")}"
+      Kontena.run(command)
+    end
+  end
+
+end
+

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

@@ -1,14 +1,22 @@
+require 'uri'
+
 module Kontena::Cli::Master
-  class CurrentCommand < Clamp::Command
+  class CurrentCommand < Kontena::Command
     include Kontena::Cli::Common
 
     option ["--name"], :flag, "Show name only", default: false
+    option ["--address"], :flag, "Show IP address or FQDN only", default: false
+    option ["--url"], :flag, "Show URL only", default: false
 
     def execute
-      master = current_master
+      master = require_current_master
 
       if name?
         puts master['name']
+      elsif address?
+        puts URI.parse(master['url']).host
+      elsif url?
+        puts master['url']
       else
         puts "#{master['name']} #{master['url']}"
       end

data/lib/kontena/cli/master/join_command.rb

@@ -0,0 +1,20 @@
+module Kontena::Cli::Master
+  class JoinCommand < Kontena::Command
+    parameter "URL", "Kontena Master URL or name"
+    parameter "INVITE_CODE", "Invitation code"
+
+    option ['-n', '--name'], '[NAME]', 'Set server name'
+    option ['-r', '--remote'], :flag, 'Do not try to open a browser'
+    option ['-v', '--verbose'], :flag, 'Increase output verbosity'
+
+    def execute
+      params = []
+      params << "--join #{self.invite_code.shellescape}"
+      params << "--remote" if self.remote?
+      params << "--name #{self.name.shellescape}" if self.name
+      params << "--verbose" if self.verbose?
+
+      Kontena.run("master auth #{params.join(' ')} #{self.url.shellescape}")
+    end
+  end
+end

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

@@ -1,12 +1,12 @@
 module Kontena::Cli::Master
-  class ListCommand < Clamp::Command
+  class ListCommand < Kontena::Command
     include Kontena::Cli::Common
 
     def execute
       puts '%-24s %-30s' % ['Name', 'Url']
-      current_server = settings['current_server']
-      settings['servers'].each do |server|
-        if server['name'] == current_server
+      current_master = config.current_master
+      config.servers.each do |server|
+        if server['name'] == current_master.name
           name = "* #{server['name']}"
         else
           name = server['name']

data/lib/kontena/cli/master/login_command.rb

@@ -0,0 +1,274 @@
+require 'uri'
+
+module Kontena::Cli::Master
+  class LoginCommand < Kontena::Command
+    include Kontena::Cli::Common
+
+    parameter "[URL]", "Kontena Master URL or name"
+    option ['-j', '--join'], '[INVITE_CODE]', "Join master using an invitation code"
+    option ['-t', '--token'], '[TOKEN]', 'Use a pre-generated access token'
+    option ['-n', '--name'], '[NAME]', 'Set server name'
+    option ['-c', '--code'], '[CODE]', 'Use authorization code generated during master install'
+    option ['-r', '--remote'], :flag, 'Do not try to open a browser'
+    option ['-e', '--expires-in'], '[SECONDS]', 'Request token with expiration of X seconds. Use 0 to never expire', default: 7200
+    option ['-v', '--verbose'], :flag, 'Increase output verbosity'
+    option ['-f', '--force'], :flag, 'Force reauthentication'
+    option ['-s', '--silent'], :flag, 'Reduce output verbosity'
+
+    def execute
+      # rewrites self.url
+      use_current_master_if_available || use_master_by_name
+
+      # find server by url or create a new one
+      server = find_server_or_create_new(url)
+
+      # set server token from self.token or create a new one
+      set_server_token(server)
+
+      # set server token by exchanging code if --code given
+      use_authorization_code(server) if self.code
+
+      client = Kontena::Client.new(server.url, server.token)
+
+      # Unless an invitation code was supplied, check auth and exit
+      # if it works already.
+      unless self.join || self.force?
+        exit_if_auth_works(server)
+      end
+
+      # no local browser? tell user to launch an external one
+      if self.remote?
+        config.current_server = server.name
+        config.write
+        display_remote_message_and_exit(get_authorization_url)
+      end
+
+      # local web flow
+      response = response_from_web_flow
+
+      # If the master responds with a code, then exchange it to a token
+      if response['code']
+        vspinner "Exchanging authorization code for an access token from Kontena Master" do
+          response = client.exchange_code(response['code'])
+          unless response && response.kind_of?(Hash) && response['access_token']
+            abort "Code exchange failed"
+          end
+        end
+      end
+
+      if response['access_token']
+        update_server_token(server, response)
+        update_server_name(server, response)
+        config.current_server = server.name
+        config.write
+        display_login_info(only: :master) unless running_silent?
+        exit 0
+      end
+    end
+
+    def master_account
+      @master_account ||= config.find_account('master')
+    end
+
+    def use_current_master_if_available
+      return nil if self.url
+      if config.current_master
+        self.url = config.current_master.url
+        true
+      else
+        abort "Current master is not set and URL was not provided."
+      end
+    end
+
+    def use_master_by_name
+      return if self.url =~ /^(?:http|https):\/\//
+      server = config.find_server(self.url)
+      if server && server.url
+        self.url = server.url
+        true
+      else
+        abort "Server '#{self.url}' not found in configuration."
+      end
+    end
+
+    def find_server_or_create_new(url)
+      existing_server = config.find_server_by(url: url)
+      if existing_server && (!self.name || existing_server.name == self.name)
+        config.current_server = existing_server.name
+        existing_server
+      else
+        new_server = Kontena::Cli::Config::Server.new(url: self.url, name: self.name)
+        config.servers << new_server
+        config.current_server = new_server.name
+        new_server
+      end
+    end
+
+    def set_server_token(server)
+      if self.token
+        # Use supplied token
+        server.token = Kontena::Cli::Config::Token.new(access_token: self.token, parent_type: :master, parent_name: server.name)
+      elsif server.token.nil?
+        # Create new empty token if the server does not have one yet
+        server.token = Kontena::Cli::Config::Token.new(parent_type: :master, parent_name: server.name)
+      end
+    end
+
+    def use_authorization_code(server)
+      vspinner "Exchanging authorization code for an access token from Master" do
+        client = Kontena::Client.new(server.url, server.token)
+        response = client.exchange_code(self.code)
+
+        if response && response.kind_of?(Hash) && !response.has_key?('error')
+          server.token.access_token = response['access_token']
+          server.token.refresh_token = response['refresh_token']
+          server.token.expires_at = response['expires_in'].to_i > 0 ? Time.now.utc.to_i + response['expires_in'].to_i : nil
+          server.token.username = response['user']['name'] || response['user']['email']
+          server.username = server.token.username
+          if response['server'] && response['server']['name']
+            server.name ||= response['server']['name']
+            config.current_server = server.name
+          end
+        else
+          raise Kontena::Errors::StandardError.new(500, 'Code exchange failed')
+        end
+      end
+    end
+
+    def exit_if_auth_works(server)
+      if server && server.token && server.token.access_token
+        # See if the existing or supplied authentication works without reauthenticating
+        auth_ok = false
+        vspinner "Testing if authentication works using current access token" do
+          auth_ok = Kontena::Client.new(server.url, server.token).authentication_ok?(master_account.userinfo_endpoint)
+        end
+        if auth_ok
+          config.current_master = server.name
+          config.write
+          display_login_info(only: :master) unless running_silent?
+          exit 0
+        end
+      end
+    end
+
+    def build_auth_url_path(port = nil)
+      auth_url_params = {}
+      if self.remote?
+        auth_url_params[:redirect_uri] = "/code"
+      else
+        auth_url_params[:redirect_uri] = "http://localhost:#{port}/cb"
+      end
+      auth_url_params[:invite_code]  = self.join if self.join
+      auth_url_params[:expires_in]   = self.expires_in if self.expires_in
+      "/authenticate?#{URI.encode_www_form(auth_url_params)}"
+    end
+
+    def get_authorization_url(web_server_port = nil)
+      authorization_url = nil
+      vspinner "Sending authentication request to receive an authorization URL" do
+        client.request(
+          http_method: :get,
+          path: build_auth_url_path(web_server_port),
+          expects: [501, 400, 302, 403],
+          auth: false
+        )
+
+        case client.last_response.status
+        when 302
+          authorization_url = client.last_response.headers['Location']
+        when 501
+          abort "Authentication provider not configured"
+        when 403
+          abort "Invalid invitation code"
+        else
+          abort "Invalid response to authentication request"
+        end
+      end
+      authorization_url
+    end
+
+    def display_remote_message_and_exit(url)
+      if running_silent?
+        sputs url
+      else
+        puts "Visit this URL in a browser:"
+        puts "<#{url}>"
+        puts 
+        puts "Then complete the authentication by using:"
+        puts "kontena master login --code <CODE FROM BROWSER>"
+        # Using exit code 1 because the operation isn't complete,
+        # you can't do something like:
+        # kontena master login --remote && echo "yes"
+      end
+      exit 1 
+    end
+
+    def response_from_web_flow
+      require_relative '../localhost_web_server'
+      require 'launchy'
+
+      web_server = Kontena::LocalhostWebServer.new
+      uri = URI.parse(get_authorization_url(web_server.port))
+      puts "Opening browser to #{uri.scheme}://#{uri.host}"
+      puts
+      puts "If you are running this command over an ssh connection or it's"
+      puts "otherwise not possible to open a browser from this terminal"
+      puts "then you must use the --remote flag or use a pregenerated"
+      puts "access token using the --token option."
+      puts
+      puts "Once the authentication is complete you can close the browser"
+      puts "window or tab and return to this window to continue."
+      puts
+
+      any_key_to_continue
+
+      puts "If the browser does not open, try visiting this URL manually:"
+      puts "<#{uri.to_s}>"
+      puts
+
+      server_thread  = Thread.new { Thread.main['response'] = web_server.serve_one }
+      browser_thread = Thread.new { Launchy.open(uri.to_s) }
+     
+      vspinner "Waiting for browser authorization response" do
+        server_thread.join
+      end
+      browser_thread.join
+
+      Thread.main['response']
+    end
+
+    def in_to_at(expires_in)
+      if expires_in.to_i > 0
+        Time.now.utc.to_i + expires_in.to_i
+      else
+        nil
+      end
+    end
+
+    def update_server_token(server, response)
+      server.token = Kontena::Cli::Config::Token.new
+      server.token.access_token = response['access_token']
+      server.token.refresh_token = response['refresh_token']
+      server.token.expires_at = in_to_at(response['expires_in'])
+      server.token.username = response.fetch('user', {}).fetch('name', nil) || response.fetch('user', {}).fetch('email', nil)
+      server.username = server.token.username
+    end
+
+    def update_server_name(server, response)
+      return unless server.name.nil?
+
+      if self.name
+        server.name = self.name
+      elsif response['server'] && response['server']['name']
+        server.name = response['server']['name']
+      elsif config.find_server('default')
+        server.name = "default-#{SecureRandom.hex(2)}"
+      else
+        server.name = "default"
+      end
+    end
+
+  end
+end
+
+