pbox 1.17.2

data/lib/rhc/commands.rb

@@ -0,0 +1,396 @@
+require 'commander'
+require 'commander/command'
+
+## monkey patch option parsing to also parse global options all at once
+#  to avoid conflicts and side effects of similar short switches
+module Commander
+  class Command
+    attr_accessor :default_action, :root, :info
+    def default_action?
+      default_action.present?
+    end
+    def root?
+      root.present?
+    end
+
+    alias_method :option_old, :option
+    def option(*args, &block)
+      opts = args.pop if Hash === args.last
+      option_old(*args, &block).tap do |options|
+        options.last.merge!(opts) if opts
+      end
+    end
+
+    #
+    # Force proxy_option_struct to default to nil for values,
+    # backported for Commander 4.0.3
+    #
+    def proxy_option_struct
+      proxy_options.inject Options.new do |options, (option, value)|
+        # options that are present will evaluate to true
+        value = true if value.nil?
+        # if multiple values were specified for this option, collect it as an
+        # array. on 'fill_arguments' we will decide between stick with the array
+        # (if :type => :list) or just take the last value from array.
+        # not part of the backported method.
+        if proxy_options.select{ |item| item[0] == option }.length > 1
+          if options[option]
+            options[option] << value
+          else
+            options.__send__ :"#{option}=", [value]
+          end
+        else
+          options.__send__ :"#{option}=", value
+        end
+        options
+      end
+    end
+
+    def deprecated(as_alias=nil)
+      return false unless info
+      return info[:deprecated] if info[:deprecated]
+      return false unless info[:aliases]
+      info[:aliases].select{ |a| ['-',' '].map{ |s| Array(a[:action]).join(s) }.include?(as_alias) }.map{ |a| a[:deprecated] }.first if as_alias
+    end
+
+    def parse_options_and_call_procs *args
+      runner = Commander::Runner.instance
+      opts = OptionParser.new
+
+      # add global options
+      runner.options.each do |option|
+        opts.on(*option[:args], &runner.global_option_proc(option[:switches], &option[:proc]))
+      end
+
+      # add command options
+      @options.each do |option|
+        opts.on(*option[:args], &option[:proc])
+        opts
+      end
+
+      # Separate option lists with '--'
+      remaining = args.split('--').map{ |a| opts.parse!(a) }.inject([]) do |arr, h|
+        arr << '--'
+        arr.concat(h)
+      end
+      remaining.shift
+
+      _, config_path = proxy_options.find{ |arg| arg[0] == :config }
+      clean, _ = proxy_options.find{ |arg| arg[0] == :clean }
+
+      begin
+        @config = RHC::Config.new
+        @config.use_config(config_path) if config_path
+        $terminal.debug("Using config file #{@config.config_path}")
+
+        unless clean
+          @config.to_options.each_pair do |key, value|
+            next if proxy_options.detect{ |arr| arr[0] == key }
+            if sw = opts.send(:search, :long, key.to_s.gsub(/_/, '-'))
+              _, cb, val = sw.send(:conv_arg, nil, value) {|*exc| raise(*exc) }
+              cb.call(val) if cb
+            else
+              proxy_options << [key, value]
+            end
+          end
+        end
+      rescue ArgumentError => e
+        n = OptionParser::InvalidOption.new(e.message)
+        n.reason = "The configuration file #{@config.path} contains an invalid setting"
+        n.set_backtrace(e.backtrace)
+        raise n
+      rescue OptionParser::ParseError => e
+        e.reason = "The configuration file #{@config.path} contains an invalid setting"
+        raise
+      end
+      remaining
+    end
+  end
+end
+
+#
+# Allow Command::Options to lazily evaluate procs and lambdas
+#
+module Commander
+  class Command
+    remove_const(:Options)
+    class Options
+      def initialize(init=nil)
+        @defaults = {}
+        @table = {}
+        default(init) if init
+      end
+      def respond_to?(meth)
+        super || meth.to_s =~ /^\w+(=)?$/
+      end
+      def method_missing meth, *args, &block
+        if meth.to_s =~ /^\w+=$/
+          raise ArgumentError, "Options does not support #{meth} without a single argument" if args.length != 1
+          self[meth.to_s.chop] = args.first
+        elsif meth.to_s =~ /^\w+$/
+          if !@table.has_key?(meth) && !@defaults.has_key?(meth)
+            begin; return super; rescue NoMethodError; nil; end
+          end
+          raise ArgumentError, "Options does not support #{meth} with arguments" if args.length != 0
+          self[meth]
+        else
+          super
+        end
+      end
+      def respond_to_missing?(meth, private_method = false)
+        meth.to_s =~ /^\w+(=)?$/
+      end
+      def []=(meth, value)
+        @table[meth.to_sym] = value
+      end
+      def [](meth)
+        k = meth.to_sym
+        value = @table.has_key?(k) ? @table[k] : @defaults[k]
+        value = value.call if value.is_a? Proc
+        value
+      end
+      def __explicit__
+        @table
+      end
+      def ==(other)
+        @table == other.instance_variable_get(:@table)
+      end
+      def default defaults = {}
+        @defaults.merge!(__to_hash__(defaults))
+      end
+      def __replace__(options)
+        @table = __to_hash__(options)
+      end
+      def __hash__
+        @defaults.merge(@table)
+      end
+      def __to_hash__(obj)
+        Options === obj ? obj.__hash__ : obj
+      end
+    end
+  end
+end
+
+module RHC
+  module Commands
+    autoload :Base, 'rhc/commands/base'
+
+    def self.load
+      Dir[File.join(File.dirname(__FILE__), "commands", "*.rb")].each do |file|
+        require file
+      end
+      self
+    end
+    def self.add(opts)
+      commands[opts[:name]] = opts
+    end
+    def self.global_option(*args, &block)
+      global_options << [args.freeze, block]
+    end
+
+    def self.deprecated!
+      instance = Commander::Runner.instance
+      command_name = instance.command_name_from_args
+      command = instance.active_command
+
+      if new_cmd = command.deprecated(command_name)
+        new_cmd = "pbox #{command.name}" if new_cmd == true
+        RHC::Helpers.deprecated_command new_cmd
+      end
+    end
+
+    def self.needs_configuration!(cmd, options, config)
+      if not (cmd.class.suppress_wizard? or
+              options.noprompt or
+              options.help or
+              config.has_local_config? or
+              config.has_opts_config?)
+
+        $stderr.puts RHC::Helpers.color("You have not yet configured the ProtonBox client tools. Please run 'pbox setup'.", :yellow)
+      end
+    end
+
+    def self.to_commander(instance=Commander::Runner.instance)
+      global_options.each do |args, block|
+        args = args.dup
+        opts = (args.pop if Hash === args.last) || {}
+        option = instance.global_option(*args, &block).last
+        option.merge!(opts)
+      end
+      commands.each_pair do |name, opts|
+        name = Array(name)
+        names = [name.reverse.join('-'), name.join(' ')] if name.length > 1
+        name = name.join('-')
+
+        instance.command name do |c|
+          c.description = opts[:description]
+          c.summary = opts[:summary]
+          c.syntax = opts[:syntax]
+          c.default_action = opts[:default]
+
+          c.info = opts
+
+          (options_metadata = Array(opts[:options])).each do |o|
+            option_data = [o[:switches], o[:type], o[:description], o.slice(:optional, :default, :hide, :covered_by)].compact.flatten(1)
+            c.option *option_data
+            o[:arg] = Commander::Runner.switch_to_sym(Array(o[:switches]).last)
+          end
+
+          (args_metadata = Array(opts[:args])).each do |meta|
+            switches = meta[:switches]
+            unless switches.blank?
+              switches = switches.dup
+              switches << meta[:description]
+              switches << meta.slice(:optional, :default, :hide, :covered_by, :allow_nil)
+              c.option *switches
+            end
+          end
+
+          Array(opts[:aliases]).each do |a|
+            action = Array(a[:action])
+            [' ', '-'].each do |s|
+              cmd = action.join(s)
+              instance.alias_command cmd, name
+            end
+          end
+
+          if names
+            names.each{ |alt| instance.alias_command alt, name }
+          else
+            c.root = true
+          end
+
+          c.when_called do |args, options|
+            deprecated!
+
+            config = c.instance_variable_get(:@config)
+
+            cmd = opts[:class].new
+            cmd.options = options
+            cmd.config = config
+
+            args = fill_arguments(cmd, options, args_metadata, options_metadata, args)
+            needs_configuration!(cmd, options, config)
+
+            return execute(cmd, :help, args) unless opts[:method]
+            execute(cmd, opts[:method], args)
+          end
+        end
+      end
+      self
+    end
+
+    protected
+      def self.execute(cmd, method, args)
+        cmd.send(method, *args)
+      end
+
+      def self.fill_arguments(cmd, options, args, opts, arguments)
+        # process defaults
+        defaults = {}
+        covers = {}
+        (opts + args).each do |option_meta|
+          arg = option_meta[:option_symbol] || option_meta[:name] || option_meta[:arg] or next
+          if arg && option_meta[:type] != :list && options[arg].is_a?(Array)
+            options[arg] = options[arg].last
+          end
+          Array(option_meta[:covered_by]).each{ |sym| (covers[sym] ||= []) << arg }
+
+          case v = option_meta[:default]
+          when Symbol
+            cmd.send(v, defaults, arg)
+          when Proc
+            v.call(defaults, arg)
+          when nil
+          else
+            defaults[arg] = v
+          end
+        end
+        options.default(defaults)
+
+        # process required options
+        opts.each do |option_meta|
+          raise ArgumentError.new("Missing required option '#{option_meta[:arg]}'.") if option_meta[:required] && options[option_meta[:arg]].nil?
+        end
+
+        slots = Array.new(args.count)
+        available = arguments.dup
+
+        args.each_with_index do |arg, i|
+          value = argument_to_slot(options, available, arg)
+
+          if value.nil?
+            if arg[:allow_nil] != true && !arg[:optional]
+              raise ArgumentError, "Missing required argument '#{arg[:name]}'."
+            end
+          end
+
+          slots[i] = value
+        end
+
+        raise ArgumentError, "Too many arguments passed in: #{available.reverse.join(" ")}" unless available.empty?
+
+        # reset covered arguments
+        options.__explicit__.keys.each do |k|
+          if covered = covers[k]
+            covered.each do |sym|
+              raise ArgumentError, "The options '#{sym}' and '#{k}' cannot both be provided" unless options.__explicit__[sym].nil?
+              options[sym] = nil
+            end
+          end
+        end
+
+        slots
+      end
+
+      def self.argument_to_slot(options, available, arg)
+        if Array(arg[:covered_by]).any?{ |k| !options.__explicit__[k].nil? }
+          return nil
+        end
+
+        option = arg[:option_symbol]
+        value = options.__explicit__[option] if option
+        if value.nil?
+          value =
+            if arg[:type] == :list
+              take_leading_list(available)
+            else
+              v = available.shift
+              if v == '--'
+                v = nil
+              else
+                available.shift if available.first == '--'
+              end
+              v
+            end
+        end
+
+        value = options[option] if option && (value.nil? || (value.is_a?(Array) && value.blank?))
+        if arg[:type] == :list
+          value = Array(value)
+        end
+        options[option] = value if option && !value.nil?
+
+        value
+      end
+
+      def self.take_leading_list(available)
+        if i = available.index('--')
+          left = available.shift(i)
+          available.shift
+          left
+        else
+          left = available.dup
+          available.clear
+          left
+        end
+      end
+
+      def self.commands
+        @commands ||= {}
+      end
+      def self.global_options
+        @options ||= []
+      end
+  end
+end

data/lib/rhc/config.rb

@@ -0,0 +1,320 @@
+require 'rhc/vendor/parseconfig'
+require 'rhc/core_ext'
+
+module RHC
+
+  module ConfigEnv
+    def conf_name
+      "#{ENV['PROTONBOX_CONFIG'].presence || 'protonbox'}.conf"
+    end
+    def home_conf_dir
+      File.join(home_dir, '.protonbox')
+    end
+    def local_config_path
+      File.join(home_conf_dir, conf_name)
+    end
+    def ssh_dir
+      File.join(home_dir, '.ssh')
+    end
+    def ssh_priv_key_file_path
+      File.join(ssh_dir, 'id_rsa')
+    end
+    def ssh_pub_key_file_path
+      File.join(ssh_dir, 'id_rsa.pub')
+    end
+  end
+
+  #
+  # Responsible for encapsulating the loading and retrieval of ProtonBox
+  # configuration files and converting them to commandline option 
+  # equivalents.  It also provides the converse option - converting a set
+  # of commandline options back into a config file.
+  #
+  # In general, the values stored in the config should be identical (require
+  # little or no type conversion) to their option form.  As new global 
+  # options are added, only this class should have to change to persist that
+  # option.
+  #
+  # During normal use, a new Config object should load the appropriate
+  # settings and those settings should be converted into commandline option
+  # defaults.
+  #
+  # TODO: Encapsulate config writing to the home location
+  # TODO: Allow the config object to initialized with a path
+  # TODO: Remove deprecated methods, remove extra sources.
+  #
+  class Config
+    include ConfigEnv
+
+    # Option name     [config_key      type           comment_string_for_config]
+    #                  if nil, == key  nil == string  won't be written to file if nil
+    OPTIONS = {
+      :server =>      ['protonbox_server', nil, 'The ProtonBox server to connect to'],
+      :pblogin =>     ['default_pblogin', nil, 'Your ProtonBox username'],
+      :password =>    nil,
+      :use_authorization_tokens =>
+                      [nil, :boolean, 'If true, the server will attempt to create and use authorization tokens to connect to the server'],
+      :timeout =>     [nil, :integer, 'The default timeout for network operations'],
+      :insecure =>    [nil, :boolean, "If true, certificate errors will be ignored.\nWARNING: This may allow others to eavesdrop on your communication with ProtonBox."],
+      :ssl_version => [nil, nil, 'The SSL protocol version to use when connecting to this server'],
+      :ssl_client_cert_file => [nil, :path_to_file, 'A client certificate file for use with your server'],
+      :ssl_ca_file => [nil, :path_to_file, 'A file containing CA one or more certificates'],
+    }
+
+    def self.options_to_config(options)
+      OPTIONS.inject([]) do |arr, (name, opts)|
+        opts ||= []
+        next arr unless opts[2]
+        value = options[name]
+        arr.concat(opts[2].each_line.to_a.map(&:strip).map{ |s| "# #{s}" })
+        arr << "#{value.nil? ? '#' : ''}#{opts[0] || name}=#{self.type_to_config(opts[1], value)}"
+        arr << ""
+        arr
+      end.join("\n")
+    end
+
+    def self.type_to_config(type, value)
+      case type
+      when :integer, :boolean
+        value.nil? ? "<#{type}>" : value
+      else
+        value.nil? ? "<#{type || 'string'}>" : value
+      end
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def self.default
+      @default ||= RHC::Config.new
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def self.method_missing(method, *args, &block)
+      if default.respond_to?(method)
+        default.send(method, *args, &block)
+      else
+        raise NoMethodError, method
+      end
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def self.initialize
+      @default = nil
+      default
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def initialize
+      set_defaults
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def read_config_files
+      load_config_files
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def set_defaults
+      @defaults = RHC::Vendor::ParseConfig.new()
+      @opts  = RHC::Vendor::ParseConfig.new() # option switches that override config file
+
+      @env_config = RHC::Vendor::ParseConfig.new()
+      @global_config = nil
+      @local_config = nil
+      @opts_config = nil # config file passed in the options
+
+      @default_proxy = nil
+
+      @defaults.add('protonbox_server', 'api.protonbox.com')
+      @env_config.add('protonbox_server', ENV['PROTONBOX_SERVER']) if ENV['PROTONBOX_SERVER']
+
+      @opts_config_path = nil
+    end
+
+    def to_options
+      OPTIONS.inject({}) do |h, (name, opts)|
+          opts = Array(opts)
+          value = self[opts[0] || name.to_s]
+          if value
+            value = case opts[1]
+                    when :integer
+                      Integer(value)
+                    when :boolean
+                      !!(value =~ /^\s*(y|yes|1|t|true)\s*$/i)
+                    else
+                      value unless value.blank?
+                    end
+            h[name] = value unless value.nil?
+          end
+          h
+        end
+    end
+
+    def save!(options)
+      File.open(path, 'w'){ |f| f.puts self.class.options_to_config(options) }
+      @opts, @opts_config, @local_config, @global_config = nil
+      load_config_files
+      self
+    end
+
+    def [](key)
+      lazy_init
+
+      # evaluate in cascading order
+      configs = [@opts, @opts_config, @env_config, @local_config, @global_config, @defaults]
+      result = nil
+      configs.each do |conf|
+        result = conf[key] if !conf.nil?
+        break if !result.nil?
+      end
+
+      result
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def get_value(key)
+      self[key]
+    end
+
+    # DEPRECATED - underlying value and command option needs to be migrated to login
+    def username
+      self['default_pblogin']
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def set_local_config(conf_path, must_exist=true)
+      conf_path = File.expand_path(conf_path)
+      @config_path = conf_path if @opts_config_path.nil?
+      @local_config = RHC::Vendor::ParseConfig.new(conf_path)
+    rescue Errno::EACCES => e
+      raise Errno::EACCES.new "Could not open config file: #{e.message}" if must_exist
+    end
+
+    # DEPRECATED - needs to be renamed to something cleaner
+    def set_opts_config(conf_path)
+      @opts_config_path = File.expand_path(conf_path)
+      @config_path = @opts_config_path
+      @opts_config = RHC::Vendor::ParseConfig.new(@opts_config_path) if File.exists?(@opts_config_path)
+    rescue Errno::EACCES => e
+      raise Errno::EACCES.new "Could not open config file: #{e.message}"
+    end
+
+    def use_config(path)
+      path = File.expand_path(path)
+      set_opts_config(path)
+    rescue => e
+      raise ArgumentError, "Unable to read configuration file: #{e.message}", $!.backtrace
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def check_cpath(opts)
+      unless opts["config"].nil?
+        opts_config_path = File.expand_path(opts["config"])
+        if !File.readable?(opts_config_path)
+          raise Errno::EACCES.new "Could not open config file: #{@opts_config_path}"
+        else
+          set_opts_config(opts_config_path)
+        end
+      end
+    end
+
+    # DEPRECATED - may be made private
+    def global_config_path
+      linux_cfg = '/etc/protonbox/' + conf_name
+      File.exists?(linux_cfg) ? linux_cfg : File.join(File.expand_path(File.dirname(__FILE__) + "/../../conf"), conf_name)
+    end
+
+    def has_global_config?
+      lazy_init
+      !@global_config.nil?
+    end
+
+    def has_local_config?
+      lazy_init
+      !@local_config.nil?
+    end
+
+    def has_opts_config?
+      !@opts_config.nil?
+    end
+
+    # DEPRECATED - should be moved to Helpers
+    def should_run_ssh_wizard?
+      not File.exists? ssh_priv_key_file_path
+    end
+
+    ##
+    # config_path
+    #
+    # authoritive configuration path
+    # this is used to determine where config options should be written to
+    # when a script modifies the config such as in rhc setup
+    def config_path
+      @config_path ||= local_config_path
+    end
+    def path
+      config_path
+    end
+
+    def home_dir
+      RHC::Config.home_dir
+    end
+
+    def home_conf_path
+      home_conf_dir
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def default_pblogin
+      get_value('default_pblogin')
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def default_proxy
+      @default_proxy ||= (
+        proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
+        if proxy
+          if proxy !~ /^(\w+):\/\// then
+            proxy = "http://#{proxy}"
+          end
+          ENV['http_proxy'] = proxy
+          proxy_uri = URI.parse(ENV['http_proxy'])
+          Net::HTTP::Proxy(proxy_uri.host, proxy_uri.port, proxy_uri.user, proxy_uri.password)
+        else
+          Net::HTTP
+        end
+      )
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def using_proxy?
+      default_proxy.instance_variable_get(:@is_proxy_class) || false
+    end
+
+    # DEPRECATED - will be removed when old commands are gone
+    def proxy_vars
+      Hash[[:address,:user,:pass,:port].map do |x|
+        [x,default_proxy.instance_variable_get("@proxy_#{x}")]
+      end]
+    end
+
+    private
+      # Allow mocking of the home dir
+      def self.home_dir
+        File.expand_path('~')
+      end
+
+      def load_config_files
+        @global_config = RHC::Vendor::ParseConfig.new(global_config_path) if File.exists?(global_config_path)
+        @local_config = RHC::Vendor::ParseConfig.new(File.expand_path(local_config_path)) if File.exists?(local_config_path)
+      rescue Errno::EACCES => e
+        raise Errno::EACCES.new("Could not open config file: #{e.message}")
+      end
+
+      def lazy_init
+        unless @loaded
+          load_config_files
+          @loaded = true
+        end
+      end
+  end
+end