morpheus-cli 5.5.0 → 5.5.1.2

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

@@ -0,0 +1,173 @@
+require 'morpheus/cli/mixins/print_helper'
+# Mixin for Morpheus::Cli command classes
+# Provides refreshing job execution records by id
+module Morpheus::Cli::JobsHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+    # klass.send :include, Morpheus::Cli::ProcessesHelper
+  end
+
+  def api_client
+    raise "#{self.class} has not defined @api_client" if @api_client.nil?
+    @api_client
+  end
+
+  def jobs_interface
+    # get_interface('jobs')
+    api_client.jobs
+  end
+
+  def get_process_event_data(process_or_event)
+    {
+        id: process_or_event['id'],
+        description: process_or_event['description'] || (process_or_event['refType'] == 'instance' ? process_or_event['displayName'] : (process_or_event['processTypeName'] || '').capitalize),
+        start_date: format_local_dt(process_or_event['startDate']),
+        created_by: process_or_event['createdBy'] ? process_or_event['createdBy']['displayName'] : '',
+        duration: format_human_duration((process_or_event['duration'] || process_or_event['statusEta'] || 0) / 1000.0),
+        status: format_job_status(process_or_event['status']),
+        error: process_or_event['message'] || process_or_event['error'],
+        output: process_or_event['output'],
+    }
+  end
+
+  # both process and process events
+  def print_process_events(events, options={})
+    # event_columns = [:id, :description, :start_date, :created_by, :duration, :status, :error, :output]
+    event_columns = {
+          "ID" => lambda {|it| it[:id]},
+          "Description" => lambda {|it| it[:description]},
+          "Start Date" => lambda {|it| it[:start_date]},
+          "Created By" => lambda {|it| it[:created_by]},
+          "Duration" => lambda {|it| it[:duration]},
+          "Status" => lambda {|it| it[:status]},
+          "Error" => lambda {|it| options[:details] ? it[:error] : truncate_string(it[:error], 32) },
+          "Output" => lambda {|it| options[:details] ? it[:output] : truncate_string(it[:output], 32) }
+      }
+    print as_pretty_table(events.collect {|it| get_process_event_data(it)}, event_columns.upcase_keys!, options)
+  end
+
+  def print_job_execution(job_execution, options)
+    process = job_execution['process']
+    print cyan
+    description_cols = {
+        "ID" => lambda {|it| it['id'] },
+        "Job" => lambda {|it| it['job'] ? it['job']['name'] : ''},
+        "Job Type" => lambda {|it| it['job'] && it['job']['type'] ? (it['job']['type']['code'] == 'morpheus.workflow' ? 'Workflow' : 'Task') : ''},
+        # "Description" => lambda {|it| it['description'] || (it['job'] ? it['job']['description'] : '') },
+        "Start Date" => lambda {|it| format_local_dt(it['startDate'])},
+        "ETA/Time" => lambda {|it| it['duration'] ? format_human_duration(it['duration'] / 1000.0) : ''},
+        "Status" => lambda {|it| format_job_status(it['status'])},
+        #"Output" => lambda {|it| it['process'] && (it['process']['output']) ?(it['process']['output']).to_s.strip : ''},
+        #"Error" => lambda {|it| it['process'] && (it['process']['message'] || it['process']['error']) ? red + (it['process']['message'] || it['process']['error']).to_s.strip + cyan : ''},
+        "Created By" => lambda {|it| it['createdBy'].nil? ? '' : it['createdBy']['displayName'] || it['createdBy']['username']}
+    }
+    print_description_list(description_cols, job_execution, options)
+
+    if process
+      process_data = get_process_event_data(process)
+      print_h2 "Process Details"
+      process_description_cols = {
+          "Process ID" => lambda {|it| it[:id]},
+          "Description" => lambda {|it| it[:description]},
+          "Start Date" => lambda {|it| it[:start_date]},
+          "Created By" => lambda {|it| it[:created_by]},
+          "Duration" => lambda {|it| it[:duration]},
+          "Status" => lambda {|it| it[:status]}
+      }
+      print_description_list(process_description_cols, process_data, options)
+
+      if process_data[:output] && process_data[:output].strip.length > 0
+        print_h2 "Output"
+        print process['output']
+      end
+      if process_data[:error] && process_data[:error].strip.length > 0
+        print_h2 "Error"
+        print process['message'] || process['error']
+        print reset,"\n"
+      end
+      
+
+      if process['events'] && !process['events'].empty?
+        print_h2 "Process Events", options
+        print_process_events(process['events'], options)
+      end
+    else
+      print reset,"\n"
+    end
+    return 0, nil
+  end
+
+  def print_job_executions(execs, options={})
+    if execs.empty?
+      print cyan,"No job executions found.",reset,"\n"
+    else
+      rows = execs.collect do |ex|
+        {
+            id: ex['id'],
+            job: ex['job'] ? ex['job']['name'] : '',
+            description: ex['description'] || ex['job'] ? ex['job']['description'] : '',
+            type: ex['job'] && ex['job']['type'] ? (ex['job']['type']['code'] == 'morpheus.workflow' ? 'Workflow' : 'Task') : '',
+            start: format_local_dt(ex['startDate']),
+            duration: ex['duration'] ? format_human_duration(ex['duration'] / 1000.0) : '',
+            status: format_job_status(ex['status']),
+            error: truncate_string(ex['process'] && (ex['process']['message'] || ex['process']['error']) ? ex['process']['message'] || ex['process']['error'] : '', options[:details] ? nil : 32),
+            output: truncate_string(ex['process'] && ex['process']['output'] ? ex['process']['output'] : '', options[:details] ? nil : 32),
+        }
+      end
+
+      columns = [
+          :id, :job, :type, {'START DATE' => :start}, {'ETA/TIME' => :duration}, :status, :error, :output
+      ]
+      print as_pretty_table(rows, columns, options)
+    end
+  end
+
+  def format_job_status(status_string, return_color=cyan)
+    out = ""
+    if status_string
+      if ['complete','success', 'successful', 'ok'].include?(status_string)
+        out << "#{green}#{status_string.upcase}"
+      elsif ['error', 'offline', 'failed', 'failure'].include?(status_string)
+        out << "#{red}#{status_string.upcase}"
+      else
+        out << "#{yellow}#{status_string.upcase}"
+      end
+    end
+    out + return_color
+  end
+
+  # this is built into CliCommand now...
+  # def find_by_name_or_id(type, val)
+  #   interface = instance_variable_get "@#{type}s_interface"
+  #   typeCamelCase = type.gsub(/(?:^|_)([a-z])/) do $1.upcase end
+  #   typeCamelCase = typeCamelCase[0, 1].downcase + typeCamelCase[1..-1]
+  #   (val.to_s =~ /\A\d{1,}\Z/) ? interface.get(val.to_i)[typeCamelCase] : interface.list({'name' => val})["#{typeCamelCase}s"].first
+  # end
+
+  # refresh execution request until it is finished
+  # returns json response data of the last execution request when status reached 'completed' or 'failed'
+  def wait_for_job_execution(job_execution_id, options={}, print_output = true)
+    refresh_interval = 10
+    if options[:refresh_interval].to_i > 0
+      refresh_interval = options[:refresh_interval]
+    end
+    refresh_display_seconds = refresh_interval % 1.0 == 0 ? refresh_interval.to_i : refresh_interval
+    unless options[:quiet]
+      print cyan, "Refreshing every #{refresh_display_seconds} seconds until execution is complete...", "\n", reset
+    end
+    job_execution = jobs_interface.get_execution(job_execution_id)['jobExecution']
+    while ['new','queued','pending','running'].include?(job_execution['status']) do
+      sleep(refresh_interval)
+      job_execution = jobs_interface.get_execution(job_execution_id)['jobExecution']
+    end
+    if print_output && options[:quiet] != true
+      print_h1 "Morpheus Job Execution", [], options
+      print_job_execution(job_execution, options)
+    end
+    return job_execution
+  end
+
+
+
+end

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

@@ -608,6 +608,9 @@ module Morpheus::Cli::PrintHelper
   # @param suffix [String] the character to pad right side with. Default is '...'
   def truncate_string(value, width, suffix="...")
     value = value.to_s
+    if !width
+      return value
+    end
     # 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...
@@ -714,7 +717,11 @@ module Morpheus::Cli::PrintHelper
     
     # support --fields x,y,z and --all-fields or --fields all
     all_fields = data.first ? data.first.keys : []
-    
+    #todo: support --raw-fields   meh, not really needed..
+    # if options[:include_fields] && options[:raw_fields]
+    #   data = transform_data_for_field_options(data, options)
+    #   data = data[options[:include_fields_context]] if options[:include_fields_context]
+    # elsif options[:include_fields]
     if options[:include_fields]
       if (options[:include_fields].is_a?(Array) && options[:include_fields].size == 1 && options[:include_fields][0] == 'all') || options[:include_fields] == 'all'
         columns = all_fields
@@ -1093,16 +1100,78 @@ module Morpheus::Cli::PrintHelper
     '"' + v.to_s.gsub('"', '""') + '"'
   end
 
-  def as_csv(data, columns, options={})
+  def as_csv(data, default_columns=nil, options={}, object_key=nil)
     out = ""
     delim = options[:csv_delim] || options[:delim] || ","
     newline = options[:csv_newline] || options[:newline] || "\n"
     include_header = options[:csv_no_header] ? false : true
     do_quotes = options[:csv_quotes] || options[:quotes]
 
+    if options[:include_fields]
+      data = transform_data_for_field_options(data, options, object_key)
+      if data.is_a?(Hash)
+        if options[:raw_fields]
+          if options[:include_fields_context]
+            data = data[options[:include_fields_context]]
+          else
+            # todo: could use a dynamic object_key, first Array or Hash in the data, can probably always do this...
+            # if object_key.nil?
+            #   object_key = data.keys.find {|k| data[k].is_a?(Array) || data[k].is_a?(Hash) }
+            # end
+            # if object_key && data[object_key]
+            #   data = data[object_key]
+            # end
+          end
+        else
+          if object_key
+            data = data[object_key]
+          end
+        end
+      end
+    else
+      # need array of records, so always select the object/array here
+      if object_key
+        if data.is_a?(Hash)
+          data = data[object_key]
+        else
+          Morpheus::Logging::DarkPrinter.puts "as_csv() expects data as an to fetch object key '#{object_key}' from, #{records.class}." if Morpheus::Logging.debug?
+        end
+      end
+    end
+    
+    
+    records = data
+
+    # allow records as Array and Hash only..
+    if records.is_a?(Array)
+      # records = records
+    elsif records.is_a?(Hash)
+      records = [records]
+    else
+      #raise "records_as_csv expects records as an Array of objects to render"
+      Morpheus::Logging::DarkPrinter.puts "as_csv() expects data as an Array of objects to render, got a #{records.class} instead" if Morpheus::Logging.debug?
+      # return ""
+      return out
+    end
+
+    # build column definitions, by default use all properties for the first record (Hash) in the array
+    columns = []
+    all_fields = records.first.is_a?(Hash) ? records.first.keys : []
+    if options[:include_fields]
+      if (options[:include_fields].is_a?(Array) && options[:include_fields].size == 1 && options[:include_fields][0] == 'all') || options[:include_fields] == 'all'
+        columns = all_fields
+      else
+        columns = options[:include_fields]
+      end
+    elsif options[:all_fields]
+      columns = all_fields
+    elsif default_columns
+      columns = default_columns
+    else
+      columns = all_fields
+    end
+
     column_defs = build_column_definitions(columns)
-    #columns = columns.flatten.compact
-    data_array = [data].flatten.compact
 
     if include_header
       headers = column_defs.collect {|column_def| column_def.label }
@@ -1113,7 +1182,7 @@ module Morpheus::Cli::PrintHelper
       out << newline
     end
     lines = []
-    data_array.each do |obj|
+    records.each do |obj|
       if obj
         cells = []
         column_defs.each do |column_def|
@@ -1137,29 +1206,9 @@ module Morpheus::Cli::PrintHelper
 
   end
 
+  # deprecated, replaced by as_csv(records, columns, options, object_key)
   def records_as_csv(records, options={}, 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 options[:include_fields]
-      if (options[:include_fields].is_a?(Array) && options[:include_fields].size == 1 && options[:include_fields][0] == 'all') || options[:include_fields] == 'all'
-        cols = all_fields
-      else
-        cols = options[:include_fields]
-      end
-    elsif options[:all_fields]
-      cols = all_fields
-    elsif default_columns
-      cols = default_columns
-    else
-      cols = all_fields
-    end
-    out << as_csv(records, cols, options)
-    out
+    as_csv(records, default_columns, options)
   end
 
   def as_json(data, options={}, object_key=nil)
@@ -1169,12 +1218,7 @@ module Morpheus::Cli::PrintHelper
     end
 
     if options[:include_fields]
-      if object_key
-        # data[object_key] = filter_data(data[object_key], options[:include_fields])
-        data = {(object_key) => filter_data(data[object_key], options[:include_fields]) }
-      else
-        data = filter_data(data, options[:include_fields])
-      end
+      data = transform_data_for_field_options(data, options, object_key)
     end
 
     do_pretty = options.key?(:pretty_json) ? options[:pretty_json] : true
@@ -1193,11 +1237,7 @@ module Morpheus::Cli::PrintHelper
       return "null" # "No data"
     end
     if options[:include_fields]
-      if object_key
-        data[object_key] = filter_data(data[object_key], options[:include_fields])
-      else
-        data = filter_data(data, options[:include_fields])
-      end
+      data = transform_data_for_field_options(data, options, object_key)
     end
     begin
       out << data.to_yaml
@@ -1209,6 +1249,48 @@ module Morpheus::Cli::PrintHelper
     out
   end
 
+
+  # transform data for options --fields id,authority and --select id,authority
+  # support traversing records with --raw-fields and the list command. Example: roles list --raw-fields roles.id,roles.authority
+  def transform_data_for_field_options(data, options, object_key=nil)
+    if options[:include_fields] && data.is_a?(Hash)
+      if options[:raw_fields]
+        row = (object_key && !options[:raw_fields]) ? data[object_key] : data
+        records = [row].flatten()
+        # look for an array in the first field only now...
+        field_parts = options[:include_fields][0].to_s.split(".")
+        field_context = field_parts[0]
+        context_data = data[field_context]
+        if field_parts.size > 1 && context_data.is_a?(Array)
+          # inject all the root level properties to be selectable too..
+          context_data = data.delete(field_context)
+          # records = context_data
+          records = context_data.collect {|it| it.is_a?(Hash) ? data.merge(it) : data }
+          # hacky modifying options in place
+          options[:include_fields_context] = field_context
+          options[:include_fields] = options[:include_fields].collect {|it| it.sub(field_context+'.', '')}
+          # data = filter_data(records, options[:include_fields])
+          # data[field_context] = filter_data(records, options[:include_fields])
+          data = {(field_context) => filter_data(records, options[:include_fields])}
+        else
+          data = filter_data(data, options[:include_fields])
+        end
+      else
+        # By default, fields are relative to the object_key, so you can use -F id instead of requiring -F instance.id
+        # So ironically it is the 'raw' options (:raw_fields == true) that has to do all this funny stuff to filter intuitively.
+        if object_key
+          # this removes everything but the object, makes sense when using --fields
+          data = {(object_key) => filter_data(data[object_key], options[:include_fields])}
+          # this preserves other fields eg. meta...
+          # data[object_key] = filter_data(data[object_key], options[:include_fields])
+        else
+          data = filter_data(data, options[:include_fields])
+        end
+      end
+    end
+    return data
+  end
+
   def sleep_with_dots(sleep_seconds, dots=3, dot_chr=".")
     dot_interval = (sleep_seconds.to_f / dots.to_i)
     dots.to_i.times do |dot_index|

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

@@ -2082,7 +2082,6 @@ module Morpheus::Cli::ProvisioningHelper
         if !visibility && !options[:no_prompt]
           visibility = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'visibility', 'fieldLabel' => 'Tenant Permissions Visibility', 'type' => 'select', 'defaultValue' => 'private', 'required' => true, 'selectOptions' => [{'name' => 'Private', 'value' => 'private'},{'name' => 'Public', 'value' => 'public'}]}], options[:options], @api_client, {})['visibility']
         end
-
         permissions['resourcePool'] = {'visibility' => visibility} if visibility
       end
 
@@ -2114,8 +2113,7 @@ module Morpheus::Cli::ProvisioningHelper
   def prompt_permissions_v2(options, excludes = [])
     perms = prompt_permissions(options, excludes)
     rtn = {}
-
-    rtn['visibility'] = perms['resourcePool']['visibility'] if !perms['resourcePool'].nil?
+    rtn['visibility'] = perms['resourcePool']['visibility'] if !perms['resourcePool'].nil? && !excludes.include?('visibility')
     rtn['tenants'] = ((perms['tenantPermissions'] || {})['accounts'] || []).collect {|it| {'id' => it}}
     rtn
   end

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

@@ -148,6 +148,28 @@ module Morpheus::Cli::RestCommand
 
     alias :set_rest_interface_name :rest_interface_name=
 
+    # rest_perms_config enables and configures permissions prompt
+    def rest_perms_config
+      @rest_perms_config || {}
+    end
+
+    def rest_perms_config=(v)
+      @rest_perms_config = v
+    end
+
+    alias :set_rest_perms_config :rest_perms_config=
+
+    # rest_option_context_map specifies context mapping during option prompt. default is domain => ''
+    def rest_option_context_map
+      @option_context_map || {'domain' => ''}
+    end
+
+    def rest_option_context_map=(v)
+      @option_context_map = v
+    end
+
+    alias :set_rest_option_context_map :rest_option_context_map=
+
     # rest_has_type indicates a resource has a type. default is false
     def rest_has_type
       @rest_has_type == true
@@ -329,6 +351,14 @@ module Morpheus::Cli::RestCommand
     self.class.rest_interface_name
   end
 
+  def rest_perms_config
+    self.class.rest_perms_config
+  end
+
+  def rest_option_context_map
+    self.class.rest_option_context_map
+  end
+
   # returns the default rest interface, allows using rest_interface_name = "your"
   # or override this method to return @your_interface if needed
   def rest_interface
@@ -567,7 +597,8 @@ EOT
   def add(args)
     record_type = nil
     record_type_id = nil
-    options = {}
+    options = {:options => {:context_map => rest_option_context_map}}
+    #respond_to?("#{rest_key}_option_context_map", true) ? send("#{rest_key}_option_context_map") : {'domain' => ''}}}
     option_types = respond_to?("add_#{rest_key}_option_types", true) ? send("add_#{rest_key}_option_types") : []
     advanced_option_types = respond_to?("add_#{rest_key}_advanced_option_types", true) ? send("add_#{rest_key}_advanced_option_types") : []
     type_option_type = option_types.find {|it| it['fieldName'] == 'type'} 
@@ -600,25 +631,25 @@ EOT
       verify_args!(args:args, optparse:optparse, count: 0)
     end
     connect(options)
-    # load or prompt for type
-    if rest_has_type && type_option_type.nil?
-      if record_type_id.nil?
-        #raise_command_error "#{rest_type_label} is required.\n#{optparse}"
-        type_list = rest_type_interface.list({max:10000, creatable:true})[rest_type_list_key]
-        type_dropdown_options = respond_to?("#{rest_key}_type_list_to_options", true) ? send("#{rest_key}_type_list_to_options", type_list) : type_list.collect {|it| {'name' => it['name'], 'value' => it['code']} }
-        record_type_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => rest_type_label, 'type' => 'select', 'selectOptions' => type_dropdown_options, 'required' => true}], options[:options], @api_client)['type']
-      end
-      record_type = rest_type_find_by_name_or_id(record_type_id)
-      if record_type.nil?
-        return 1, "#{rest_type_label} not found for '#{record_type_id}"
-      end
-    end
     passed_options = parse_passed_options(options)
     payload = {}
     if options[:payload]
       payload = options[:payload]
       payload.deep_merge!({rest_object_key => passed_options})
     else
+      # load or prompt for type
+      if rest_has_type && type_option_type.nil?
+        if record_type_id.nil?
+          #raise_command_error "#{rest_type_label} is required.\n#{optparse}"
+          type_list = rest_type_interface.list({max:10000, creatable:true})[rest_type_list_key]
+          type_dropdown_options = respond_to?("#{rest_key}_type_list_to_options", true) ? send("#{rest_key}_type_list_to_options", type_list) : type_list.collect {|it| {'name' => it['name'], 'value' => it['code']} }
+          record_type_id = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'type', 'fieldLabel' => rest_type_label, 'type' => 'select', 'selectOptions' => type_dropdown_options, 'required' => true}], options[:options], @api_client)['type']
+        end
+        record_type = rest_type_find_by_name_or_id(record_type_id)
+        if record_type.nil?
+          return 1, "#{rest_type_label} not found for '#{record_type_id}"
+        end
+      end
       record_payload = {}
       if record_name
         record_payload['name'] = record_name
@@ -667,7 +698,7 @@ EOT
           end
         end
         api_params = (options[:params] || {}).merge(record_payload)
-        v_prompt = Morpheus::Cli::OptionTypes.prompt(my_option_types, options[:options], @api_client, api_params)
+        v_prompt = Morpheus::Cli::OptionTypes.prompt(my_option_types, options[:options], @api_client, api_params, false, true)
         v_prompt.deep_compact!
         v_prompt.booleanize! # 'on' => true
         record_payload.deep_merge!(v_prompt)
@@ -679,6 +710,18 @@ EOT
         v_prompt.booleanize! # 'on' => true
         record_payload.deep_merge!(v_prompt)
       end
+      # permissions
+      if rest_perms_config[:enabled]
+        if rest_perms_config[:version] == 2
+          perms = prompt_permissions_v2(options.deep_merge(rest_perms_config[:options] || {}), rest_perms_config[:excludes] || [])
+        else
+          perms = prompt_permissions(options.deep_merge(rest_perms_config[:options] || {}), rest_perms_config[:excludes] || [])
+        end
+        if !rest_perms_config[:name].nil?
+          perms.transform_keys! {|k| k == 'resourcePermissions' ? rest_perms_config[:name] : k}
+        end
+        record_payload.merge!(perms)
+      end
       payload[rest_object_key] = record_payload
     end
     rest_interface.setopts(options)