rhc 0.92.11 → 0.93.18

data/bin/rhc-snapshot

@@ -46,13 +46,8 @@ rescue Exception => e
     p_usage
 end
 
-# check for gnutar - gnu tar is called tar on linux and cygwin but gnutar on
-#                    BSD based systems like MacOS X
-TAR_BIN = 'tar'
-TAR_BIN = '/usr/bin/gnutar' if File.executable?('/usr/bin/gnutar')
-
 # If provided a config path, check it
-check_cpath(opt)
+RHC::Config.check_cpath(opt)
 
 # Pull in configs from files
 libra_server = get_var('libra_server')
@@ -80,7 +75,7 @@ if !password
   password = RHC::get_password
 end
 
-user_info = RHC::get_user_info(libra_server, opt['rhlogin'], password, @http, debug, false)
+user_info = RHC::get_user_info(libra_server, opt['rhlogin'], password, RHC::Config.default_proxy, debug, false)
 
 app = opt['app']
 opt['save'] = "#{opt['app']}.tar.gz" unless opt['save'] || opt['restore']
@@ -96,47 +91,13 @@ end
 app_uuid = user_info['app_info'][app]['uuid']
 namespace = user_info['user_info']['domains'][0]['namespace']
 rhc_domain = user_info['user_info']['rhc_domain']
-if opt['save']
-  ssh_cmd = "ssh #{app_uuid}@#{app}-#{namespace}.#{rhc_domain} 'snapshot' > #{opt['save']}"
-  puts "Pulling down a snapshot to #{opt['save']}"
-else
-  if File.exists? opt['restore']
-    `#{TAR_BIN} --wildcards -tf #{opt['restore']} './*/#{app}'`
-    if $?.exitstatus != 0
-      puts "Archive at #{opt['restore']} does not contain the target application: ./*/#{app}"
-      puts "If you created this archive rather than exported with rhc-snapshot, be sure"
-      puts "the directory structure inside the archive starts with ./<app_uuid>/"
-      puts "i.e.: tar -czvf <app_name>.tar.gz ./<app_uuid>/"
-      exit 255
-    else
-      `#{TAR_BIN} --wildcards -tf #{opt['restore']} './*/git'`
-      include_git = $?.exitstatus == 0
-      ssh_cmd = "cat #{opt['restore']} | ssh #{app_uuid}@#{app}-#{namespace}.#{rhc_domain} 'restore#{include_git ? ' INCLUDE_GIT' : ''}'"
-      puts "Restoring from snapshot #{opt['restore']}"
-    end
-  else
-    puts "Archive not found: #{opt['restore']}"
-    exit 255
-  end
-end
-
 
-puts 
-puts ssh_cmd if debug
-output = `#{ssh_cmd}`
-puts
-if $?.exitstatus != 0
-    puts output
-    puts
 if opt['save']
-    puts "Error in trying to save snapshot.  You can try to save manually by running:"
+  status = RHC.snapshot_create rhc_domain, namespace, app, app_uuid, opt['save'], debug
+  exit status if ! status
 else
-    puts "Error in trying to restore snapshot.  You can try to restore manually by running:"
+  status = RHC.snapshot_restore rhc_domain, namespace, app, app_uuid, opt['restore'], debug
+  exit status if ! status
 end
-    puts
-    puts ssh_cmd
-    puts
-    exit 1
-end
-puts output if opt['restore'] && debug
+
 exit 0

data/bin/rhc-sshkey

@@ -34,7 +34,7 @@ end
 
 def validate_args(val_id=true)
   # If provided a config path, check it
-  check_cpath($opt)
+  RHC::Config.check_cpath($opt)
   
   # Pull in configs from files
   $libra_server = get_var('libra_server')
@@ -53,52 +53,6 @@ def validate_args(val_id=true)
   $password = $opt['password'] ? $opt['password'] : RHC::get_password
 end
 
-def add_or_update_key(command)
-  validate_args(true)
-  
-  # Read user public ssh key
-  if $opt['ssh']
-    if File.readable?($opt['ssh'])
-      begin
-        ssh_keyfile_contents = File.open($opt['ssh']).gets.chomp.split(' ')
-        ssh_key = ssh_keyfile_contents[1]
-        ssh_key_type = ssh_keyfile_contents[0]
-      rescue Exception => e
-        puts "Invalid public keyfile format! Please specify a valid user public keyfile."
-        exit 1
-      end
-    else
-      puts "Unable to read user public keyfile #{$opt['ssh']}"
-      exit 1
-    end
-  else # create key
-    key_name = $opt['identifier']
-    puts "Generating ssh key pair for user '#{key_name}' in the dir '#{Dir.pwd}/'"
-    # Use system for interaction
-    system("ssh-keygen -t rsa -f '#{key_name}'")
-    ssh_pub_key_file = Dir.pwd + '/' + key_name + '.pub'
-    ssh_keyfile_contents = File.open(ssh_pub_key_file).gets.chomp.split(' ')
-    ssh_key = ssh_keyfile_contents[1]
-    ssh_key_type = ssh_keyfile_contents[0]
-  end
-
-  data = {}
-  data[:rhlogin] = $opt['rhlogin']
-  data[:key_name] = $opt['identifier']
-  data[:ssh] = ssh_key
-  data[:action] = 'add-key'
-  data[:key_type] = ssh_key_type
-
-  if command == 'add'
-    data[:action] = 'add-key'
-  elsif command == 'update'
-    data[:action] = 'update-key'
-  end
-
-  url = URI.parse("https://#{$libra_server}/broker/ssh_keys")
-  handle_key_mgmt_response(url, data, $password)
-end
-
 def remove_key
   validate_args(true)
 
@@ -114,7 +68,7 @@ end
 def show_key_list
   validate_args(false)
   
-  ssh_keys = RHC::get_ssh_keys($libra_server, $opt['rhlogin'], $password, @http)
+  ssh_keys = RHC::get_ssh_keys($libra_server, $opt['rhlogin'], $password, RHC::Config.default_proxy)
   additional_ssh_keys = ssh_keys['keys']
   
   puts ""
@@ -122,46 +76,24 @@ def show_key_list
   puts "========"
 
   # first list the primary key
-  puts "Name: default"
-  puts "Type: #{ssh_keys['ssh_type']}"
-  puts " Key: #{ssh_keys['ssh_key']}"
+  puts "       Name: default"
+  puts "       Type: #{ssh_keys['ssh_type']}"
+  puts "Fingerprint: #{ssh_keys['fingerprint']}"
+  #puts "        Key: #{ssh_keys['ssh_key']}"
   puts ""
     
   # now list the additional keys
   if additional_ssh_keys && additional_ssh_keys.kind_of?(Hash)
     additional_ssh_keys.each do |name, keyval|
-      puts "Name: #{name}"
-      puts "Type: #{keyval['type']}"
-      puts " Key: #{keyval['key']}"
+      puts "       Name: #{name}"
+      puts "       Type: #{keyval['type']}"
+      puts "Fingerprint: #{keyval['fingerprint']}"
+      #puts "        Key: #{keyval['key']}"
       puts ""
     end
   end
 end
 
-def handle_key_mgmt_response(url, data, password)
-  RHC::print_post_data(data)
-  json_data = RHC::generate_json(data)
-  
-  response = RHC::http_post(@http, url, json_data, password)
-  
-  if response.code == '200'
-    begin
-      json_resp = JSON.parse(response.body)
-      RHC::update_server_api_v(json_resp)
-      RHC::print_response_success(json_resp)
-      puts "Success"
-      exit 0
-    rescue JSON::ParserError
-      RHC::print_response_err(response)
-    end
-  else
-    RHC::print_response_err(response)
-  end
-  puts "Failure"
-  exit 1
-end
-
-
 begin
   argv_c = ARGV.clone
 
@@ -223,7 +155,9 @@ p_usage 0 if $opt["help"]
 
 case argv_c[0]
 when "add", "update"
-  add_or_update_key(argv_c[0])
+  validate_args(true)
+  add_or_update_key(argv_c[0], $opt['identifier'], $opt['ssh'],
+                    $opt['rhlogin'], $password)
 when "remove"
   remove_key
 when "list", nil

data/bin/rhc-tail-files

@@ -48,7 +48,7 @@ rescue Exception => e
 end
 
 # If provided a config path, check it
-check_cpath(opt)
+RHC::Config.check_cpath(opt)
 
 # Pull in configs from files
 libra_server = get_var('libra_server')
@@ -76,7 +76,7 @@ if !password
   password = RHC::get_password
 end
 
-user_info = RHC::get_user_info(libra_server, opt['rhlogin'], password, @http, false)
+user_info = RHC::get_user_info(libra_server, opt['rhlogin'], password, RHC::Config.default_proxy, false)
 
 app = opt['app']
 
@@ -98,21 +98,29 @@ rhc_domain = user_info['user_info']['rhc_domain']
 # Red Hat OpenShift: https://bugzilla.redhat.com/show_bug.cgi?id=726646
 # OpenSSH https://bugzilla.mindrot.org/show_bug.cgi?id=396
 
-ssh_cmd = "ssh -t #{app_uuid}@#{app}-#{namespace}.#{rhc_domain} 'tail#{opt['opts'] ? ' --opts ' + Base64::encode64(opt['opts']).chomp : ''} #{file_glob}'"
+remote_cmd = "tail#{opt['opts'] ? ' --opts ' + Base64::encode64(opt['opts']).chomp : ''} #{file_glob}"
+ssh_cmd = "ssh -t #{app_uuid}@#{app}-#{namespace}.#{rhc_domain} '#{remote_cmd}'"
 
 puts "Attempting to tail files: #{file_glob}"
 puts "Use ctl + c to stop"
-puts 
 puts ssh_cmd if debug
 begin
   if opt['files'] == 'system-messages'
-     RHC::ctl_app(libra_server, @http, opt['app'], opt['rhlogin'], password, 'system-messages', false, nil, nil)
+     RHC::ctl_app(libra_server, RHC::Config.default_proxy, opt['app'], opt['rhlogin'], password,
+                  'system-messages', false, nil, nil)
   else
-     exec ssh_cmd
+     ssh_ruby("#{app}-#{namespace}.#{rhc_domain}", app_uuid, remote_cmd)
   end
-rescue SystemCallError
+rescue Interrupt
+    puts
+    puts "Terminating..."
+    exit 0
+rescue SocketError => e
+  puts
+  puts "Could not connect: #{e.message}"
   puts
-  puts "Error in trying to tail files.  You can tail manually by running:"
+  puts "DEBUG: #{e.debug}" if debug
+  puts "You can try to run this manually if you have ssh installed: "
   puts
   puts ssh_cmd
   puts

data/lib/rhc-common.rb

@@ -1,15 +1,20 @@
 require 'rubygems'
 require 'fileutils'
 require 'getoptlong'
-require 'json'
 require 'net/http'
 require 'net/https'
-#require 'net/ssh'
-require 'open3'
+require 'net/ssh'
+require 'sshkey'
 require 'parseconfig'
 require 'resolv'
 require 'uri'
+require 'highline/import'
 require 'rhc-rest'
+require 'rhc/helpers'
+require 'rhc/config'
+require 'rhc/wizard'
+require 'rhc/targz'
+require 'rhc/json'
 
 module RHC
 
@@ -68,7 +73,7 @@ module RHC
 
   def self.debug(bool)
     @mydebug = bool
-  end
+end
 
   def self.update_server_api_v(dict)
     if !dict['api'].nil? && (dict['api'] =~ PATTERN_VERSION)
@@ -87,10 +92,18 @@ module RHC
   def self.delay(time, adj=DEFAULT_DELAY)
     (time*=adj).to_int
   end
+  
+  def self.json_encode(data)
+    RHC::Json.encode(data)
+  end
+
+  def self.json_decode(json)
+    RHC::Json.decode(json)
+  end
 
   def self.generate_json(data)
       data['api'] = API
-      json = JSON.generate(data)
+      json = json_encode(data)
       json
   end
 
@@ -111,8 +124,8 @@ module RHC
       return []
     end
     begin
-      json_resp = JSON.parse(response.body)
-    rescue JSON::ParserError
+      json_resp = json_decode(response.body)
+    rescue RHC::JsonError
       exit 1
     end
     update_server_api_v(json_resp)
@@ -120,8 +133,8 @@ module RHC
       print_response_success(json_resp)
     end
     begin
-      carts = (JSON.parse(json_resp['data']))['carts']
-    rescue JSON::ParserError
+      carts = (json_decode(json_resp['data']))['carts']
+    rescue RHC::JsonError
       exit 1
     end
     carts
@@ -156,8 +169,8 @@ module RHC
   end
 
   def self.check_key(keyname)
-    check_field(keyname, 'key name', DEFAULT_MAX_LENGTH, /[^0-9_a-zA-Z]/, 
-                'contains invalid characters! Only alpha-numeric characters and underscores allowed.')
+    check_field(keyname, 'key name', DEFAULT_MAX_LENGTH, /[^0-9a-zA-Z]/, 
+                'contains invalid characters! Only alpha-numeric characters allowed.')
   end
 
   def self.check_field(field, type, max=0, val_regex=/[^0-9a-zA-Z]/, 
@@ -175,7 +188,7 @@ module RHC
       puts "#{type} is required"
       return false
     end
-    true
+    field
   end
 
   def self.print_post_data(h)
@@ -223,8 +236,8 @@ module RHC
       exit 1
     end
     begin
-      json_resp = JSON.parse(response.body)
-    rescue JSON::ParserError
+      json_resp = json_decode(response.body)
+    rescue RHC::JsonError
       exit 1
     end
     update_server_api_v(json_resp)
@@ -232,13 +245,34 @@ module RHC
       print_response_success(json_resp)
     end
     begin
-      user_info = JSON.parse(json_resp['data'].to_s)
-    rescue JSON::ParserError
+      user_info = json_decode(json_resp['data'].to_s)
+    rescue RHC::JsonError
       exit 1
     end
     user_info
   end
 
+  # Public: Get a list of ssh keys
+  #
+  # type - The String type RSA or DSS.
+  # libra_server - The String DNS for the broker
+  # rhlogin - The String login name
+  # password - The String password for login
+  # net_http - The NET::HTTP Object to use
+  #
+  # Examples
+  #
+  #  RHC::get_ssh_keys('openshift.redhat.com',
+  #                    'mylogin@example.com',
+  #                    'mypassword',
+  #                    RHC::Config.default_proxy)
+  #  # => { "ssh_type" => "ssh-rsa",
+  #         "ssh_key" => "AAAAB3NzaC1yc2EAAAADAQAB....",
+  #         "fingerprint" => "ea:08:e3:c7:e3:c3:8e:6a:66:34:65:e4:56:f4:3e:ff"}
+  #
+  # FIXME!  Exits on failure!  Should return something instead
+  #
+  # Returns Hash on success or exits on failure
   def self.get_ssh_keys(libra_server, rhlogin, password, net_http)
     data = {'rhlogin' => rhlogin, 'action' => 'list-keys'}
     if @mydebug
@@ -260,30 +294,59 @@ module RHC
       exit 1
     end
     begin
-      json_resp = JSON.parse(response.body)
-    rescue JSON::ParserError
+      json_resp = json_decode(response.body)
+    rescue RHC::JsonError
       exit 1
     end
     update_server_api_v(json_resp)
     begin
-      ssh_keys = (JSON.parse(json_resp['data'].to_s))
-    rescue JSON::ParserError
+      ssh_keys = (json_decode(json_resp['data'].to_s))
+    rescue RHC::JsonError
       exit 1
     end
+
+    # Inject public fingerprint into key.
+    begin
+      ssh_keys['fingerprint'] = \
+        Net::SSH::KeyFactory.load_data_public_key(
+          "#{ssh_keys['ssh_type']} #{ssh_keys['ssh_key']}").fingerprint
+    rescue NoMethodError 
+      #older net/ssh (mac for example)
+      tempfile = `mktemp /tmp/openshift.XXXXXXXX`
+      `echo "#{ssh_keys['ssh_type']} #{ssh_keys['ssh_key']}" > #{tempfile}`
+      ssh_keys['fingerprint'] = `ssh-keygen -lf #{tempfile}`.split(' ')[1]
+    rescue Net::SSH::Exception
+    rescue NotImplementedError
+      # key invalid, do nothing
+      # this happens if the user does not have a default key
+    end
+
+    if ssh_keys['keys'] && ssh_keys['keys'].kind_of?(Hash)
+      ssh_keys['keys'].each do |name, keyval|
+        type = keyval['type']
+        key = keyval['key']
+        begin
+          ssh_keys['keys'][name]['fingerprint'] = \
+            Net::SSH::KeyFactory.load_data_public_key(
+              "#{type} #{key}").fingerprint
+        rescue NoMethodError
+          #older net/ssh (mac for example)
+          tempfile = `mktemp /tmp/openshift.XXXXXXXX`
+          `echo "#{type} #{key}" > #{tempfile}`
+          ssh_keys['keys'][name]['fingerprint'] = `ssh-keygen -lf #{tempfile}`.split(' ')[1]
+        end
+end
+    end
     ssh_keys
   end
 
   def self.get_password
     password = nil
     begin
-      print "Password: "
-      system "stty -echo"
-      password = gets.chomp
+      password = ask_password
     rescue Interrupt
       puts "\n"
       exit 1
-    ensure
-      system "stty echo"
     end
     puts "\n"
     password
@@ -328,9 +391,9 @@ module RHC
       print_response_message(response.body)
     elsif response.content_type == 'application/json'
       begin
-        json_resp = JSON.parse(response.body)
+        json_resp = json_decode(response.body)
         exit_code = print_json_body(json_resp)
-      rescue JSON::ParserError
+      rescue RHC::JsonError
         exit_code = 1
       end
     elsif @mydebug
@@ -408,7 +471,13 @@ module RHC
   def self.create_app(libra_server, net_http, user_info, app_name, app_type, rhlogin, password, repo_dir=nil, no_dns=false, no_git=false, is_embedded_jenkins=false, gear_size='small',scale=false)
 
     # Need to have a fake HTTPResponse object for passing to print_reponse_err
-    Struct.new('FakeResponse',:body,:code,:content_type)
+    # May already be initialized if called from another piece of code
+    # FIXME: remove this requirement when refactoring rhc
+    begin
+      Struct::FakeResponse
+    rescue NameError
+      Struct.new('FakeResponse',:body,:code,:content_type)
+    end
 
     domains = user_info['user_info']['domains']
     if domains.empty?
@@ -476,9 +545,9 @@ module RHC
       response = http_post(net_http, url, json_data, password)
 
       if response.code == '200'
-        json_resp = JSON.parse(response.body)
+        json_resp = json_decode(response.body)
         print_response_success(json_resp)
-        json_data = JSON.parse(json_resp['data'])
+        json_data = json_decode(json_resp['data'])
         health_check_path = json_data['health_check_path']
         app_uuid = json_data['uuid']
         result = json_resp['result']
@@ -697,116 +766,6 @@ LOOKSGOOD
     http_post(net_http, url, json_data, password)
   end
   
-# Runs rhc-list-ports on server to check available ports
-  # :stderr return user-friendly port name, :stdout returns 127.0.0.1:8080 format
-  def self.list_ports(rhc_domain, namespace, app_name, app_uuid, debug=true)
-
-    ip_and_port_simple_regex = /[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\:[0-9]{1,5}/
-
-    ssh_host = "#{app_name}-#{namespace}.#{rhc_domain}"
-
-    ssh_cmd = "ssh -t #{app_uuid}@#{ssh_host} 'rhc-list-ports'"
-
-    hosts_and_ports = []
-    hosts_and_ports_descriptions = []
-    scaled_uuids = []
-
-    puts ssh_cmd if debug
-
-    Open3.popen3(ssh_cmd) { |stdin, stdout, stderr| 
-
-      stdout.each { |line|
-        line = line.chomp
-        if line.downcase =~ /scale/
-          scaled_uuid = line[5..-1]
-          scaled_uuids << scaled_uuid
-        else
-          if ip_and_port_simple_regex.match(line)
-            hosts_and_ports << line
-          end
-        end
-      }
-
-      stderr.each { |line|
-        line = line.chomp
-        if line.downcase =~ /permission denied/
-          puts line
-          exit 1
-        end
-        
-        
-        if line.index(ip_and_port_simple_regex)
-          hosts_and_ports_descriptions << line
-        end
-      }
-
-    }
-
-    scaled_uuids.each { |uuid|
-      list_scaled_ports(rhc_domain, namespace, app_name, uuid, hosts_and_ports, hosts_and_ports_descriptions, debug)
-    }
-    
-    #hosts_and_ports_descriptions = stderr.gets.chomp.split(/\n/)
-    #hosts_and_ports = stdout.gets.chomp.split(/\n/)
-
-    # Net::SSH.start(ssh_host, app_uuid) do |ssh| 
-
-    #   ssh.exec!("rhc-list-ports") do |channel, stream, data|
-
-    #     array = data.split(/\n/)
-
-    #     if stream == :stderr 
-    #       hosts_and_ports_descriptions = array
-    #     elsif stream == :stdout 
-    #       hosts_and_ports = array
-    #     end
-
-    #   end
-
-    # end
-
-    return hosts_and_ports, hosts_and_ports_descriptions
-
-  end
-
-  # Runs rhc-list-ports on server to check available ports
-  # :stderr return user-friendly port name, :stdout returns 127.0.0.1:8080 format
-  def self.list_scaled_ports(rhc_domain, namespace, app_name, app_uuid, hosts_and_ports, hosts_and_ports_descriptions, debug=true)
-
-    ip_and_port_simple_regex = /[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\.[0-9]{1,3}\:[0-9]{1,5}/
-
-    ssh_host = "#{app_name}-#{namespace}.#{rhc_domain}"
-
-    ssh_cmd = "ssh -t #{app_uuid}@#{ssh_host} 'rhc-list-ports'"
-
-    puts ssh_cmd if debug
-
-    Open3.popen3(ssh_cmd) { |stdin, stdout, stderr| 
-
-      stdout.each { |line|
-        line = line.chomp
-     
-        if ip_and_port_simple_regex.match(line)
-          hosts_and_ports << line
-        end
-      }
-
-      stderr.each { |line|
-        line = line.chomp
-
-        if line.downcase =~ /permission denied/
-          puts line
-          exit 1
-        end
-        
-        if line.index(ip_and_port_simple_regex)
-          hosts_and_ports_descriptions << line
-        end
-      }
-    }
-
-  end
-  
   def self.ctl_app(libra_server, net_http, app_name, rhlogin, password, action, embedded=false, framework=nil, server_alias=nil, print_result=true)
     data = {:action => action,
             :app_name => app_name,
@@ -833,13 +792,128 @@ LOOKSGOOD
     response = http_post(net_http, url, json_data, password)
     
     if response.code == '200'
-      json_resp = JSON.parse(response.body)
+      json_resp = json_decode(response.body)
       print_response_success(json_resp, print_result || @mydebug)
     else
         print_response_err(response)
     end
-    JSON.parse(response.body)
+    json_decode(response.body)
+  end
+
+  def self.snapshot_create(rhc_domain, namespace, app_name, app_uuid, filename, debug=false)
+
+    ssh_cmd = "ssh #{app_uuid}@#{app_name}-#{namespace}.#{rhc_domain} 'snapshot' > #{filename}"
+    puts "Pulling down a snapshot to #{filename}..."
+    puts ssh_cmd if debug
+    puts 
+
+    begin
+
+      if ! RHC::Helpers.windows?
+        output = `#{ssh_cmd}`
+        if $?.exitstatus != 0
+          puts output
+          puts "Error in trying to save snapshot.  You can try to save manually by running:"
+          puts
+          puts ssh_cmd
+          puts
+          return 1
+        end
+      else
+        Net::SSH.start("#{app_name}-#{namespace}.#{rhc_domain}", app_uuid) do |ssh|
+          File.open(filename, 'wb') do |file|
+            ssh.exec! "snapshot" do |channel, stream, data|
+              if stream == :stdout
+                file.write(data)
+              else
+                puts data if debug
+              end
+            end
+          end
+        end
+      end
+    rescue Exception => e
+      puts e.message
+      puts "Error in trying to save snapshot.  You can try to save manually by running:"
+      puts
+      puts ssh_cmd
+      puts
+      return 1
+    end
+    true
   end
+
+  def self.snapshot_restore(rhc_domain, namespace, app_name, app_uuid, filename, debug=false)
+    if File.exists? filename
+
+      if ! RHC::TarGz.contains filename, './*/' + app_name
+
+        puts "Archive at #{filename} does not contain the target application: ./*/#{app_name}"
+        puts "If you created this archive rather than exported with rhc-snapshot, be sure"
+        puts "the directory structure inside the archive starts with ./<app_uuid>/"
+        puts "i.e.: tar -czvf <app_name>.tar.gz ./<app_uuid>/"
+        return 255
+
+      else
+
+        include_git = RHC::TarGz.contains filename, './*/git'
+
+        ssh_cmd = "cat #{filename} | ssh #{app_uuid}@#{app_name}-#{namespace}.#{rhc_domain} 'restore#{include_git ? ' INCLUDE_GIT' : ''}'"
+        puts "Restoring from snapshot #{filename}..."
+        puts ssh_cmd if debug
+        puts 
+
+        begin
+          if ! RHC::Helpers.windows?
+            output = `#{ssh_cmd}`
+            if $?.exitstatus != 0
+              puts output
+              puts "Error in trying to restore snapshot.  You can try to restore manually by running:"
+              puts
+              puts ssh_cmd
+              puts
+              return 1
+            end
+          else
+            ssh = Net::SSH.start("#{app_name}-#{namespace}.#{rhc_domain}", app_uuid)
+            ssh.open_channel do |channel|
+              channel.exec("restore#{include_git ? ' INCLUDE_GIT' : ''}") do |ch, success|
+                channel.on_data do |ch, data|
+                  puts data
+                end
+                channel.on_extended_data do |ch, type, data|
+                  puts data
+                end
+                channel.on_close do |ch|
+                  puts "Terminating..."
+                end
+                File.open(filename, 'rb') do |file|
+                  while (line = file.gets)
+                    channel.send_data line
+                  end
+                end
+                channel.eof!
+              end
+            end
+            ssh.loop
+          end
+        rescue Exception => e
+          puts e.message if debug
+          puts "Error in trying to restore snapshot.  You can try to restore manually by running:"
+          puts
+          puts ssh_cmd
+          puts
+          return 1
+        end
+
+      end
+    else
+      puts "Archive not found: #{filename}"
+      return 255
+    end
+    true
+  end
+
 end
 
 # provide a hook for performing actions before rhc-* commands exit
@@ -856,32 +930,17 @@ at_exit {
 @conf_name = 'express.conf'
 _linux_cfg = '/etc/openshift/' + @conf_name
 _gem_cfg = File.join(File.expand_path(File.dirname(__FILE__) + "/../conf"), @conf_name)
-_home_conf = File.expand_path('~/.openshift')
-@local_config_path = File.join(_home_conf, @conf_name)
+@home_conf = File.expand_path('~/.openshift')
+@local_config_path = File.join(@home_conf, @conf_name)
 @config_path = File.exists?(_linux_cfg) ? _linux_cfg : _gem_cfg
+@home_dir=File.expand_path("~")
 
-FileUtils.mkdir_p _home_conf unless File.directory?(_home_conf)
 local_config_path = File.expand_path(@local_config_path)
-if !File.exists? local_config_path
-  file = File.open(local_config_path, 'w')
-  begin
-    file.puts <<EOF
-# SSH key file
-#ssh_key_file = 'libra_id_rsa'
-EOF
-
-  ensure
-    file.close
-  end
-  puts ""
-  puts "Created local config file: " + local_config_path
-  puts "express.conf contains user configuration and can be transferred across clients."
-  puts ""
-end
 
 begin
   @global_config = ParseConfig.new(@config_path)
-  @local_config = ParseConfig.new(File.expand_path(@local_config_path))
+  @local_config = ParseConfig.new(File.expand_path(@local_config_path)) if \
+    File.exists?(@local_config_path)
 rescue Errno::EACCES => e
   puts "Could not open config file: #{e.message}"
   exit 253
@@ -946,6 +1005,10 @@ def get_var(var)
   v
 end
 
+def ask_password
+  return ask("Password: ") { |q| q.echo = '*' }
+end
+
 def kfile_not_found
   puts <<KFILE_NOT_FOUND
 Your SSH keys are created either by running ssh-keygen (password optional)
@@ -953,7 +1016,7 @@ or by having the 'rhc domain create' command do it for you.  If you created
 them on your own (or want to use an existing keypair), be sure to paste
 your public key into the express console at http://www.openshift.com.
 The client tools use the value of 'ssh_key_file' in express.conf to find
-your key followed by the defaults of libra_id_rsa[.pub] and then
+your key followed by the defaults of id_rsa[.pub] and then
 id_rsa[.pub].
 KFILE_NOT_FOUND
 
@@ -969,7 +1032,7 @@ def get_kfile(check_exists=true)
       kfile = File.expand_path(ssh_key_file)
     end
   else
-    kfile = "#{ENV['HOME']}/.ssh/libra_id_rsa"
+    kfile = "#{ENV['HOME']}/.ssh/id_rsa"
   end
   if check_exists && !File.exists?(kfile)
     if ssh_key_file
@@ -997,8 +1060,9 @@ end
 
 # Add a new namespace to configs
 def self.add_rhlogin_config(rhlogin, uuid)
+    config_path = RHC::Config.local_config_path
     f = open(File.expand_path(config_path), 'a')
-    unless config.get_value('default_rhlogin')
+    unless RHC::Config.get_value('default_rhlogin')
         f.puts("# Default rhlogin to use if none is specified")
         f.puts("default_rhlogin=#{rhlogin}")
         f.puts("")
@@ -1006,77 +1070,189 @@ def self.add_rhlogin_config(rhlogin, uuid)
     f.close
 end
 
-# Check / add new host to ~/.ssh/config
-def self.add_ssh_config_host(rhc_domain, ssh_key_file_path, ssh_config, ssh_config_d)
-  
-  puts "Checking ~/.ssh/config"
-  ssh_key_file_name = File.basename(ssh_key_file_path)
-  if ssh_key_file_path =~ /^#{ENV['HOME']}/
-    ssh_key_file_path = ssh_key_file_path[ENV['HOME'].length..-1]
-    if ssh_key_file_path =~ /^\// || ssh_key_file_path =~ /^\\/
-      ssh_key_file_path = '~' + ssh_key_file_path
+# Public: Handle response message when updating keys
+#
+# url - The Object URI::HTTPS
+# data - The Hash representation of the data response
+# password - The String password for the user
+#
+# Examples
+#
+#  handle_key_mgmt_response(
+#                  URI.parse('https://openshift.redhat.com/broker/ssh_keys'),
+#                  {
+#                    :rhlogin=>"rhnlogin@example.com",
+#                    :key_name=>"default",
+#                    :action=>"update-key",
+#                    :ssh=>"AAAAB3NzaC1yc2EAAAADAQABAAAAgQCrXG5c.....",
+#                    :key_type=>"ssh-rsa"},
+#                  'mypass')
+#  # => nil
+#
+# Returns nil on Success and RHC::http object on failure
+def handle_key_mgmt_response(url, data, password)
+  RHC::print_post_data(data)
+  json_data = RHC::generate_json(data)
+
+  response = RHC::http_post(RHC::Config.default_proxy, url, json_data, password)
+
+  if response.code == '200'
+    begin
+      json_resp = RHC::json_decode(response.body)
+      RHC::update_server_api_v(json_resp)
+      RHC::print_response_success(json_resp)
+      puts "Success"
+      return
+    rescue RHC::JsonError
+      RHC::print_response_err(response)
+    end
+  else
+    RHC::print_response_err(response)
+  end
+  puts "Failure"
+  return response
+end
+
+# Public: Add or upload an ssh key
+#
+# type - The String type RSA or DSS.
+# command - The String value 'add' or 'update'
+# identifier - The String value to identify the key
+# pub_key_file_path - The String file path of the public key
+# rhlogin - The String login to the broker
+# password- The String password for the user
+#
+# Examples
+#
+#  generate_ssh_key_ruby('add', 'newkeyname', '~/.ssh/id_rsa',
+#                        'mylogin', 'mypass')
+#  # => /home/user/.ssh/id_rsa.pub
+#
+# Returns nil on success or HTTP object on failure
+def add_or_update_key(command, identifier, pub_key_file_path, rhlogin, password)
+
+  # Read user public ssh key
+  if pub_key_file_path
+    if File.readable?(pub_key_file_path)
+      begin
+        ssh_keyfile_contents = File.open(pub_key_file_path).gets.chomp.split(' ')
+        ssh_key = ssh_keyfile_contents[1]
+        ssh_key_type = ssh_keyfile_contents[0]
+      rescue Exception => e
+        puts "Invalid public keyfile format! Please specify a valid user public keyfile."
+        exit 1
+      end
     else
-      ssh_key_file_path = '~/' + ssh_key_file_path
+      puts "Unable to read user public keyfile #{pub_key_file_path}"
+      exit 1
     end
+  else # create key
+    key_name = identifier
+    puts "Generating ssh key pair for user '#{key_name}' in the dir '#{Dir.pwd}/'"
+    # REMOVED in favor of generate_ssh_key_ruby: system("ssh-keygen -t rsa -f '#{key_name}'")
+    ssh_pub_key_file = generate_ssh_key_ruby()
+    ssh_keyfile_contents = File.open(ssh_pub_key_file).gets.chomp.split(' ')
+    ssh_key = ssh_keyfile_contents[1]
+    ssh_key_type = ssh_keyfile_contents[0]
   end
-  if (ssh_key_file_name != 'id_rsa')
-    found = false
 
-    begin
-        File.open(ssh_config, "r") do |sline|
-            while(line = sline.gets)
-                if line.to_s.index("Host *.#{rhc_domain}") == 0
-                    found = true
-                    break
-                end
-            end
-        end
-    rescue Errno::EACCES
-        puts "Could not read from #{ssh_config}"
-        puts "Reason: " + $!
-        puts
-        puts "Please correct this first.  Then run rerun."
-        puts
-        exit 213
-    rescue Errno::ENOENT
-        puts "Could not find #{ssh_config}.  This is ok, continuing"
+  data = {}
+  data[:rhlogin] = rhlogin
+  data[:key_name] = identifier
+  data[:ssh] = ssh_key
+  data[:action] = 'add-key'
+  data[:key_type] = ssh_key_type
+
+  if command == 'add'
+    data[:action] = 'add-key'
+  elsif command == 'update'
+    data[:action] = 'update-key'
+  end
+
+  url = URI.parse("https://#{RHC::Config.get_value('libra_server')}/broker/ssh_keys")
+  handle_key_mgmt_response(url, data, password)
+end
+
+
+# Public: Generate an SSH key and store it in ~/.ssh/id_rsa
+#
+# type - The String type RSA or DSS.
+# bits - The Integer value for number of bits.
+# comment - The String comment for the key
+#
+# Examples
+#
+#  generate_ssh_key_ruby()
+#  # => /home/user/.ssh/id_rsa.pub
+#
+# Returns nil on failure or public key location as a String on success
+def generate_ssh_key_ruby(type="RSA", bits = 1024, comment = "OpenShift-Key")
+  key = SSHKey.generate(:type => type,
+                        :bits => bits,
+                        :comment => comment)
+  ssh_dir = "#{RHC::Config.home_dir}/.ssh"
+  if File.exists?("#{ssh_dir}/id_rsa")
+    puts "SSH key already exists: #{ssh_dir}/id_rsa.  Reusing..."
+    return nil
+  else
+    unless File.exists?(ssh_dir)
+      FileUtils.mkdir_p(ssh_dir)
+      File.chmod(0700, ssh_dir)
     end
-    if found
-        puts "Found #{rhc_domain} in ~/.ssh/config... No need to adjust"
-    else
-        puts "    Adding #{rhc_domain} to ~/.ssh/config"
-        begin
-            f = File.open(ssh_config, "a")
-            f.puts <<SSH
-
-# Added by 'rhc domain create' on #{`date`}
-Host *.#{rhc_domain}
-  IdentityFile #{ssh_key_file_path}
-  VerifyHostKeyDNS yes
-  StrictHostKeyChecking no
-  UserKnownHostsFile ~/.ssh/libra_known_hosts
-
-SSH
-            f.close
-        rescue Errno::EACCES
-            puts "Could not write to #{ssh_config}"
-            puts "Reason: " + $!
-            puts
-            puts "Please correct this first.  Then run rerun."
-            puts
-            exit 214
-        rescue Errno::ENOENT
-            # Make directory and config if they do not exist
-            puts "Could not find directory: " + $!
-            puts "creating"
-            FileUtils.mkdir_p ssh_config_d
-            file = File.open(ssh_config, 'w')
-            file.close
-            retry
-        end
+    File.open("#{ssh_dir}/id_rsa", 'w') {|f| f.write(key.private_key)}
+    File.chmod(0600, "#{ssh_dir}/id_rsa")
+    File.open("#{ssh_dir}/id_rsa.pub", 'w') {|f| f.write(key.ssh_public_key)}
+  end
+  "#{ssh_dir}/id_rsa.pub"
+end
+
+# Public: Run ssh command on remote host
+#
+# host - The String of the remote hostname to ssh to.
+# username - The String username of the remote user to ssh as.
+# command - The String command to run on the remote host.
+#
+# Examples
+#
+#  ssh_ruby('myapp-t.rhcloud.com',
+#            '109745632b514e9590aa802ec015b074',
+#            'rhcsh tail -f $OPENSHIFT_LOG_DIR/*"')
+#  # => true
+#
+# Returns true on success
+def ssh_ruby(host, username, command)
+  Net::SSH.start(host, username) do |session|
+    session.open_channel do |channel|
+      channel.request_pty do |ch, success|
+        puts "pty could not be obtained" unless success
+      end
+
+      channel.on_data do |ch, data|
+        #puts "[#{file}] -> #{data}"
+        puts data
+      end
+      channel.exec command
     end
+    session.loop
+  end
+end
 
-    File.chmod(0700, ssh_config_d)
-    File.chmod(0600, ssh_config)
+# Public: legacy convinience function for getting config keys
+def get_var(key)
+  RHC::Config.get_value(key)
+end
+
+# Public: convinience function for running the wizard
+#
+# Returns: false if wizard did not need to run
+#          true if wizard ran successfuly
+#          nil of there was an error
+#
+def default_setup_wizard
+  if RHC::Config.should_run_wizard?
+    w = RHC::Wizard.new(RHC::Config.local_config_path) 
+    return w.run
   end
+
+  false
 end