cft_smartcloud 0.2.2 → 0.3.0

data/lib/smartcloud.rb

@@ -22,32 +22,39 @@ require 'restclient_fix'
 require 'hash_fix'
 require 'xmlsimple'
 require 'smartcloud_logger'
+require 'curl_client'
+require 'terminal-table'
 
 IBM_TOOLS_HOME=File.join(File.dirname(__FILE__), "cli_tools") unless defined?(IBM_TOOLS_HOME)
 
 # Encapsulates communications with IBM SmartCloud via REST
-class IBMSmartCloud
 
+class IBMSmartCloud
+ 
   attr_accessor :logger
 
-  def initialize(username, password, logger=nil, debug=false)
+  def initialize(opts={})
+    @save_response = opts[:save_response]
+    @simulated_response = opts[:simulated_response_file] && File.read(opts[:simulated_response_file])
+
     # For handling errors
-    @retries = 120
-    @sleep_interval = 30
+    @retries = (opts[:retries] || 120).to_i
+    @sleep_interval = (opts[:sleep_interval] || 30).to_i
     
-    @username = username
-    @password = password
-    @logger = logger || SmartcloudLogger.new(STDOUT)
-    @debug = debug
+    @username = opts[:username] || ENV['SMARTCLOUD_USERNAME'] || raise(RuntimeError, "Please specify username in an option or as ENV variable SMARTCLOUD_USERNAME")
+    @password = opts[:password]|| ENV['SMARTCLOUD_PASSWORD'] || raise(RuntimeError, "Please specify password in an option or as ENV variable SMARTCLOUD_PASSWORD")
+    @logger = opts[:logger] || SmartcloudLogger.new(STDOUT)
+    @debug = opts[:debug] || false
 
     @config = YAML.load_file(File.join(File.dirname(__FILE__), "config/config.yml"))
     @states = @config["states"]
 
-    @api_url = @config["api_url"]
-    @api_url.gsub!("https://", "https://#{CGI::escape(username)}:#{CGI::escape(password)}@")
-
-    RestClient.timeout = 120 # ibm requests can be very slow
-    RestClient.log = @logger if @debug
+    @api_url = (opts[:api_url] || @config["api_url"]).to_s.dup # gotta dup it because the option string is frozen
+    @api_url.gsub!("https://", "https://#{CGI::escape(@username)}:#{CGI::escape(@password)}@")
+    
+    @http_client = Kernel.const_get(@config["http_client"]) 
+    @http_client.timeout = 120 # ibm requests can be very slow
+    @http_client.log = @logger if @debug
   end
 
   class << self
@@ -57,7 +64,7 @@ class IBMSmartCloud
     attr_reader :config
   end
 
-  def self.args(method, args, extra_help={})
+  def self.help_for(method, args, extra_help={})
     @method_help||={}
     @method_help_supplemental||={}
     @method_help[method.to_s] = args
@@ -71,10 +78,7 @@ class IBMSmartCloud
         return "Sorry, I don't know method: #{method}"
       end
 
-      if args.nil?
-        puts method.to_s
-      else
-        args = args.map do |arg|
+        args = args && args.map do |arg|
           if arg.is_a?(Hash)
             # If an argument is required, just list it
             if arg.values.first==:req
@@ -93,11 +97,11 @@ class IBMSmartCloud
 
         extra_help = self.class.method_help_supplemental[method.to_s] || ""
 
-        puts "#{method.to_s}(#{args})\n#{extra_help}"
-      end
+        puts %{  * #{method.to_s}#{'(' + args + ')' if args}#{extra_help + "\n" if extra_help}}
     else
       methods = public_methods - Object.public_methods - ['post','get','put','delete','logger','logger=','help']
-      puts methods.sort.join("\n")
+      methods.sort.each {|m| help(m)}
+      nil
     end
   end
 
@@ -111,15 +115,22 @@ class IBMSmartCloud
   end
 
   def display_locations
-    log = describe_locations.map {|loc| "#{loc.ID.ljust(4)} | #{loc.Location.ljust(15)} | #{loc.Name}"}.join("\n")
-    logger.info "\n#{log}"
+
+    table = Terminal::Table.new do |t|
+      t.headings = ['ID', 'Loc', 'Name']
+      describe_locations.each do |loc|
+        t.add_row [loc.ID, loc.Location, loc.Name]
+      end
+    end
+
+    logger.info table
   end
 
   # Create an instance. The instance_params hash can follow
   # CLI-style attribute naming. I.e. "image-id" or "data-center"
   # or API-style (imageID, location). If the CLI-style params are
   # provided, they will be remapped to the correct API params.
-  args :create_instance, [:instance_params_hash], %{
+  help_for :create_instance, [:instance_params_hash], %{
     Available hash keys: :name, :imageID, :instanceType, :location, :publicKey, :ip, :volumeID, 
                          :ConfigurationData, :vlanID, :antiCollocationInstance, :isMiniEphemeral
 
@@ -161,7 +172,7 @@ class IBMSmartCloud
   end
 
   # Find a location by its name. Assumes locations have unique names (not verified by ibm docs)
-  args :get_locations_by_name, [:name]
+  help_for :get_location_by_name, [:name]
   def get_location_by_name(name)
     locations = describe_locations
     locations.detect {|loc| loc.Name == name}
@@ -169,7 +180,7 @@ class IBMSmartCloud
 
   # find all ip address offerings. If a location is specified, give the offering for the location
   # assumption: only one offering per location. This is assumed, not verified in docs.
-  args :describe_address_offerings, [{:location => :opt}]
+  help_for :describe_address_offerings, [{:location => :opt}]
   def describe_address_offerings(location=nil)
     response=get("/offerings/address").Offerings
     if location
@@ -181,7 +192,7 @@ class IBMSmartCloud
 
   # Allocate IP address. Offering ID is optional. if not specified, will look up offerings
   # for this location and pick one
-  args :allocate_address, [{:location => :req}, {:offering_id => :opt}, {:foo => [:bar, :baz, :quux]}]
+  help_for :allocate_address, [{:location => :req}, {:offering_id => :opt}, {:foo => [:bar, :baz, :quux]}]
   def allocate_address(location, offering_id=nil)
     if offering_id.nil?
       offering_id = describe_address_offerings(location).ID
@@ -190,7 +201,7 @@ class IBMSmartCloud
   end
 
 
-  args :describe_address, [:address_id]
+  help_for :describe_address, [:address_id]
   def describe_address(address_id)
     address = get("/addresses/#{address_id}").Address
     address["State"] = @config.states.ip[address.State]
@@ -198,37 +209,56 @@ class IBMSmartCloud
   end
 
   # Launches a clone image call from CLI
-  args :clone_image, [:name, :description, :image_id]
+  help_for :clone_image, [:name, :description, :image_id]
   def clone_image(name, description, image_id)
     post("/offerings/image/#{image_id}", :name => name, :description => description).ImageID
   end
 
+  # Export an image to a volume
+  help_for :export_image, [{:name=>:req}, {:size => ['Small','Medium','Large']}, {:image_id => :req}, {:location => :req}]
+  def export_image(name, size, image_id, location)
+    # Note we figure out the correct size based on the name and location
+    storage_offering=describe_storage_offerings(location, size)
+
+    response = post("/storage", :name => name, :size => storage_offering.Capacity, :format => 'EXT3', :offeringID => storage_offering.ID, :location => location, :imageID => image_id)
+    response.Volume.ID
+  end
+
+  help_for :import_image, [{:name=>:req, :volume_id => :req}] 
+  def import_image(name, volume_id)
+    # TODO: this is a complete guess as we have no info from IBM as to the URL for this api, only the parameters
+    response = post("/offerings/image", :volumeID => volume_id, :name => name)
+    response.ImageID
+  end
+
   # Launches a clone request and returns ID of new volume
   # TODO: the API call does not work, we have to use the cli for now
-  args :clone_volume, [:name, :source_disk_id]
+  help_for :clone_volume, [:name, :source_disk_id]
   def clone_volume(name, source_disk_id)
     result = post("/storage", :name => name, :sourceDiskID => source_disk_id, :type => 'clone')
     result.Volume.ID
   end
 
-  args :attach_volume, [:instance_id, :volume_id]
+  help_for :attach_volume, [:instance_id, :volume_id]
   def attach_volume(instance_id, volume_id)
     put("/instances/#{instance_id}", :volumeID => volume_id, :attach => true)
   end
 
-  args :detach_volume, [:instance_id, :volume_id]
+  help_for :detach_volume, [:instance_id, :volume_id]
   def detach_volume(instance_id, volume_id)
     put("/instances/#{instance_id}", :volumeID => volume_id, :detach => true)
   end
 
   # Delete the volume
-  args :delete_volume, [:vol_id]
+  help_for :delete_volume, [:vol_id]
   def delete_volume(vol_id)
     delete("/storage/#{vol_id}")
     true
   end
 
-  args :delete_volumes, [:volume_ids], %{Example: smartcloud "delete_volumes(12345,12346,12347)"}
+  help_for :delete_volumes, [:volume_ids], %{
+    Example: smartcloud "delete_volumes(12345,12346,12347)"
+  }
   def delete_volumes(*vol_id_list)
     threads=[]
     vol_id_list.each {|vol| 
@@ -239,7 +269,10 @@ class IBMSmartCloud
   end
 
   # generates a keypair and returns the private key
-  args :generate_keypair, [{:name=>:req}, {:publicKey=>:opt}], %{ If publicKey parameter is given, creates a key with that public key, and returns nothing. If public key is omitted, generates a new key and returns the pirvate key.}
+  help_for :generate_keypair, [{:name=>:req}, {:publicKey=>:opt}], %{ 
+    If publicKey parameter is given, creates a key with that public key, and returns nothing. 
+    If public key is omitted, generates a new key and returns the pirvate key.
+  }
   def generate_keypair(name, publicKey=nil)
     options = {:name => name}
     options[:publicKey] = publicKey if publicKey
@@ -251,26 +284,28 @@ class IBMSmartCloud
     end
   end
 
-  args :remove_keypair, [:name]
+  help_for :remove_keypair, [:name]
   def remove_keypair(name)
     delete("/keys/#{name}")
     true
   end
+  alias remove_key remove_keypair
+  alias delete_key remove_keypair
 
-  args :describe_key, [:name]
+  help_for :describe_key, [:name]
   def describe_key(name)
     get("/keys/#{name}").PublicKey
   end
 
-  args :update_key, [:name, :publicKey]
+  help_for :update_key, [:name, :publicKey]
   def update_key(name, key)
     put("/keys/#{name}", :publicKey => key)
   end
 
   # If address_id is supplied, will return info on that address only
-  args :describe_addresses, [{:address_id=>:opt}]
+  help_for :describe_addresses, [{:address_id=>:opt}]
   def describe_addresses(address_id=nil)
-    response = get("/addresses").Address
+    response = arrayize(get("/addresses").Address)
     response.each do |a|
       a["State"] = @states["ip"][a.State.to_i]
     end
@@ -283,49 +318,48 @@ class IBMSmartCloud
   def display_addresses
     addresses = describe_addresses
 
-    logger.info "\nID     | Loc  | State      | IP \n" + addresses.map {|a| 
-      a.ID.ljust(6) + " | " + a.Location.ljust(4) + " | " + (a.State[0..9].ljust(10) rescue '?'.ljust(10)) + " | " + (a.IP.to_s || "")
-    }.join("\n")
+    table = Terminal::Table.new do |t|
+      t.headings = ['ID', 'Loc', 'State', 'IP']
+      addresses.each do |a|
+        t.add_row [a.ID, a.Location, a.State, a.IP]
+      end
+    end
+
+    logger.info table
   end
 
   # Allows you to poll for a specific storage state
   # ex: storage_state_is?("123456", "UNMOUNTED")
   # storage state string can be given as a string or symbol
-  args :describe_addresses, [{:address_id=>:req}, {:state_string=>%w(new attached etc...)}]
+  help_for :describe_addresses, [{:address_id=>:req}, {:state_string=>%w(new attached etc...)}]
   def address_state_is?(address_id, state_string)
     v = describe_addresses(address_id)
     v.State.to_s == state_string.to_s.upcase
   end
 
   def describe_keys
-    get("/keys").PublicKey
+    arrayize(get("/keys").PublicKey)
   end
 
   def describe_unused_keys
     describe_keys.select {|key| key.Instances == {}}
   end
 
-  def delete_unused_keys(auto=false)
-    describe_unused_keys.each do |key|
-      if auto
-        remove_keypair(key.KeyName)
-      else
-        puts "Remove key #{key.KeyName}? (type 'y' to continue): "
-        input = gets.strip
-        if input == 'y'
-          remove_keypair(key.KeyName)
-        else
-          puts "Not removing key #{key.KeyName}"
-        end
+  def display_keys 
+    keys = describe_keys
+
+    table = Terminal::Table.new do |t|
+      t.headings = ['KeyName', 'Used By Instances', 'Last Modified']
+      keys.each do |k|
+        t.add_row [k.KeyName, (k.Instances.empty? ? '[NONE]' : arrayize(k.Instances.InstanceID).join("\n")), time_format( k.LastModifiedTime )]
       end
     end
+    
+    logger.info table
   end
+  alias display_keypairs display_keys
 
-  def display_keys 
-    logger.info "\nKeyName".ljust(50) + "  | Instance ID's\n" +  describe_keys.map {|key| key.KeyName.strip.ljust(50) + " | " + (key.Instances.empty? ? '[]' : key.Instances.InstanceID.inspect  )}.join("\n")
-  end
-
-  args :supported_instance_types, [:image_id]
+  help_for :supported_instance_types, [:image_id]
   def supported_instance_types(image_id)
     img=describe_image(image_id)
     arrayize(img.SupportedInstanceTypes.InstanceType).map(&:ID)
@@ -337,8 +371,8 @@ class IBMSmartCloud
 
   # Optionally supply a location to get offerings filtered to a particular location
   # Optionally supply a name (Small, Medium, Large) to get the specific offering
-  args :describe_volume_offerings, [{:location => :opt}, {:name => :opt}]
-  args :describe_storage_offerings, [{:location => :opt}, {:name => :opt}]
+  help_for :describe_volume_offerings, [{:location => :opt}, {:name => :opt}]
+  help_for :describe_storage_offerings, [{:location => :opt}, {:name => :opt}]
   def describe_storage_offerings(location=nil, name=nil)
     response = get("/offerings/storage")
     if location
@@ -361,13 +395,18 @@ class IBMSmartCloud
   # ex: create_volume("yan", 61, "Small", "20001208", 61)
   #
   # NOTE: storage area id is not currently supported by IBM (according to docs)
-  args :create_volume, [{:name => :req},{:location_id => :req},{:size => ['Small','Medium','Large']}, {:offering_id => :opt}, {:format => :opt}]
+  help_for :create_volume, [{:name => :req},{:location_id => :req},{:size => ['Small','Medium','Large']}, {:offering_id => :opt}, {:format => :opt}]
   def create_volume(name, location, size, offering_id=nil, format="EXT3")
 
     # figure out the offering ID automatically based on location and size
     if offering_id.nil?
       logger.debug "Looking up volume offerings based on location: #{location} and size: #{size}"
-      offering_id = describe_volume_offerings(location, size).ID
+      offering = describe_volume_offerings(location, size)
+      offering_id = if offering
+        offering.ID
+      else
+        raise "Unable to locate offering with location #{location}, size #{size}."
+      end
     end
 
     logger.debug "Creating volume...please wait."
@@ -376,21 +415,13 @@ class IBMSmartCloud
   end
 
   # Optionally takes a volume id, if none supplied, will show all volumes
-  args :describe_storage, [{:volume_id => :opt}]
+  help_for :describe_storage, [{:volume_id => :opt}]
   def describe_storage(volume_id=nil)
     response = volume_id ? get("/storage/#{volume_id}") : get("/storage")
 
-    if response.Volume.is_a?(Array)
-      response.Volume.each do |v|
-        v["State"] = @states["storage"][v.State.to_i]
-      end
-    elsif response.Volume
-      response.Volume["State"] = @states["storage"][response.Volume.State.to_i]
-    else
-      return []
+    arrayize(response.Volume).each do |v|
+      v["State"] = @states["storage"][v.State.to_i]
     end
-
-    response.Volume
   end
 
   alias describe_volumes describe_storage
@@ -398,16 +429,21 @@ class IBMSmartCloud
 
   # This does a human-usable version of describe_volumes with the critical info (name, id, state)
   # Optionally takes a filter (currently supports state). i.e. display_volumes(:state => :mounted)
-  args :display_volumes, [{:filter => :opt}]
+  help_for :display_volumes, [{:filters => :opt}], %{
+    Example filters: {:Name => "match-name", :Location => 101}
+  }
   def display_volumes(filter={})
     vols = describe_volumes
     vols = filter_and_sort(vols, filter)
 
-    log = "\nVolume | State      | Loc  | Name\n"
-    volsz = vols.map {|vol| vol.ID.ljust(6) + " | " + (vol.State[0..9].ljust(10) rescue '?'.ljust(10)) + " | " + vol.Location.ljust(4) + " | " + vol.Name }.join("\n")
-    log << volsz
-    logger.info log
-    true
+    table = Terminal::Table.new do |t|
+      t.headings = %w(Volume State Loc Name CreatedTime)
+      vols.each do |vol|
+        t.add_row [vol.ID, vol.State, vol.Location, vol.Name, time_format(vol.CreatedTime)]
+      end
+    end
+
+    logger.info table
   end
   
   alias display_storage display_volumes
@@ -415,9 +451,10 @@ class IBMSmartCloud
   # Allows you to poll for a specific storage state
   # ex: storage_state_is?("123456", "UNMOUNTED")
   # storage state string can be given as a string or symbol
-  args :storage_state_is?, [{:volume_id => :req}, {:state_string => %w(mounted unmounted etc...)}]
+  help_for :storage_state_is?, [{:volume_id => :req}, {:state_string => %w(mounted unmounted etc...)}]
   def storage_state_is?(volume_id, state_string)
     v = describe_storage(volume_id)
+    v = v.first if v.is_a?(Array)
 
     @last_storage_state||={}
     if @last_storage_state[volume_id.to_s] != v.State
@@ -433,7 +470,7 @@ class IBMSmartCloud
 
   end
 
-  args :instance_state_is?, [{:instance_id=> :req}, {:state_string => %w(active stopping etc...)}]
+  help_for :instance_state_is?, [{:instance_id=> :req}, {:state_string => %w(active stopping etc...)}]
   def instance_state_is?(instance_id, state_string)
     v = describe_instance(instance_id)
 
@@ -451,7 +488,7 @@ class IBMSmartCloud
   end
 
   # Polls until volume state is matched. When it is, returns entire volume descriptor hash.
-  args :poll_for_volume_state, [{:volume_id => :req}, {:state_string => %w(mounted unmounted etc...)}]
+  help_for :poll_for_volume_state, [{:volume_id => :req}, {:state_string => %w(mounted unmounted etc...)}]
   def poll_for_volume_state(volume_id, state_string, polling_interval=5)
     logger.debug "Polling for volume #{volume_id} to acquire state #{state_string} (interval: #{polling_interval})..."
     while(true)
@@ -462,7 +499,7 @@ class IBMSmartCloud
   end
 
   # Polls until instance state is matched. When it is, returns entire instance descriptor hash.
-  args :poll_for_instance_state, [{:instance_id => :req}, {:state_string => %w(active stopped etc...)}]
+  help_for :poll_for_instance_state, [{:instance_id => :req}, {:state_string => %w(active stopped etc...)}]
   def poll_for_instance_state(instance_id, state_string, polling_interval=5)
     logger.debug "Polling for instance #{instance_id} to acquire state #{state_string} (interval: #{polling_interval})..."
     while(true)
@@ -473,7 +510,9 @@ class IBMSmartCloud
   end
 
   # Deletes many instances in a thread
-  args :delete_instances, [:instance_ids], %{Example: smartcloud "delete_instances(12345,12346,12347)"}
+  help_for :delete_instances, [:instance_ids], %{
+    Example: smartcloud "delete_instances(12345,12346,12347)"
+  }
   def delete_instances(*instance_ids)
     threads=[]
     instance_ids.each {|id| logger.info "Sending delete request for: #{id}..."; threads << Thread.new { delete_instance(id) }; logger.info "Finished delete request for #{id}" }
@@ -481,24 +520,25 @@ class IBMSmartCloud
     true
   end
 
-  args :rename_instance, [:instance_id, :new_name]
+  help_for :rename_instance, [:instance_id, :new_name]
   def rename_instance(instance_id, new_name)
     put("/instances/#{instance_id}", :name => new_name)
+    true
   end
 
-  args :delete_instance, [:instance_id]
+  help_for :delete_instance, [:instance_id]
   def delete_instance(instance_id)
     delete("/instances/#{instance_id}")
     true
   end
   
-  args :restart_instance, [:instance_id]
+  help_for :restart_instance, [:instance_id]
   def restart_instance(instance_id)
     put("/instances/#{instance_id}", :state => "restart")
     true
   end
 
-  args :describe_instance, [:instance_id]
+  help_for :describe_instance, [:instance_id]
   def describe_instance(instance_id)
     response = get("instances/#{instance_id}").Instance
     response["Status"] = @states["instance"][response.Status.to_i]
@@ -508,7 +548,7 @@ class IBMSmartCloud
   # You can filter by any instance attributes such as
   # describe_instances(:name => "FOO_BAR", :status => 'ACTIVE')
   # in the case of status you can also use symbols like :status => :active
-  args :describe_instances, [:filters => :opt]
+  help_for :describe_instances, [:filters => :opt]
   def describe_instances(filters={})
     instances = arrayize(get("instances").Instance)
     
@@ -525,30 +565,34 @@ class IBMSmartCloud
   # display_instances(:order => "Name") or :order => "LaunchTime"
   #
 
-  args :display_instances, [:filters => :opt], %{example: smartcloud "display_instances(:name=>'matchMe')"}
+  help_for :display_instances, [:filters => :opt], %{
+    Example: smartcloud "display_instances(:name=>'matchMe')"
+  }
   def display_instances(filters={})
     instances = describe_instances(filters)
 
-    log = %{#{"Started".ljust(18)} | #{"Instance".ljust(8)} | #{"Image".ljust(9)} | #{"Loc".ljust(3)} | #{"Status".ljust(10)} | #{"KeyName".ljust(15)} | #{"IP".ljust(15)} | #{"Volume".ljust(6)} | Name\n}
-    log << instances.map do |ins|
-      ip = (ins.IP && ins.IP.to_s) || ""
-      ip = (ip.strip == "") ? "[NONE]" : ip.strip
-      "#{DateTime.parse(ins.LaunchTime).strftime("%Y-%m-%d %I:%M%p")} | #{ins.ID.ljust(8)} | #{ins.ImageID.ljust(9)} | #{ins.Location.ljust(3)} | #{ins.Status[0..9].ljust(10)} | #{(ins.KeyName || "").strip[0..14].ljust(15)} | #{ip.ljust(15)} | #{(ins.Volume && ins.Volume || "").ljust(6)} | #{ins.Name}" 
-    end.join("\n")
-    logger.info "\n#{log}"
+    table = Terminal::Table.new do |t|
+      t.headings = ['ID', 'LaunchTime', 'Name', 'Key', 'ID', 'Loc', 'Status', 'IP', 'Volume']
+      instances.each do |ins|
+        launchTime = time_format(ins.LaunchTime)
+        t.add_row [ins.ID, launchTime, ins.Name, ins.KeyName, ins.ImageID, ins.Location, ins.Status, ins.IP && ins.IP.strip, ins.Volume]
+      end
+    end
+    table.style = {:padding_left => 0, :padding_right => 0, :border_y => ' ', :border_x => '-'}
+    logger.info table
   end
 
 
-  args :describe_image, [:image_id]
+  help_for :describe_image, [:image_id]
   def describe_image(image_id)
     image = get("offerings/image/#{image_id}").Image
     image["State"] = @states["image"][image.State.to_i]
     image 
   end
 
-  args :describe_images, [:filters => :opt]
+  help_for :describe_images, [:filters => :opt]
   def describe_images(filters={})
-    images = arrayize(get("offerings/image/").Image)
+    images = arrayize(get("offerings/image").Image)
     images.each {|img| img["State"] = @states["image"][img.State.to_i]}
     filters[:order] ||= "Location"
     images = filter_and_sort(images, filters)
@@ -558,20 +602,25 @@ class IBMSmartCloud
     get("offerings/image/#{image_id}/manifest").Manifest
   end
 
-  args :display_images, [:filters => :opt]
+  help_for :display_images, [:filters => :opt]
   def display_images(filters={})
     images = describe_images(filters)
 
-    log = images.map do |i|
-      types = arrayize(i.SupportedInstanceTypes.InstanceType).map(&:ID).join(", ") rescue "[INSTANCE TYPE UNKNOWN]"
-      "#{i.ID} | #{i.Location} | #{i.Name} | #{types}" 
-    end.join("\n")
-    logger.info "\n#{log}"
+    table = Terminal::Table.new do |t|
+      t.headings = ['ID', 'Loc', 'Name & Type', 'Platform', 'Arch']
+      images.each do |i|
+        types = arrayize(i.SupportedInstanceTypes.InstanceType).map(&:ID).join("\n") rescue "[INSTANCE TYPE UNKNOWN]"
+        t.add_row [i.ID, i.Location, i.Name + "\n" + types, i.Platform, i.Architecture]
+        t.add_separator unless i == images.last
+      end
+    end
+
+    logger.info table
   end
 
   def delete(path)
     rescue_and_retry_errors do
-      output = RestClient.delete File.join(@api_url, path), :accept => :response
+      output = @http_client.delete File.join(@api_url, path), :accept => :response
       response = XmlSimple.xml_in(output, {'ForceArray' => nil})
     end
   end
@@ -579,22 +628,38 @@ class IBMSmartCloud
   def put(path, params={}, param_remap={})
     rescue_and_retry_errors do
       param_string = make_param_string(params, param_remap)
-      output = RestClient.put File.join(@api_url, path), param_string, :accept => :response
+      output = @http_client.put File.join(@api_url, path), param_string, :accept => :response
       response = XmlSimple.xml_in(output, {'ForceArray' => nil})
     end
   end
 
   def get(path)
     rescue_and_retry_errors do
-      output = RestClient.get File.join(@api_url, path), :accept => :response
-      response = XmlSimple.xml_in(output, {'ForceArray' => nil})
+      output = if @simulated_response
+        @simulated_response
+      else
+        @http_client.get File.join(@api_url, path) 
+      end
+
+      # Save Response for posterity
+      if @save_response && !output.empty? 
+        response_file = "responses/#{path.gsub('/','_').gsub(/^_/,'')}.#{Time.now.to_i}"
+        logger.info "Saving response to: #{response_file}"
+        File.open(response_file,'w') {|f| f.write(output)}
+      end
+
+      if output && !output.empty?
+        XmlSimple.xml_in(output, {'ForceArray' => nil})
+      else
+        raise "Empty response!"
+      end
     end
   end
 
   def post(path, params={}, param_remap=nil)
     rescue_and_retry_errors do
       param_string = make_param_string(params, param_remap)
-      output = RestClient.post File.join(@api_url, path), param_string, :accept => :response
+      output = @http_client.post File.join(@api_url, path), param_string, :accept => :response
       response = XmlSimple.xml_in(output, {'ForceArray' => nil})
     end
   end
@@ -618,6 +683,8 @@ class IBMSmartCloud
   def rescue_and_retry_errors(&block)
     block.call
   rescue timeouts_and_500s => e
+      logger.warn e.inspect
+
       is_500 = e.message =~ /500/
 
       @retries -= 1
@@ -687,7 +754,10 @@ class IBMSmartCloud
     array_or_object.is_a?(Array) ? array_or_object : [array_or_object]
   end
 
+  def time_format(time)
+    DateTime.parse(time).strftime("%Y-%m-%d %I:%M%p")
+  end
 end
 
 # predefine an instance for convenience
-@smartcloud = IBMSmartCloud.new(ENV['SMARTCLOUD_USERNAME'], ENV['SMARTCLOUD_PASSWORD']) if ENV['SMARTCLOUD_USERNAME'] && ENV['SMARTCLOUD_PASSWORD']
+@smartcloud = IBMSmartCloud.new if ENV['SMARTCLOUD_USERNAME'] && ENV['SMARTCLOUD_PASSWORD']