morpheus-cli 2.10.3 → 2.11.0

data/lib/morpheus/cli/mixins/accounts_helper.rb

@@ -243,7 +243,7 @@ module Morpheus::Cli::AccountsHelper
   def print_users_table(users, opts={})
     table_color = opts[:color] || cyan
     rows = users.collect do |user|
-      {id: user['id'], username: user['username'], first: user['firstName'], last: user['lastName'], email: user['email'], role: format_user_role_names(user), account: user['account'] ? user['account']['name'] : nil}
+      {id: user['id'], username: user['username'], name: user['displayName'], first: user['firstName'], last: user['lastName'], email: user['email'], role: format_user_role_names(user), account: user['account'] ? user['account']['name'] : nil}
     end
     print table_color
     tp rows, :id, :account, :first, :last, :username, :email, :role

data/lib/morpheus/cli/mixins/monitoring_helper.rb

@@ -0,0 +1,434 @@
+require 'morpheus/cli/mixins/print_helper'
+require 'morpheus/cli/option_types'
+require 'morpheus/rest_client'
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for the monitoring domain, incidents, checks, 'n such
+module Morpheus::Cli::MonitoringHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  def monitoring_interface
+    # @api_client.monitoring
+    raise "#{self.class} has not defined @monitoring_interface" if @monitoring_interface.nil?
+    @monitoring_interface
+  end
+
+  def find_check_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_check_by_id(val)
+    else
+      return find_check_by_name(val)
+    end
+  end
+
+  def find_check_by_id(id)
+    begin
+      json_response = monitoring_interface.checks.get(id.to_i)
+      return json_response['check']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Check not found by id #{id}"
+        exit 1
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_check_by_name(name)
+    json_results = monitoring_interface.checks.list({name: name})
+    if json_results['checks'].empty?
+      print_red_alert "Check not found by name #{name}"
+      exit 1
+    end
+    check = json_results['checks'][0]
+    return check
+  end
+
+  # def find_incident_by_name_or_id(val)
+  #   if val.to_s =~ /\A\d{1,}\Z/
+  #     return find_incident_by_id(val)
+  #   else
+  #     return find_incident_by_name(val)
+  #   end
+  # end
+
+  def find_incident_by_id(id)
+    begin
+      json_response = monitoring_interface.incidents.get(id.to_i)
+      return json_response['incident']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Incident not found by id #{id}"
+        exit 1
+      else
+        raise e
+      end
+    end
+  end
+
+  # def find_incident_by_name(name)
+  #   json_results = monitoring_interface.incidents.get({name: name})
+  #   if json_results['incidents'].empty?
+  #     print_red_alert "Incident not found by name #{name}"
+  #     exit 1
+  #     end
+  #   incident = json_results['incidents'][0]
+  #   return incident
+  # end
+
+
+  def get_available_check_types(refresh=false)
+    if !@available_check_types || refresh
+      # @available_check_types = [{name: 'A Fake Check Type', code: 'achecktype'}]
+      # todo: use options api instead probably...
+      @available_check_types = check_types_interface.list_check_types['checkTypes']
+    end
+    return @available_check_types
+  end
+
+  def check_type_for_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return check_type_for_id(val)
+    else
+      return check_type_for_name(val)
+    end
+  end
+  
+  def check_type_for_id(id)
+    return get_available_check_types().find { |z| z['id'].to_i == id.to_i}
+  end
+
+  def check_type_for_name(name)
+    return get_available_check_types().find { |z| z['name'].downcase == name.downcase || z['code'].downcase == name.downcase}
+  end
+
+  def format_severity(severity, return_color=cyan)
+    out = ""
+    status_string = severity
+    if status_string == 'critical'
+      out << "#{red}#{status_string.capitalize}#{return_color}"
+    elsif status_string == 'warning'
+      out << "#{yellow}#{status_string.capitalize}#{return_color}"
+    elsif status_string == 'info'
+      out << "#{cyan}#{status_string.capitalize}#{return_color}"
+    else
+      out << "#{cyan}#{status_string}#{return_color}"
+    end
+    out
+  end
+
+  def format_monitoring_issue_attachment_type(issue)
+    if issue["app"]
+      "App"
+    elsif issue["check"]
+      "Check"
+    elsif issue["checkGroup"]
+      "Group"
+    else
+      "Severity Change"
+    end
+  end
+
+  def format_monitoring_incident_status(incident)
+    status_string = incident['status']
+    if status_string == 'closed'
+      "closed ✓"
+    else
+      status_string
+    end
+  end
+
+  def format_monitoring_issue_status(issue)
+    format_monitoring_incident_status(issue)
+  end
+
+  
+
+  # Incidents
+
+  def print_incidents_table(incidents, opts={})
+    columns = [
+      {"ID" => lambda {|incident| incident['id'] } },
+      {"SEVERITY" => lambda {|incident| format_severity(incident['severity']) } },
+      {"NAME" => lambda {|incident| incident['name'] || 'No Subject' } },
+      {"TIME" => lambda {|incident| format_local_dt(incident['startDate']) } },
+      {"STATUS" => lambda {|incident| format_monitoring_incident_status(incident) } },
+      {"DURATION" => lambda {|incident| format_duration(incident['startDate'], incident['endDate']) } }
+    ]
+    if opts[:include_fields]
+      columns = opts[:include_fields]
+    end
+    print as_pretty_table(incidents, columns, opts)
+  end
+
+  def print_incident_history_table(history_items, opts={})
+    columns = [
+      # {"ID" => lambda {|issue| issue['id'] } },
+      {"SEVERITY" => lambda {|issue| format_severity(issue['severity']) } },
+      {"AVAILABLE" => lambda {|issue| format_boolean issue['available'] } },
+      {"TYPE" => lambda {|issue| issue["attachmentType"] } },
+      {"NAME" => lambda {|issue| issue['name'] } },
+      {"DATE CREATED" => lambda {|issue| format_local_dt(issue['startDate']) } }
+    ]
+    if opts[:include_fields]
+      columns = opts[:include_fields]
+    end
+    print as_pretty_table(history_items, columns, opts)
+  end
+
+  def print_incident_notifications_table(notifications, opts={})
+    columns = [
+      {"NAME" => lambda {|notification| notification['recipient'] ? notification['recipient']['name'] : '' } },
+      {"DELIVERY TYPE" => lambda {|notification| notification['addressTypes'].to_s } },
+      {"NOTIFIED ON" => lambda {|notification| format_local_dt(notification['dateCreated']) } },
+      # {"AVAILABLE" => lambda {|notification| format_boolean notification['available'] } },
+      # {"TYPE" => lambda {|notification| notification["attachmentType"] } },
+      # {"NAME" => lambda {|notification| notification['name'] } },
+      {"DATE CREATED" => lambda {|notification| 
+        date_str = format_local_dt(notification['startDate']).to_s
+        if notification['pendingUtil']
+          "(pending) #{date_str}"
+        else
+          date_str
+        end
+      } }
+    ]
+    #event['pendingUntil']
+    if opts[:include_fields]
+      columns = opts[:include_fields]
+    end
+    print as_pretty_table(notifications, columns, opts)
+  end
+
+
+  # Checks
+
+  def format_monitoring_check_status(check, return_color=cyan)
+    #<morph:statusIcon unknown="${!check.lastRunDate}" muted="${!check.createIncident}" failure="${check.lastCheckStatus == 'error'}" health="${check.health}" class="pull-left"/>
+    out = ""
+    muted = !check['createIncident']
+    status_string = check['lastCheckStatus'].to_s
+    failure = check['lastCheckStatus'] == 'error'
+    health = check['health'] # todo: examine at this too?
+    if failure
+      out << "#{red}#{status_string.capitalize}#{return_color}"
+    else
+      out << "#{cyan}#{status_string.capitalize}#{return_color}"
+    end
+    if muted
+      out << "(muted)"
+    end
+    out
+  end
+
+  def format_monitoring_check_last_metric(check)
+    #<td class="last-metric-col">${check.lastMetric} ${check.lastMetric ? checkTypes.find{ type -> type.id == check.checkTypeId}?.metricName : ''}</td>
+    out = ""
+    out << "#{check['lastMetric']} "
+    # todo:
+    out.strip
+  end
+
+  def format_monitoring_check_type(check)
+    #<td class="check-type-col"><div class="check-type-icon ${morph.checkTypeCode(id:check.checkTypeId, checkTypes:checkTypes)}"></div></td>
+    # return get_object_value(check, 'checkType.name') # this works too
+    out = ""
+    if check && check['checkType'] && check['checkType']['name']
+      out << check['checkType']['name']
+    elsif check['checkTypeId']
+      out << check['checkTypeId'].to_s
+    elsif !check.empty?
+      out << check.to_s
+    end
+    out.strip! + "WEEEEEE"
+  end
+
+  def print_checks_table(incidents, opts={})
+    columns = [
+      {"ID" => lambda {|check| check['id'] } },
+      {"STATUS" => lambda {|check| format_monitoring_check_status(check) } },
+      {"NAME" => lambda {|check| check['name'] } },
+      {"TIME" => lambda {|check| format_local_dt(check['lastRunDate']) } },
+      {"AVAILABILITY" => {display_method: lambda {|check| check['availability'] ? "#{check['availability'].to_f.round(3).to_s}%" : "N/A"} }, justify: "center" },
+      {"RESPONSE TIME" => {display_method: lambda {|check| check['lastTimer'] ? "#{check['lastTimer']}ms" : "N/A" } }, justify: "center" },
+      {"LAST METRIC" => {display_method: lambda {|check| check['lastMetric'] ? "#{check['lastMetric']}" : "N/A" } }, justify: "center" },
+      {"TYPE" => 'checkType.name'},
+      
+    ]
+    if opts[:include_fields]
+      columns = opts[:include_fields]
+    end
+    print as_pretty_table(incidents, columns, opts)
+  end
+
+  def print_check_history_table(history_items, opts={})
+    columns = [
+      # {"ID" => lambda {|issue| issue['id'] } },
+      {"SEVERITY" => lambda {|issue| format_severity(issue['severity']) } },
+      {"AVAILABLE" => lambda {|issue| format_boolean issue['available'] } },
+      {"TYPE" => lambda {|issue| issue["attachmentType"] } },
+      {"NAME" => lambda {|issue| issue['name'] } },
+      {"DATE CREATED" => lambda {|issue| format_local_dt(issue['startDate']) } }
+    ]
+    if opts[:include_fields]
+      columns = opts[:include_fields]
+    end
+    print as_pretty_table(history_items, columns, opts)
+  end
+
+  def print_check_notifications_table(notifications, opts={})
+    columns = [
+      {"NAME" => lambda {|notification| notification['recipient'] ? notification['recipient']['name'] : '' } },
+      {"DELIVERY TYPE" => lambda {|notification| notification['addressTypes'].to_s } },
+      {"NOTIFIED ON" => lambda {|notification| format_local_dt(notification['dateCreated']) } },
+      # {"AVAILABLE" => lambda {|notification| format_boolean notification['available'] } },
+      # {"TYPE" => lambda {|notification| notification["attachmentType"] } },
+      # {"NAME" => lambda {|notification| notification['name'] } },
+      {"DATE CREATED" => lambda {|notification| 
+        date_str = format_local_dt(notification['startDate']).to_s
+        if notification['pendingUtil']
+          "(pending) #{date_str}"
+        else
+          date_str
+        end
+      } }
+    ]
+    #event['pendingUntil']
+    if opts[:include_fields]
+      columns = opts[:include_fields]
+    end
+    print as_pretty_table(notifications, columns, opts)
+  end
+
+  # Monitoring Contacts
+
+  def find_contact_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_contact_by_id(val)
+    else
+      return find_contact_by_name(val)
+    end
+  end
+
+  def find_contact_by_id(id)
+    begin
+      json_response = monitoring_interface.contacts.get(id.to_i)
+      return json_response['contact']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Contact not found by id #{id}"
+        exit 1 # return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_contact_by_name(name)
+    json_results = monitoring_interface.contacts.list({name: name})
+    contacts = json_results["contacts"]
+    if contacts.empty?
+      print_red_alert "Contact not found by name #{name}"
+      exit 1 # return nil
+    elsif contacts.size > 1
+      print_red_alert "#{contacts.size} Contacts found by name #{name}"
+      print "\n"
+      puts as_pretty_table(contacts, [{"ID" => "id" }, {"NAME" => "name"}], {color: red})
+      print_red_alert "Try passing ID instead"
+      print reset,"\n"
+      exit 1 # return nil
+    else
+      return contacts[0]
+    end
+  end
+
+
+  # Monitoring Check Groups
+
+  def find_check_group_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_check_group_by_id(val)
+    else
+      return find_check_group_by_name(val)
+    end
+  end
+
+  def find_check_group_by_id(id)
+    begin
+      json_response = monitoring_interface.groups.get(id.to_i)
+      return json_response['checkGroup']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Check Group not found by id #{id}"
+        exit 1 # return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_check_group_by_name(name)
+    json_results = monitoring_interface.groups.list({name: name})
+    groups = json_results["groups"]
+    if groups.empty?
+      print_red_alert "Check Group not found by name #{name}"
+      exit 1 # return nil
+    elsif groups.size > 1
+      print_red_alert "#{groups.size} Check Groups found by name #{name}"
+      print "\n"
+      puts as_pretty_table(groups, [{"ID" => "id" }, {"NAME" => "name"}], {color: red})
+      print_red_alert "Try passing ID instead"
+      print reset,"\n"
+      exit 1 # return nil
+    else
+      return groups[0]
+    end
+  end
+
+  # Monitoring apps
+
+  def find_app_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_app_by_id(val)
+    else
+      return find_app_by_name(val)
+    end
+  end
+
+  def find_app_by_id(id)
+    begin
+      json_response = monitoring_interface.apps.get(id.to_i)
+      return json_response['app']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Monitor App not found by id #{id}"
+        exit 1 # return nil
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_app_by_name(name)
+    json_results = monitoring_interface.apps.list({name: name})
+    apps = json_results["apps"]
+    if apps.empty?
+      print_red_alert "Monitor App not found by name #{name}"
+      exit 1 # return nil
+    elsif apps.size > 1
+      print_red_alert "#{apps.size} apps found by name #{name}"
+      print "\n"
+      puts as_pretty_table(apps, [{"ID" => "id" }, {"NAME" => "name"}], {color: red})
+      print_red_alert "Try passing ID instead"
+      print reset,"\n"
+      exit 1 # return nil
+    else
+      return apps[0]
+    end
+  end
+
+
+end

data/lib/morpheus/cli/mixins/print_helper.rb

@@ -1,6 +1,9 @@
 require 'uri'
 require 'term/ansicolor'
 require 'json'
+require 'yaml'
+require 'ostruct'
+require 'io/console'
 
 module Morpheus::Cli::PrintHelper
 
@@ -8,122 +11,81 @@ module Morpheus::Cli::PrintHelper
     klass.send :include, Term::ANSIColor
   end
 
-  def print_red_alert(msg)
-    print "#{red}#{msg}#{reset}\n"
+  def self.terminal_width
+    @@terminal_width ||= 80
   end
 
-  def print_yellow_warning(msg)
-    print "#{yellow}#{msg}#{reset}\n"
+  def self.terminal_width=(v)
+    if v.nil? || v.to_i == 0
+      @@terminal_width = nil
+    else
+      @@terminal_width = v.to_i
+    end
+    @@terminal_width
   end
 
-  def print_green_success(msg)
-    print "#{green}#{msg}#{reset}\n"
+  def current_terminal_width
+    return IO.console.winsize[1] rescue 0
   end
 
-  def print_errors(response, options={})
-    begin
-      if options[:json]
-        print red
-        print JSON.pretty_generate(response)
-        print reset, "\n"
-      else
-        if !response['success']
-          print red,bold
-          if response['msg']
-            puts response['msg']
-          end
-          if response['errors']
-            response['errors'].each do |key, value|
-              print "* #{key}: #{value}\n"
-            end
-          end
-          print reset
-        else
-          # this should not really happen
-          print cyan,bold, "\nSuccess!"
-        end
-      end
-    ensure
-      print reset
-    end
+  # puts red message to stderr
+  def print_red_alert(msg)
+    #$stderr.print "#{red}#{msg}#{reset}\n"
+    print "#{red}#{msg}#{reset}\n"
+    #puts_error "#{red}#{msg}#{reset}"
   end
 
-  def print_rest_exception(e, options={})
-    if e.response
-      if options[:debug]
-        begin
-          print_rest_exception_request_and_response(e)
-        ensure
-          print reset
-        end
-        return
-      end
-      if e.response.code == 400
-        response = JSON.parse(e.response.to_s)
-        print_errors(response, options)
-      else
-        print_red_alert "Error Communicating with the Appliance. #{e}"
-        if options[:json] || options[:debug]
-          begin
-            response = JSON.parse(e.response.to_s)
-            print red
-            print JSON.pretty_generate(response)
-            print reset, "\n"
-          rescue TypeError, JSON::ParserError => ex
-            print_red_alert "Failed to parse JSON response: #{ex}"
-            print red
-            print response.to_s
-            print reset, "\n"
-          ensure
-            print reset
-          end
-        end
-      end
-    else
-      print_red_alert "Error Communicating with the Appliance. #{e}"
-    end
+  # puts green message to stdout
+  def print_green_success(msg)
+    print "#{green}#{msg}#{reset}\n"
   end
 
-  def print_rest_request(req)
-    # JD: IOError when accessing payload... we should probably just be printing at the time the request is made..
-    #out = []
-    #out << "#{req.method} #{req.url.inspect}"
-    #out << req.payload.short_inspect if req.payload
-    # payload = req.instance_variable_get("@payload")
-    # out << payload if payload
-    #out << req.processed_headers.to_a.sort.map { |(k, v)| [k.inspect, v.inspect].join("=>") }.join(", ")
-    #print out.join(', ') + "\n"
-    print "Request:"
-    print "\n"
-    print "#{req.method.to_s.upcase} #{req.url.inspect}"
-    print "\n"
+  # print_h1 prints a header title and optional subtitles
+  # Output:
+  #
+  # title - subtitle1, subtitle2
+  # ==================
+  #
+  def print_h1(title, subtitles=[], color=cyan)
+    #print "\n" ,color, bold, title, (subtitles.empty? ? "" : " - #{subtitles.join(', ')}"), "\n", "==================", reset, "\n\n"
+    subtitles = subtitles.flatten
+    out = ""
+    out << "\n"
+    out << "#{color}#{bold}#{title}#{reset}"
+    if !subtitles.empty?
+      out << "#{color} - #{subtitles.join(', ')}#{reset}"
+    end
+    out << "\n"
+    out << "#{color}#{bold}==================#{reset}"
+    out << "\n\n"
+    out << reset
+    print out
   end
 
-  def print_rest_response(res)
-    # size = @raw_response ? File.size(@tf.path) : (res.body.nil? ? 0 : res.body.size)
-    size = (res.body.nil? ? 0 : res.body.size)
-    print "Response:"
-    print "\n"
-    display_size = Filesize.from("#{size} B").pretty rescue size
-    print "HTTP #{res.net_http_res.code} - #{res.net_http_res.message} | #{(res['Content-type'] || '').gsub(/;.*$/, '')} #{display_size}"
-    print "\n"
-    begin
-      print JSON.pretty_generate(JSON.parse(res.body))
-    rescue
-      print res.body.to_s
+  def print_h2(title, subtitles=[], color=cyan)
+    #print "\n" ,color, bold, title, (subtitles.empty? ? "" : " - #{subtitles.join(', ')}"), "\n", "---------------------", reset, "\n\n"
+    subtitles = subtitles.flatten
+    out = ""
+    out << "\n"
+    out << "#{color}#{bold}#{title}#{reset}"
+    if !subtitles.empty?
+      out << "#{color} - #{subtitles.join(', ')}#{reset}"
     end
-    print "\n"
+    out << "\n"
+    out << "#{color}---------------------#{reset}"
+    out << "\n\n"
+    out << reset
+    print out
   end
 
-  def print_rest_exception_request_and_response(e)
-    print_red_alert "Error Communicating with the Appliance. (#{e.response.code}) #{e}"
-    response = e.response
-    request = response.instance_variable_get("@request")
-    print red
-    print_rest_request(request)
-    print "\n"
-    print_rest_response(response)
-    print reset
+  # @deprecated, use ErrorHandler.print_rest_exception()
+  def print_rest_exception(e, options={})
+    # ugh, time to clean this stuff up
+    if respond_to?(:my_terminal)
+      Morpheus::Cli::ErrorHandler.new(my_terminal.stderr).print_rest_exception(e, options)
+    else
+      Morpheus::Cli::ErrorHandler.new.print_rest_exception(e, options)
+    end
   end
 
   def print_dry_run(opts)
@@ -137,7 +99,7 @@ module Morpheus::Cli::PrintHelper
     end
     request_string = "#{http_method.to_s.upcase} #{url}".strip
     payload = opts[:payload]
-    print "\n" ,cyan, bold, "DRY RUN\n","==================", "\n\n", reset
+    print_h1 "DRY RUN"
     print cyan
     print "Request: ", "\n"
     print reset
@@ -160,10 +122,61 @@ module Morpheus::Cli::PrintHelper
     print reset
   end
 
-  def print_results_pagination(json_response)
-    if json_response && json_response["meta"]
-      print cyan,"\nViewing #{json_response['meta']['offset'].to_i + 1}-#{json_response['meta']['offset'].to_i + json_response['meta']['size'].to_i} of #{json_response['meta']['total']}\n", reset
+  def print_results_pagination(json_response, options={})
+    # print cyan,"\nViewing #{json_response['meta']['offset'].to_i + 1}-#{json_response['meta']['offset'].to_i + json_response['meta']['size'].to_i} of #{json_response['meta']['total']}\n", reset
+    print format_results_pagination(json_response, options)
+  end
+
+  def format_results_pagination(json_response, options={})
+    # no output for strange, empty data
+    if json_response.nil? || json_response.empty?
+      return ""
+    end
+    
+    # options = OpenStruct.new(options) # laff, let's do this instead
+    color = options.key?(:color) ? options[:color] : cyan
+    label = options[:label]
+    n_label = options[:n_label]
+    # label = n_label if !label && n_label
+    message = options[:message] || "Viewing %{start_index}-%{end_index} of %{total} %{label}"
+    blank_message = options[:blank_message] || nil # "No %{label} found"
+
+    # support lazy passing of common json_response {"meta": {"size": {25}, "total": 56} }
+    # otherwise use the root values given
+    meta = OpenStruct.new(json_response)
+    if meta.meta
+      meta = OpenStruct.new(meta.meta)
+    end
+    offset, size, total = meta.offset.to_i, meta.size.to_i, meta.total.to_i
+    #objects = meta.objects || options[:objects_key] ? json_response[options[:objects_key]] : nil
+    #objects ||= meta.instances || meta.servers || meta.users || meta.roles
+    #size = objects.size if objects && size == 0
+    if total == 0
+      total = size
+    end
+    if total != 1
+      label = n_label || label
     end
+    out_str = ""
+    string_key_values = {start_index: offset + 1, end_index: offset + size, total: total, size: size, offset: offset, label: label}
+    if size > 0
+      if message
+        out_str << message % string_key_values
+      end
+    else
+      if blank_message
+        out_str << blank_message % string_key_values
+      else
+        #out << "No records"
+      end
+    end
+    out = ""
+    out << "\n"
+    out << color if color
+    out << out_str.strip
+    out << reset if color
+    out << "\n"
+    out
   end
 
   def required_blue_prompt
@@ -184,7 +197,7 @@ module Morpheus::Cli::PrintHelper
     else
       percent = ((used_value.to_f / max_value.to_f) * 100)
     end
-    percent_label = (used_value.nil? || max_value.to_f == 0.0) ? "n/a" : "#{percent.round(2)}%".rjust(6, ' ')
+    percent_label = ((used_value.nil? || max_value.to_f == 0.0) ? "n/a" : "#{percent.round(2)}%").rjust(6, ' ')
     bar_display = ""
     if percent > 100
       max_bars.times { bars << "|" }
@@ -235,17 +248,25 @@ module Morpheus::Cli::PrintHelper
   end
 
   def print_stats_usage(stats, opts={})
+    label_width = opts[:label_width] || 10
+    out = ""
+    if stats.nil? || stats.empty?
+      out << cyan + "No data." +  "\n" + reset
+      print out
+      return
+    end
     opts[:include] ||= [:memory, :storage, :cpu]
+    if opts[:include].include?(:cpu)
+      cpu_usage = (stats['usedCpu'] || stats['cpuUsage'])
+      out << cyan + "CPU".rjust(label_width, ' ') + ": " + generate_usage_bar(cpu_usage.to_f, 100)  + "\n"
+    end
     if opts[:include].include?(:memory)
-      print cyan, "Memory:".ljust(10, ' ')  + generate_usage_bar(stats['usedMemory'], stats['maxMemory']) + cyan + Filesize.from("#{stats['usedMemory']} B").pretty.strip.rjust(15, ' ')           + " / " + Filesize.from("#{stats['maxMemory']} B").pretty.strip.ljust(15, ' ')  + "\n"
+      out << cyan + "Memory".rjust(label_width, ' ') + ": " + generate_usage_bar(stats['usedMemory'], stats['maxMemory']) + cyan + Filesize.from("#{stats['usedMemory']} B").pretty.strip.rjust(15, ' ')           + " / " + Filesize.from("#{stats['maxMemory']} B").pretty.strip.ljust(15, ' ')  + "\n"
     end
     if opts[:include].include?(:storage)
-      print cyan, "Storage:".ljust(10, ' ') + generate_usage_bar(stats['usedStorage'], stats['maxStorage']) + cyan + Filesize.from("#{stats['usedStorage']} B").pretty.strip.rjust(15, ' ') + " / " + Filesize.from("#{stats['maxStorage']} B").pretty.strip.ljust(15, ' ') + "\n"
-    end
-    if opts[:include].include?(:cpu)
-      cpu_usage = (stats['usedCpu'] || stats['cpuUsage'])
-      print cyan, "CPU:".ljust(10, ' ')  + generate_usage_bar(cpu_usage.to_f, 100)  + "\n"
+      out << cyan + "Storage".rjust(label_width, ' ') + ": " + generate_usage_bar(stats['usedStorage'], stats['maxStorage']) + cyan + Filesize.from("#{stats['usedStorage']} B").pretty.strip.rjust(15, ' ') + " / " + Filesize.from("#{stats['maxStorage']} B").pretty.strip.ljust(15, ' ') + "\n"
     end
+    print out
   end
 
   def print_available_options(option_types)
@@ -253,4 +274,491 @@ module Morpheus::Cli::PrintHelper
     puts "Available Options:\n#{option_lines}\n\n"
   end
 
+  def format_dt_dd(label, value, label_width=10, justify="right", do_wrap=true)
+    # JD: uncomment next line to do away with justified labels
+    # label_width, justify = 0, "none"
+    out = ""
+    value = value.to_s
+    if do_wrap && value && Morpheus::Cli::PrintHelper.terminal_width
+      value_width = Morpheus::Cli::PrintHelper.terminal_width - label_width
+      if value_width > 0 && value.to_s.size > value_width
+        wrap_indent = label_width + 1 # plus 1 needs to go away
+        value = wrap(value, value_width, wrap_indent)
+      end
+    end
+    if justify == "right"
+      out << "#{label}:".rjust(label_width, ' ') + " #{value}" 
+    elsif justify == "left"
+      out << "#{label}:".ljust(label_width, ' ') + " #{value}" 
+    else
+      # default is none
+      out << "#{label}:" + " #{value}" 
+    end
+    out
+  end
+
+  # truncate_string truncates a string and appends the suffix "..."
+  # @param value [String] the string to pad
+  # @param width [Integer] the length to truncate to
+  # @param pad_char [String] the character to pad with. Default is ' '
+  def truncate_string(value, width, suffix="...")
+    value = value.to_s
+    # JD: hack alerty.. this sux, but it's a best effort to preserve values containing ascii coloring codes
+    #     it stops working when there are words separated by ascii codes, eg. two diff colors
+    #     plus this is probably pretty slow...
+    uncolored_value = Term::ANSIColor.coloring? ? Term::ANSIColor.uncolored(value.to_s) : value.to_s
+    if uncolored_value != value
+      trimmed_value = nil
+      if uncolored_value.size > width
+        if suffix
+          trimmed_value = uncolored_value[0..width-(suffix.size+1)] + suffix
+        else
+          trimmed_value = uncolored_value[0..width-1]
+        end
+        return value.gsub(uncolored_value, trimmed_value)
+      else
+        return value
+      end
+    else
+      if value.size > width
+        if suffix
+          return value[0..width-(suffix.size+1)] + suffix
+        else
+          return value[0..width-1]
+        end
+      else
+        return value
+      end
+    end
+  end
+
+  # justified returns a left, center, or right aligned string. 
+  # @param value [String] the string to pad
+  # @param width [Integer] the length to truncate to
+  # @param pad_char [String] the character to pad with. Default is ' '
+  # @return [String]
+  def justify_string(value, width, justify="left", pad_char=" ")
+    # JD: hack alert! this sux, but it's a best effort to preserve values containing ascii coloring codes
+    value = value.to_s
+    uncolored_value = Term::ANSIColor.coloring? ? Term::ANSIColor.uncolored(value.to_s) : value.to_s
+    if value.size != uncolored_value.size
+      width = width + (value.size - uncolored_value.size)
+    end
+    if justify == "right"
+      return "#{value}".rjust(width, pad_char)
+    elsif justify == "center"
+      return "#{value}".center(width, pad_char)
+    else
+      return "#{value}".ljust(width, pad_char)
+    end
+  end
+
+  def format_table_cell(value, width, justify="left", pad_char=" ", suffix="...")
+    #puts "format_table_cell(#{value}, #{width}, #{justify}, #{pad_char.inspect})"
+    cell = value.to_s
+    cell = truncate_string(cell, width, suffix)
+    cell = justify_string(cell, width, justify, pad_char)
+    cell
+  end
+
+  # as_pretty_table generates a table with aligned columns and truncated values.
+  # This can be used in place of TablePrint.tp()
+  # @param data [Array] A list of objects to extract the data from.
+  # @param columns - [Array of Objects] list of column definitions, A column definition can be a String, Symbol, or Hash
+  # @return [String]
+  # Usage: puts as_pretty_table(my_objects, [:id, :name])
+  #        puts as_pretty_table(my_objects, ["id", "name", {"plan" => "plan.name" }], {color: white})
+  #
+  def as_pretty_table(data, columns, options={})
+    data = [data].flatten
+    columns = build_column_definitions(columns)
+
+    table_color = options[:color] || cyan
+    cell_delim = options[:delim] || " | "
+
+    header_row = []
+    
+    columns.each do |column_def|
+      header_row << column_def.label
+    end
+
+    # generate rows matrix data for the specified columns
+    rows = []
+    data.each do |row_data|
+      row = []
+      columns.each do |column_def|
+        # r << column_def.display_method.respond_to?(:call) ? column_def.display_method.call(row_data) : get_object_value(row_data, column_def.display_method)
+        value = column_def.display_method.call(row_data)        
+        row << value
+      end
+      rows << row
+    end
+
+    # all rows (pre-formatted)
+    data_matrix = [header_row] + rows
+  
+    # determine column meta info i.e. width    
+    columns.each_with_index do |column_def, column_index|
+      # column_def.meta = {
+      #   max_value_size: (header_row + rows).max {|row| row[column_index] ? row[column_index].to_s.size : 0 }.size
+      # }
+      if column_def.fixed_width
+        column_def.width = column_def.fixed_width.to_i
+      else
+        max_value_size = 0
+        data_matrix.each do |row|
+          v = row[column_index].to_s
+          v_size = Term::ANSIColor.coloring? ? Term::ANSIColor.uncolored(v).size : v.size
+          if v_size > max_value_size
+            max_value_size = v_size
+          end
+        end
+
+        max_width = (column_def.max_width.to_i > 0) ? column_def.max_width.to_i : nil
+        min_width = (column_def.min_width.to_i > 0) ? column_def.min_width.to_i : nil
+        if min_width && max_value_size < min_width
+          column_def.width = min_width
+        elsif max_width && max_value_size > max_width
+          column_def.width = max_width
+        else
+          # expand / contract to size of the value by default
+          column_def.width = max_value_size
+        end
+        #puts "DEBUG: #{column_index} column_def.width:  #{column_def.width}"
+      end
+    end
+
+    # format header row
+    header_cells = []
+    columns.each_with_index do |column_def, column_index|
+      value = header_row[column_index] # column_def.label
+      header_cells << format_table_cell(value, column_def.width, column_def.justify)
+    end
+    
+    # format header spacer row
+    h_line = header_cells.collect {|cell| ("-" * cell.size) }.join(cell_delim.gsub(" ", "-"))
+    
+    # format data rows
+    formatted_rows = []
+    rows.each_with_index do |row, row_index|
+      formatted_row = []
+      row.each_with_index do |value, column_index|
+        column_def = columns[column_index]
+        formatted_row << format_table_cell(value, column_def.width, column_def.justify)
+      end
+      formatted_rows << formatted_row
+    end
+    
+    
+
+    table_str = ""
+    table_str << header_cells.join(cell_delim) + "\n"
+    table_str << h_line + "\n"
+    formatted_rows.each do |row|
+      table_str << row.join(cell_delim) + "\n"
+    end
+
+    out = ""
+    out << table_color if table_color
+    out << table_str
+    out << reset if table_color
+    out
+  end
+
+
+  # as_description_list() prints a a two column table containing
+  # the name and value of a list of descriptions
+  # @param columns - [Hash or Array or Hashes] list of column definitions, A column defintion can be a String, Symbol, Hash or Proc
+  # @param obj [Object] an object to extract the data from, it is treated like a Hash.
+  # @param opts [Map] rendering options for label :justify, :wrap
+  # Usage: 
+  # print_description_list([:id, :name, :status], my_instance, {})
+  #
+  def as_description_list(obj, columns, opts={})
+    
+    columns = build_column_definitions(columns)
+    
+    #label_width = opts[:label_width] || 10
+    max_label_width = 0
+    justify = opts.key?(:justify) ? opts[:justify] : "right"
+    do_wrap = opts.key?(:wrap) ? !!opts[:wrap] : true
+    
+    rows = []
+    
+    columns.flatten.each do |column_def|
+      label = column_def.label
+      # value = get_object_value(obj, column_def.display_method)
+      value = column_def.display_method.call(obj)
+      if label.size > max_label_width
+        max_label_width = label.size
+      end
+      rows << {label: label, value: value}
+    end
+    label_width = max_label_width + 1 # for a leading space ' ' ..ew
+    value_width = nil
+    if Morpheus::Cli::PrintHelper.terminal_width
+      value_width = Morpheus::Cli::PrintHelper.terminal_width - label_width
+    end
+
+    out = ""
+    rows.each do |row|
+      value = row[:value].to_s
+      if do_wrap
+        if value_width && value_width < value.size
+          wrap_indent = label_width + 1
+          value = wrap(value, value_width, wrap_indent)
+        end
+      end
+      out << format_dt_dd(row[:label], value, label_width, justify) + "\n"
+    end
+    return out
+  end
+
+  # print_description_list() is an alias for `print generate_description_list()`
+  def print_description_list(columns, obj, opts={})
+    # raise "oh no.. replace with as_description_list()"
+    print as_description_list(obj, columns, opts)
+  end
+
+  # build_column_definitions constructs an Array of column definitions (OpenStruct)
+  # Each column is defined by a label (String), and a display_method (Proc)
+  #
+  # @columns [Array] list of definitions. A column definition can be a String, Symbol, Proc or Hash
+  # @return [Array of OpenStruct] list of column definitions (OpenStruct) like:
+  #      [{label: "ID", display_method: 'id'}, {label: "Name", display_method: Proc}]
+  # Usage:
+  #   build_column_definitions(:id, :name)
+  #   build_column_definitions({"Object Id" => 'id'}, :name)
+  #   build_column_definitions({"ID" => 'id'}, "name", "plan.name", {status: lambda {|data| data['status'].upcase } })
+  #
+  def build_column_definitions(*columns)
+    # allow passing a single hash instead of an array of hashes
+    if columns.size == 1 && columns[0].is_a?(Hash)
+      columns = columns[0].collect {|k,v| {(k) => v} }
+    else
+      columns = columns.flatten.compact
+    end
+    results = []
+    columns.each do |col|
+      # determine label
+      if col.is_a?(String)
+        k = col
+        v = col
+        build_column_definitions([{(k) => v}]).each do |r|
+          results << r if r
+        end
+      elsif col.is_a?(Symbol)
+        k = col.to_s.upcase #.capitalize
+        v = col.to_s
+        build_column_definitions([{(k) => v}]).each do |r|
+          results << r if r
+        end
+      elsif col.is_a?(Hash)
+        column_def = OpenStruct.new
+        k, v = col.keys[0], col.values[0]
+        if k.is_a?(String)
+          column_def.label = k
+        elsif k.is_a?(Symbol)
+          column_def.label = k
+        else
+          column_def.label = k.to_s
+          # raise "invalid column definition label (#{k.class}) #{k.inspect}. Should be a String or Symbol."
+        end
+
+        # determine display_method
+        if v.is_a?(String)
+          column_def.display_method = lambda {|data| get_object_value(data, v) }
+        elsif v.is_a?(Symbol)
+          column_def.display_method = lambda {|data| get_object_value(data, v) }
+        elsif v.is_a?(Proc)
+          column_def.display_method = v
+        elsif v.is_a?(Hash) || v.is_a?(OStruct)
+          if v[:display_name] || v[:label]
+            column_def.label = v[:display_name] || v[:label]
+          end
+          if v[:display_method]
+            if v[:display_method].is_a?(Proc)
+              column_def.display_method = v[:display_method]
+            else
+              # assume v[:display_method] is a String, Symbol
+              column_def.display_method = lambda {|data| get_object_value(data, v[:display_method]) }
+            end
+          else
+            # the default behavior is to use the key (undoctored) to find the data
+            # column_def.display_method = k
+            column_def.display_method = lambda {|data| get_object_value(data, k) }
+          end
+          
+          # other column rendering options
+          column_def.justify = v[:justify]
+          if v[:max_width]
+            column_def.max_width = v[:max_width]
+          end
+          if v[:min_width]
+            column_def.min_width = v[:min_width]
+          end
+          # tp uses width to behave like max_width
+          if v[:width]
+            column_def.width = v[:width]
+            column_def.max_width = v[:width]
+          end
+          column_def.wrap = v[:wrap].nil? ? true :  v[:wrap] # only utlized in as_description_list() right now
+          
+        else
+          raise "invalid column definition value (#{v.class}) #{v.inspect}. Should be a String, Symbol, Proc or Hash"
+        end        
+
+        # only upcase label for symbols, this is silly anyway, 
+        # just pass the exact label (key) that you want printed..
+        if column_def.label.is_a?(Symbol)
+          column_def.label = column_def.label.to_s.upcase
+        end
+
+        results << column_def        
+
+      else
+        raise "invalid column definition (#{column_def.class}) #{column_def.inspect}. Should be a String, Symbol or Hash"
+      end
+      
+    end
+
+    return results
+  end
+
+  def wrap(s, width, indent=0)
+    out = s
+    if s.size > width
+      if indent > 0
+        out = s.gsub(/(.{1,#{width}})(\s+|\Z)/, "#{' ' * indent}\\1\n").strip
+      else
+        out = s.gsub(/(.{1,#{width}})(\s+|\Z)/, "\\1\n")
+      end
+    else
+      return s
+    end
+  end
+
+  def format_boolean(v)
+    !!v ? 'Yes' : 'No'
+  end
+
+  def quote_csv_value(v)
+    '"' + v.to_s.gsub('"', '""') + '"'
+  end
+
+  def as_csv(data, columns, opts={})
+    out = ""
+    delim = opts[:csv_delim] || opts[:delim] || ","
+    newline = opts[:csv_newline] || opts[:newline] || "\n"
+    include_header = opts[:csv_no_header] ? false : true
+    do_quotes = opts[:csv_quotes] || opts[:quotes]
+    # allow passing a single hash instead of an array of hashes
+    # todo: stop doing this, always pass an array!
+    if columns.is_a?(Hash)
+      columns = columns.collect {|k,v| {(k) => v} }
+    end
+    columns = columns.flatten.compact
+    data_array = [data].flatten.compact
+    if include_header
+      headers = columns.collect {|column_def| column_def.is_a?(Hash) ? column_def.keys[0].to_s : column_def.to_s }
+      if do_quotes
+        headers = headers.collect {|it| quote_csv_value(it) }
+      end
+      out << headers.join(delim)
+      out << newline
+    end
+    lines = []
+    data_array.each do |obj|
+      if obj
+        cells = []
+        columns.each do |column_def|
+          value = get_object_value(obj, column_def)
+          if do_quotes
+            cells << quote_csv_value(value)
+          else
+            cells << value.to_s
+          end
+        end
+      end
+      line = cells.join(delim)
+      lines << line
+    end
+    out << lines.join(newline)
+    #out << delim
+    out
+  end
+
+  def records_as_csv(records, opts={}, default_columns=nil)
+    out = ""
+    if !records
+      #raise "records_as_csv expects records as an Array of objects to render"
+      return out
+    end
+    cols = []
+    all_fields = records.first ? records.first.keys : []
+    if opts[:include_fields]
+      if opts[:include_fields] == 'all' || opts[:include_fields].include?('all')
+        cols = all_fields
+      else
+        cols = opts[:include_fields]
+      end
+    elsif default_columns
+      cols = default_columns
+    else
+      cols = all_fields
+    end
+    out << as_csv(records, cols, opts)
+    out
+  end
+
+  def as_json(data, options={})
+    out = ""
+    if !data
+      return "null" # "No data"
+    end
+    
+    # include_fields = options[:include_fields]
+    # if include_fields
+    #   json_fields_for = options[:json_fields_for] || options[:fields_for] || options[:root_field]
+    #   if json_fields_for && data[json_fields_for]
+    #     data[json_fields_for] = filtered_data(data[json_fields_for], include_fields)
+    #   else
+    #     data = filtered_data(data, include_fields)
+    #   end
+    # end
+    do_pretty = options.key?(:pretty_json) ? options[:pretty_json] : true
+    if do_pretty
+      out << JSON.pretty_generate(data)
+    else
+      out << JSON.fast_generate(data)
+    end
+    #out << "\n"
+    out
+  end
+
+  def anded_list(items)
+    items = items ? items.clone : []
+    last_item = items.pop
+    if items.empty?
+      return "#{last_item}"
+    else
+      return items.join(", ") + " and #{last_item}"
+    end
+  end
+
+  def as_yaml(data, options={})
+    out = ""
+    if !data
+      return "null" # "No data"
+    end
+    begin
+      out << data.to_yaml
+    rescue => err
+      puts "failed to render YAML from data: #{data.inspect}"
+      puts err.message
+    end
+    #out << "\n"
+    out
+  end
+
 end