pbox 1.17.2

data/lib/rhc/auth/token.rb

@@ -0,0 +1,102 @@
+module RHC::Auth
+  class Token
+    def initialize(opt, auth=nil, store=nil)
+      if opt.is_a?(String)
+        @token = opt
+      else
+        @options = opt || Commander::Command::Options.new
+        @token = options[:token]
+        @no_interactive = options[:noprompt]
+        @allows_tokens = options[:use_authorization_tokens]
+      end
+      @auth = auth
+      @store = store
+      read_token
+    end
+
+    def to_request(request)
+      if token
+        debug "Using token authentication"
+        (request[:headers] ||= {})['authorization'] = "Bearer #{token}"
+      elsif auth and (!@allows_tokens or @can_get_token == false)
+        debug "Bypassing token auth"
+        auth.to_request(request)
+      end
+      request
+    end
+
+    def retry_auth?(response, client)
+      if response.status == 401
+        token_rejected(response, client)
+      else
+        false
+      end
+    end
+
+    def username
+      auth && auth.respond_to?(:username) && auth.username || options[:username]
+    end
+
+    def save(token)
+      store.put(username, protonbox_server, token) if store
+      @token = token
+    end
+
+    def can_authenticate?
+      token || auth && auth.can_authenticate?
+    end
+
+    protected
+      include RHC::Helpers
+      attr_reader :options, :token, :auth, :store
+
+      def token_rejected(response, client)
+        has_token = !!token
+        @token = nil
+
+        unless auth && auth.can_authenticate?
+          if has_token
+            raise RHC::Rest::TokenExpiredOrInvalid, "Your authorization token is expired or invalid."
+          end
+          debug "Cannot authenticate via token or password, exiting"
+          return false
+        end
+
+        if has_token
+          if cannot_retry?
+            raise RHC::Rest::TokenExpiredOrInvalid, "Your authorization token is expired or invalid."
+          end
+          if not client.supports_sessions?
+            raise RHC::Rest::AuthorizationsNotSupported
+          end
+        end
+
+        @can_get_token = client.supports_sessions? && @allows_tokens
+
+        if has_token
+          warn "Your authorization token has expired. Please sign in now to continue."
+        elsif @can_get_token
+          info "Please sign in to start a new session to #{protonbox_server}."
+        end
+
+        return auth.retry_auth?(response, client) unless @can_get_token
+
+        debug "Creating a new authorization token"
+        if auth_token = client.new_session(:auth => auth)
+          @fetch_once = true
+          save(auth_token.token)
+          true
+        else
+          auth.retry_auth?(response, client)
+        end
+      end
+
+      def read_token
+        @token ||= store.get(username, protonbox_server) if store
+      end
+
+      def cannot_retry?
+        !@fetch_once && @no_interactive
+      end
+  end
+end

data/lib/rhc/auth/token_store.rb

@@ -0,0 +1,53 @@
+require 'base64'
+
+module RHC::Auth
+  class TokenStore
+    def initialize(dir)
+      @dir = dir
+    end
+
+    def get(login, server)
+      self[key(login,server)]
+    end
+
+    def put(login, server, token)
+      self[key(login,server)] = token
+    end
+
+    def clear
+      Dir[File.join(@dir, "token_*")].
+        each{ |f| File.delete(f) unless File.directory?(f) }.
+        present?
+    end
+
+    private
+      def path(key)
+        File.join(@dir, filename(key))
+      end
+
+      def filename(key)
+        "token_#{Base64.encode64(Digest::MD5.digest(key)).gsub(/[^\w\@]/,'')}"
+      end
+
+      def []=(key, value)
+        file = path(key)
+        FileUtils.mkdir_p File.dirname(file)
+        File.open(file, 'w'){ |f| f.write(value) }
+        File.chmod(0600, file)
+        value
+      end
+
+      def [](key)
+        s = IO.read(path(key)).presence
+        s = s.strip.gsub(/[\n\r\t]/,'') if s
+        s
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def key(login, server)
+        "#{login || ''}@#{server}"
+      end
+
+  end
+end

data/lib/rhc/auth.rb

@@ -0,0 +1,5 @@
+module RHC::Auth
+  autoload :Basic,      'rhc/auth/basic'
+  autoload :Token,      'rhc/auth/token'
+  autoload :TokenStore, 'rhc/auth/token_store'
+end

data/lib/rhc/autocomplete.rb

@@ -0,0 +1,66 @@
+module RHC
+  class AutoComplete
+    attr_reader :runner
+
+    def initialize(runner=::Commander::Runner.instance, shell='bash')
+      @runner, @shell = runner, shell
+    end
+
+    def to_s
+      @s ||= template.result AutoCompleteBindings.new(self).get_binding
+    end
+
+    private
+
+      def template
+        @template ||= ERB.new(File.read(File.join(File.dirname(__FILE__), 'autocomplete_templates', "#{@shell}.erb")), nil, '-')
+      end
+  end
+
+  class AutoCompleteBindings
+    attr_reader :commands, :top_level_commands, :global_options
+
+    def initialize(data)
+      @commands = {}
+      @top_level_commands = []
+
+      data.runner.commands.each_pair do |name, cmd|
+        next if cmd.summary.nil?
+        next if cmd.deprecated(name)
+
+        if cmd.root?
+          if cmd.name == name
+            @top_level_commands << name
+          end
+        else
+          @top_level_commands << name if name == cmd.name
+          commands = name.split ' '
+          action = commands.pop
+          id = commands.join(' ')
+          v = @commands[id] || {:actions => [], :switches => []}
+          v[:actions] << action unless id == '' && name != cmd.name
+          @commands[id] = v
+        end
+
+        v = @commands[name.to_s] || {:actions => [], :switches => []}
+        v[:switches].concat(cmd.options.map do |o| 
+          if o[:switches] 
+            s = o[:switches][-1].split(' ')[0]
+            if m = /--\[no-\](.+)/.match(s)
+              s = ["--#{m[1]}", "--no-#{m[1]}"]
+            else
+              s
+            end
+          end
+        end.flatten.compact.sort)
+        @commands[name.to_s] = v
+      end
+      @commands.delete('')
+      @commands = @commands.to_a.sort{ |a,b| a[0] <=> b[0] }
+
+      @top_level_commands.sort!
+
+      @global_options = data.runner.options.map{ |o| o[:switches][-1].split(' ')[0] }.sort
+    end
+  end  
+end

data/lib/rhc/autocomplete_templates/bash.erb

@@ -0,0 +1,39 @@
+#
+# This is the bash auto completion script for the pbox command
+#
+_pbox()
+{
+  local cur opts prev
+  COMPREPLY=()
+  cur="${COMP_WORDS[COMP_CWORD]}"
+  if [ $COMP_CWORD -eq 1 ]; then
+    if [[ "$cur" == -* ]]; then
+      opts=<%= "\"%s\"" % global_options.join(' ') %>
+    elif [ -z $cur ]; then
+      opts=<%= "\"%s\"" % top_level_commands.join(' ') %>
+    else
+      opts=<%= "\"%s\"" % commands.map{ |c| c.first }.delete_if{ |s| s.include? ' ' }.sort.join(' ') %>
+    fi
+  else
+    prev="${COMP_WORDS[@]:0:COMP_CWORD}"
+    SAVE_IFS=$IFS
+    IFS=" "
+    case "${prev[*]}" in
+      <%- for name, data in commands %>
+      <%= "\"pbox %s\")" % name %>
+        if [[ "$cur" == -* ]]; then
+          opts=<%= "\"%s\"" % data[:switches].join(" ") %>
+        else
+          opts=<%= "\"%s\"" % data[:actions].join(" ") %>
+        fi
+        ;;
+      <%- end %>
+    esac
+    IFS=$SAVE_IFS
+  fi
+
+  COMPREPLY=( $(compgen -W "${opts}" -- ${cur}) )
+  return 0
+}
+
+complete -o default -F _pbox pbox

data/lib/rhc/cartridge_helpers.rb

@@ -0,0 +1,118 @@
+module RHC
+  module CartridgeHelpers
+
+    protected
+      def check_cartridges(names, opts={}, &block)
+        cartridge_names = Array(names).map{ |s| s.strip if s && s.length > 0 }.compact
+        from = opts[:from] || all_cartridges
+
+        cartridge_names.map do |name|
+          next use_cart(RHC::Rest::Cartridge.for_url(name), name) if name =~ %r(\Ahttps?://)i
+
+          name = name.downcase
+          from.find{ |c| c.name.downcase == name } ||
+          begin
+            carts = from.select{ |c| match_cart(c, name) }
+            if carts.empty?
+              paragraph { list_cartridges(from) }
+              raise RHC::CartridgeNotFoundException, "There are no cartridges that match '#{name}'."
+            elsif carts.length == 1
+              use_cart(carts.first, name)
+            else
+              carts.sort!.instance_variable_set(:@for, name)
+              carts
+            end
+          end
+        end.tap do |carts|
+          yield carts if block_given?
+        end.each do |carts|
+          if carts.is_a? Array
+            name = carts.instance_variable_get(:@for)
+            paragraph { list_cartridges(carts) }
+            raise RHC::MultipleCartridgesException, "There are multiple cartridges matching '#{name}'. Please provide the short name of the correct cart."
+          end
+        end
+      end
+
+      def use_cart(cart, for_cartridge_name)
+        if cart.name.blank? and cart.custom?
+          info "The cartridge '#{cart.url}' will be downloaded and installed"
+        else
+          info "Using #{cart.name}#{cart.display_name ? " (#{cart.display_name})" : ''} for '#{for_cartridge_name}'"
+        end
+        cart
+      end
+
+      def match_cart(cart, search)
+        search = search.to_s.downcase.gsub(/[_\-\s]/,' ')
+        [
+           cart.name,
+          (cart.tags || []).join(' '),
+        ].compact.any?{ |s| s.present? && s.downcase.gsub(/[_\-\s]/,' ').include?(search) } || 
+        search.length > 2 && [
+          cart.description
+        ].compact.any?{ |s| s.present? && !s.downcase.match(/\b#{search}\b/).nil? }
+      end
+
+      def web_carts_only
+        lambda{ |cart|
+          next cart unless cart.is_a? Array
+          name = cart.instance_variable_get(:@for)
+          matching = cart.select{ |c| not c.only_in_existing? }
+          if matching.size == 1
+            use_cart(matching.first, name)
+          else
+            matching.instance_variable_set(:@for, name)
+            matching
+          end
+        }
+      end
+
+      def other_carts_only
+        lambda{ |cart|
+          next cart unless cart.is_a? Array
+          name = cart.instance_variable_get(:@for)
+          matching = cart.select{ |c| not c.only_in_new? }
+          if matching.size == 1
+            use_cart(matching.first, name)
+          else
+            matching.instance_variable_set(:@for, name)
+            matching
+          end
+        }
+      end
+
+      def standalone_cartridges
+        @standalone_cartridges ||= all_cartridges.select{ |c| c.type == 'standalone' }
+      end
+
+      def not_standalone_cartridges
+        @not_standalone_cartridges ||= all_cartridges.select{ |c| c.type != 'standalone' }
+      end
+
+      def all_cartridges
+        @all_cartridges = rest_client.cartridges
+      end
+
+      def list_cartridges(cartridges)
+        carts = cartridges.map{ |c| [c.name, c.display_name || ''] }.sort{ |a,b| a[1].downcase <=> b[1].downcase }
+        carts.unshift ['==========', '=========']
+        carts.unshift ['Short Name', 'Full name']
+        say table(carts)
+      end
+
+      def filter_jenkins_cartridges(tag)
+        cartridges = all_cartridges.select { |c| (c.tags || []).include?(tag) && c.name =~ /\Ajenkins/i }.sort
+        raise RHC::JenkinsNotInstalledOnServer if cartridges.empty?
+        cartridges
+      end
+
+      def jenkins_cartridges
+        @jenkins_cartridges ||= filter_jenkins_cartridges('ci')
+      end
+
+      def jenkins_client_cartridges
+        @jenkins_client_cartridges ||= filter_jenkins_cartridges('ci_builder')
+      end
+  end
+end

data/lib/rhc/cli.rb

@@ -0,0 +1,40 @@
+require 'rhc'
+require 'rhc/commands'
+
+module RHC
+  #
+  # Run and execute a command line session with the PBOX tools.
+  #
+  # You can invoke the CLI with:
+  #   bundle exec ruby -e 'require "rhc/cli"; RHC::CLI.start(ARGV);' -- <arguments>
+  #
+  # from the gem directory.
+  #
+  module CLI
+    extend Commander::Delegates
+
+    def self.set_terminal
+      $terminal.wrap_at = HighLine::SystemExtensions.terminal_size.first rescue 80 if $stdin.tty?
+      $terminal.wrap_at = nil if $terminal.wrap_at == 0
+      #$terminal.page_at = :auto if $stdin.tty? and $stdout.tty?
+      # FIXME: ANSI terminals are not default on windows but we may just be
+      #        hitting a bug in highline if windows does support another method.
+      #        This is a safe fix for now but needs more research.
+      HighLine::use_color = false if RHC::Helpers.windows? or not $stdout.tty?
+    end
+
+    def self.start(args)
+      runner = RHC::CommandRunner.new(args)
+      Commander::Runner.instance_variable_set :@singleton, runner
+
+      program :name,           'pbox'
+      program :description,    'Command line interface for ProtonBox.'
+      program :version,        RHC::VERSION::STRING
+      program :help_formatter, RHC::HelpFormatter
+      program :int_message,    " Interrupted\n"
+
+      RHC::Commands.load.to_commander
+      run! || 0
+    end
+  end
+end

data/lib/rhc/command_runner.rb

@@ -0,0 +1,186 @@
+module RHC
+  class CommandRunner < Commander::Runner
+    # regex fix from git - match on word boundries
+    def valid_command_names_from *args
+      arg_string = args.delete_if { |value| value =~ /^-/ }.join ' '
+      commands.keys.find_all { |name| name if /^#{name}\b/.match arg_string }
+    end
+
+    if Commander::VERSION == '4.0.3'
+      #:nocov:
+      def program(*args)
+        Array(super).first
+      end
+      #:nocov:
+    end
+
+    def options_parse_trace
+      if @args.include?("--trace")
+        @args.delete "--trace"
+        return true
+      end
+      false
+    end
+
+    def options_parse_debug
+      if @args.include?("-d") or @args.include?("--debug")
+        @args.delete "-d"
+        @args.delete "--debug"
+        return true
+      end
+      false
+    end
+
+    def options_parse_version
+      if @args.include? "--version"
+        say version
+        exit 0
+      end
+    end
+
+    HELP_OPTIONS = ['--help', '-h']
+
+    def options_parse_help
+      if (@args & HELP_OPTIONS).present?
+        args = (@args -= HELP_OPTIONS)
+        args.shift if args.first == 'help' && !command_exists?(args.join(' '))
+        exit run_help(args)
+      end
+    end
+
+    # override so we can do our own error handling
+    def run!
+      trace = false
+      require_program :version, :description
+
+      global_option('-h', '--help', 'Help on any command', :hide => true)
+      global_option('--version', 'Display version information', :hide => true)
+
+      # special case --debug so all commands can output relevant info on it
+      $terminal.debug = options_parse_debug
+
+      # special case --trace because we need to use it in the runner
+      trace = options_parse_trace
+
+      # special case --version so it is processed before an invalid command
+      options_parse_version
+
+      # help is a special branch prior to command execution
+      options_parse_help
+
+      unless trace
+        begin
+          run_active_command
+        rescue InvalidCommandError => e
+          return RHC::Wizard.new.run unless RHC::Wizard.has_configuration? || provided_arguments.present?
+          run_help(provided_arguments)
+        rescue \
+          OptionParser::InvalidOption => e
+          RHC::Helpers.error e.message
+          1
+        rescue \
+          ArgumentError,
+          OptionParser::ParseError => e
+
+          help_bindings = CommandHelpBindings.new(active_command, commands, self)
+          usage = RHC::HelpFormatter.new(self).render_command_syntax(help_bindings)
+          message = case e
+          when OptionParser::AmbiguousOption
+            "The option #{e.args.join(' ')} is ambiguous. You will need to specify the entire option."
+          else
+            e.message
+          end
+
+          RHC::Helpers.error message
+          say "#{usage}"
+          1
+        rescue RHC::Exception, RHC::Rest::Exception => e
+          RHC::Helpers.error e.message
+          e.code.nil? ? 128 : [1, (e.code || 1).to_i].max
+        end
+      else
+        run_active_command
+      end
+    end
+
+    def provided_arguments
+      @args[0, @args.find_index { |arg| arg != '--' and arg.start_with?('-') } || @args.length]
+    end
+
+    def global_option(*args, &block)
+      opts = args.pop if Hash === args.last
+      super(*args, &block).tap do |options|
+        options.last.merge!(opts) if opts
+      end
+    end
+
+    def create_default_commands
+      command 'help options' do |c|
+        c.description = "Display all global options and information about configuration"
+        c.when_called do |args, options|
+          say help_formatter.render_options self
+          0
+        end
+      end
+      command :help do |c|
+        c.syntax = '<command>'
+        c.description = 'Display global or <command> help documentation.'
+        c.when_called(&method(:run_help))
+      end
+    end
+
+    def run_help(args=[], options=nil)
+      args.delete_if{ |a| a.start_with? '-' }
+      unless args[0] == 'commands'
+        variations = (1..args.length).reverse_each.map{ |n| args[0,n].join('-') }
+        cmd = variations.find{ |cmd| command_exists?(cmd) }
+      end
+
+      if args.empty?
+        say help_formatter.render
+        0
+      else
+        if cmd.nil?
+          matches = (variations || ['']).inject(nil) do |candidates, term|
+            term = term.downcase
+            keys = commands.keys.map(&:downcase)
+            prefix, keys = keys.partition{ |n| n.start_with? term }
+            inline, keys = keys.partition{ |n| n.include? term }
+            break [term, prefix, inline] unless prefix.empty? && inline.empty?
+          end
+
+          unless matches
+            RHC::Helpers.error "The command '#{program :name} #{provided_arguments.join(' ')}' is not recognized.\n"
+            say "See '#{program :name} help' for a list of valid commands."
+            return 1
+          end
+
+          candidates = (matches[1] + matches[2]).map{ |n| commands[n] }.uniq.sort_by{ |c| c.name }
+          if candidates.length == 1
+            cmd = candidates.first.name
+          else
+            RHC::Helpers.pager
+            RHC::Helpers.say matches[0] != '' ? "Showing commands matching '#{matches[0]}'" : "Showing all commands"
+            candidates.reverse.each do |command|
+              RHC::Helpers.paragraph do
+                aliases = (commands.map{ |(k,v)| k if command == v }.compact - [command.name]).map{ |s| "'#{s}'"}
+                aliases[0] = "(also #{aliases[0]}" if aliases[0]
+                aliases[-1] << ')' if aliases[0]
+
+                RHC::Helpers.header [RHC::Helpers.color(command.name, :cyan), *aliases.join(', ')]
+                say command.description || command.summary
+              end
+            end
+            return 1
+          end
+        end
+
+        RHC::Helpers.pager
+        command = command(cmd)
+        help_bindings = CommandHelpBindings.new command, commands, self
+        say help_formatter.render_command help_bindings
+        0
+      end
+    end
+  end
+end

data/lib/rhc/commands/account.rb

@@ -0,0 +1,25 @@
+module RHC::Commands
+  class Account < Base
+    suppress_wizard
+
+    summary "Display details about your ProtonBox account"
+    description <<-DESC
+      Shows who you are logged in to the server as and the capabilities
+      available to you on this server.
+
+      To access more details about your account please visit the website.
+      DESC
+    def run
+      user = rest_client.user
+
+      say format_table \
+            ["Login #{user.login} on #{protonbox_server}"],
+            get_properties(user, :id, :plan_id, :consumed_gears, :max_gears, :max_domains).
+              concat(get_properties(user.capabilities, :gear_sizes)).
+              push(['SSL Certificates:', user.capabilities.private_ssl_certificates ? 'yes' : 'no']), 
+            :delete => true
+
+      0
+    end
+  end
+end