rhc 1.2.7 → 1.3.8

data/lib/rhc/commands/snapshot.rb

@@ -2,7 +2,7 @@ require 'rhc/commands/base'
 
 module RHC::Commands
   class Snapshot < Base
-    summary "Pull down application snapshot for a user."
+    summary "Save the current state of your application locally"
     syntax "<action>"
     alias_action :"app snapshot", :root_command => true
     default_action :help
@@ -53,9 +53,9 @@ module RHC::Commands
 
     summary "Restores a previously saved snapshot."
     syntax "<application>"
-    option ["-n", "--namespace namespace"], "Namespace of the application you are saving a snapshot", :context => :namespace_context, :required => true
-    option ["-f", "--filepath filepath"], "Local path to save tarball (default: ./$APPNAME.tar.gz)"
-    argument :app, "Application you are saving a snapshot (required)", ["-a", "--app app"]
+    option ["-n", "--namespace namespace"], "Namespace of the application you are restoring a snapshot", :context => :namespace_context, :required => true
+    option ["-f", "--filepath filepath"], "Local path to restore tarball"
+    argument :app, "Application of which you are restoring a snapshot (required)", ["-a", "--app app"]
     alias_action :"app snapshot restore", :root_command => true, :deprecated => true
     def restore(app)
 

data/lib/rhc/commands/sshkey.rb

@@ -1,10 +1,8 @@
-#! /usr/bin/env ruby
-
 require 'rhc/commands/base'
 
 module RHC::Commands
   class Sshkey < Base
-    include RHC::SSHKeyHelpers
+    include RHC::SSHHelpers
 
     summary 'Manage multiple keys for the registered rhcloud user.'
     syntax '<action>'
@@ -13,14 +11,9 @@ module RHC::Commands
     summary 'Display all the SSH keys for the user account'
     syntax ''
     def list
-      keys = rest_client.sshkeys
+      keys = rest_client.sshkeys.each{ |key| paragraph{ display_key(key) } }
 
-      results do
-        result = keys.inject('') do |r, key|
-          r += format(key, erb)
-        end
-        say result
-      end
+      success "You have #{keys.length} SSH keys associated with your account."
 
       0
     end
@@ -30,7 +23,7 @@ module RHC::Commands
     argument :name, 'SSH key to display', []
     def show(name)
       key = rest_client.find_key(name)
-      say format(key, erb)
+      display_key(key)
 
       0
     end
@@ -71,12 +64,5 @@ module RHC::Commands
 
       0
     end
-
-    private
-    # shared ERB template for formatting SSH Key
-    def erb
-      return @erb if @erb # cache
-      @erb = ::RHC::Helpers.ssh_key_display_format
-    end
   end
 end

data/lib/rhc/commands/tail.rb

@@ -1,8 +1,11 @@
 require 'rhc/commands/base'
 require 'rhc/config'
-require 'rhc-common'
+require 'rhc/ssh_helpers'
+
 module RHC::Commands
   class Tail < Base
+    include RHC::SSHHelpers
+
     summary "Tail the logs of an application"
     syntax "<application>"
     argument :app, "Name of application you wish to view the logs of", ["-a", "--app app"]
@@ -10,15 +13,35 @@ module RHC::Commands
     option ["-o", "--opts options"], "Options to pass to the server-side (linux based) tail command (applicable to tail command only) (-f is implicit.  See the linux tail man page full list of options.) (Ex: --opts '-n 100')"
     option ["-f", "--files files"], "File glob relative to app (default <application_name>/logs/*) (optional)"
     alias_action :"app tail", :root_command => true, :deprecated => true
-    def run(app)
-      begin
-        rest_domain = rest_client.find_domain(options.namespace)
-        rest_app = rest_domain.find_application(app)
-        rest_app.tail(options)
-      rescue Interrupt
-        results { say "Terminating..." }
-      end
+    def run(app_name)
+      domain = rest_client.find_domain(options.namespace)
+      app = domain.find_application(app_name)
+      cartridges = app.cartridges
+
+      tail(cartridges.first.name, URI(app.ssh_url), options)
+
       0
     end
+
+    private 
+      #Application log file tailing
+      def tail(cartridge_name, ssh_url, options)
+        debug "Tail in progress for cartridge #{cartridge_name}"
+
+        host = ssh_url.host
+        uuid = ssh_url.user
+
+        file_glob = options.files ? options.files : "#{cartridge_name}/logs/*"
+        remote_cmd = "tail#{options.opts ? ' --opts ' + Base64::encode64(options.opts).chomp : ''} #{file_glob}"
+        ssh_cmd = "ssh -t #{uuid}@#{host} '#{remote_cmd}'"
+        begin
+          #Use ssh -t to tail the logs
+          debug ssh_cmd
+          ssh_ruby(host, uuid, remote_cmd)
+        rescue
+          warn "You can tail this application directly with:\n#{ssh_cmd}"
+          raise
+        end
+      end
   end
 end

data/lib/rhc/config.rb

@@ -2,16 +2,90 @@ require 'rhc/vendor/parseconfig'
 require 'rhc/core_ext'
 
 module RHC
+
+  module ConfigEnv
+    def conf_name
+      'express.conf'
+    end
+    def home_conf_dir
+      File.join(home_dir, '.openshift')
+    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 OpenShift
+  # 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 =>      ['libra_server', nil, 'The OpenShift server to connect to'],
+      :rhlogin =>     ['default_rhlogin', nil, 'Your OpenShift login name'],
+      :password =>    nil,
+      :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 OpenShift."],
+      :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 ||= begin
-        RHC::Config.new
-      end.tap do |c|
-        c.read_config_files
-      end
+      @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)
@@ -20,74 +94,61 @@ module RHC
       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
-
-      _gem_cfg = File.join(File.expand_path(File.dirname(__FILE__) + "/../../conf"), @conf_name)
-      @global_config_path = File.exists?(@_linux_cfg) ? @_linux_cfg : _gem_cfg
     end
 
+    # DEPRECATED - will be removed when old commands are gone
     def read_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}")
+      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
-      @opts  = RHC::Vendor::ParseConfig.new() # option switches that override config file
+
       @default_proxy = nil
-      @env_config = RHC::Vendor::ParseConfig.new()
 
       @defaults.add('libra_server', 'openshift.redhat.com')
       @env_config.add('libra_server', ENV['LIBRA_SERVER']) if ENV['LIBRA_SERVER']
-      #
-      # Config paths... /etc/openshift/express.conf or $GEM/conf/express.conf -> ~/.openshift/express.conf
-      #
-      @conf_name = 'express.conf'
-      @home_dir = File.expand_path("~")
-      @home_conf_path = File.join(@home_dir, '.openshift')
-      @local_config_path = File.join(@home_conf_path, @conf_name)
-
-      # config path passed in on the command line
-      @opts_config_path = nil
 
-      # authoritive config path
-      # this can be @local_config_path or @opts_config_path
-      # @opts_config_path trumps
-      # this is used to determine where config options should be written to
-      # when a script modifies the config such as in rhc setup
-      @config_path = @local_config_path
-
-      @ssh_priv_key_file_path = "#{@home_dir}/.ssh/id_rsa"
-      @ssh_pub_key_file_path = "#{@home_dir}/.ssh/id_rsa.pub"
+      @opts_config_path = nil
+    end
 
-      @_linux_cfg = '/etc/openshift/' + @conf_name
-      @global_config_path = @_linux_cfg
+    def to_options
+      OPTIONS.inject({}) do |h, (name, opts)|
+          opts = Array(opts)
+          value = self[opts[0] || name.to_s]
+          if value
+            value = value unless value.blank?
+            h[name] = value unless value.nil?
+          end
+          h
+        end
     end
 
-    # used for tests
-    def home_dir=(home_dir)
-      @home_dir=home_dir
-      @home_conf_path = File.join(@home_dir, '.openshift')
-      @local_config_path = File.join(@home_conf_path, @conf_name)
-      @local_config = nil
-      @local_config = RHC::Vendor::ParseConfig.new(File.expand_path(@local_config_path)) if File.exists?(@local_config_path)
-      @ssh_priv_key_file_path = "#{@home_dir}/.ssh/id_rsa"
-      @ssh_pub_key_file_path = "#{@home_dir}/.ssh/id_rsa.pub"
+    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)
-      raise KeyError("Please use RHC::Config.password to access the password config") if key == "password"
+      lazy_init
 
       # evaluate in cascading order
       configs = [@opts, @opts_config, @env_config, @local_config, @global_config, @defaults]
@@ -100,58 +161,42 @@ module RHC
       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_rhlogin']
     end
 
-    # Public: configures the default user for this session
-    def config_user(username)
-      @defaults.add('default_rhlogin', username)
-    end
-
-    def opts_login=(username)
-      @opts.add('default_rhlogin', username)
-    end
-    
-    def opts_login
-      @opts['default_rhlogin']
-    end
-
-    # password is not allowed in config files and can only be passed on comman line
-    def password=(password)
-      @opts.add('password', password)
-    end
-
-    def password
-      @opts['password']
+    # 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
 
-    def set_local_config(confpath, must_exist=true)
-      begin
-        @local_config_path = File.expand_path(confpath)
-        @config_path = @local_config_path if @opts_config_path.nil?
-        @local_config = RHC::Vendor::ParseConfig.new(@local_config_path)
-      rescue Errno::EACCES => e
-        if must_exist
-          raise Errno::EACCES.new "Could not open config file: #{e.message}"
-        end
-      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 set_opts_config(confpath)
-      begin
-        @opts_config_path = File.expand_path(confpath)
-        @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"])
@@ -163,24 +208,29 @@ module RHC
       end
     end
 
+    # DEPRECATED - may be made private
+    def global_config_path
+      linux_cfg = '/etc/openshift/' + 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
-    
-    def has_opts?
-      !@opts.nil?
-    end
 
+    # DEPRECATED - should be moved to Helpers
     def should_run_ssh_wizard?
-      not File.exists? @ssh_priv_key_file_path
+      not File.exists? ssh_priv_key_file_path
     end
 
     ##
@@ -190,29 +240,26 @@ module RHC
     # 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
+      @config_path ||= local_config_path
     end
-
-    def local_config_path
-      @local_config_path
-    end
-
-    def home_conf_path
-      @home_conf_path
+    def path
+      config_path
     end
 
     def home_dir
-      @home_dir
+      RHC::Config.home_dir
     end
 
-    def ssh_pub_key_file_path
-      @ssh_pub_key_file_path
+    def home_conf_path
+      home_conf_dir
     end
 
+    # DEPRECATED - will be removed when old commands are gone
     def default_rhlogin
       get_value('default_rhlogin')
     end
 
+    # DEPRECATED - will be removed when old commands are gone
     def default_proxy
       @default_proxy ||= (
         proxy = ENV['http_proxy'] || ENV['HTTP_PROXY']
@@ -229,14 +276,36 @@ module RHC
       )
     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