mtncloud-cli 1.0.0

data/lib/mtncloud/cli/mixins/processes_helper.rb

@@ -0,0 +1,286 @@
+require 'mtncloud/cli/mixins/print_helper'
+
+# Mixin for MtnCloud::Cli command classes
+# Provides common methods for viewing process history
+module MtnCloud::Cli::ProcessesHelper
+
+  def self.included(klass)
+    klass.send :include, MtnCloud::Cli::PrintHelper
+  end
+
+  def api_client
+    raise "#{self.class} has not defined @api_client" if @api_client.nil?
+    @api_client
+  end
+
+  def processes_interface
+    # get_interface('processes')
+    api_client.processes
+  end
+
+  def print_process_details(process, options={})
+    description_cols = {
+      "Process ID" => lambda {|it| it['id'] },
+      "Name" => lambda {|it| it['displayName'] },
+      "Description" => lambda {|it| it['description'] },
+      "Process Type" => lambda {|it| it['processType'] ? (it['processType']['name'] || it['processType']['code']) : it['processTypeName'] },
+      "Created By" => lambda {|it| it['createdBy'] ? (it['createdBy']['displayName'] || it['createdBy']['username']) : '' },
+      "Start Date" => lambda {|it| format_local_dt(it['startDate']) },
+      "End Date" => lambda {|it| format_local_dt(it['endDate']) },
+      "Duration" => lambda {|it| format_process_duration(it) },
+    }
+    if process['message'].to_s.strip != ''
+      description_cols.merge!({ "Message" => lambda {|it| it['message']}
+      })
+    end
+    description_cols.merge!({
+      "Status" => lambda {|it| format_process_status(it) },
+      # "# Events" => lambda {|it| (it['events'] || []).size() },
+    })
+    print_description_list(description_cols, process, options)
+
+    if process['error']
+      print_h2 "Error"
+      print reset
+      #puts format_process_error(process_event)
+      puts process['error'].to_s.strip
+    end
+
+    if process['output']
+      print_h2 "Output"
+      print reset
+      #puts format_process_error(process_event)
+      puts process['output'].to_s.strip
+    end
+  end
+
+  def print_process_event_details(process_event, options={})
+    # process_event =~ process
+    description_cols = {
+      "Process ID" => lambda {|it| it['processId'] },
+      "Event ID" => lambda {|it| it['id'] },
+      "Name" => lambda {|it| it['displayName'] },
+      "Description" => lambda {|it| it['description'] },
+      "Process Type" => lambda {|it| it['processType'] ? (it['processType']['name'] || it['processType']['code']) : it['processTypeName'] },
+      "Created By" => lambda {|it| it['createdBy'] ? (it['createdBy']['displayName'] || it['createdBy']['username']) : '' },
+      "Start Date" => lambda {|it| format_local_dt(it['startDate']) },
+      "End Date" => lambda {|it| format_local_dt(it['endDate']) },
+      "Duration" => lambda {|it| format_process_duration(it) },
+      "Status" => lambda {|it| format_process_status(it) },
+    }
+    print_description_list(description_cols, process_event, options)
+
+    if process_event['error']
+      print_h2 "Error"
+      print reset
+      #puts format_process_error(process_event)
+      puts process_event['error'].to_s.strip
+    end
+
+    if process_event['output']
+      print_h2 "Output"
+      print reset
+      #puts format_process_error(process_event)
+      puts process_event['output'].to_s.strip
+    end
+  end
+  
+
+  def format_process_status(process, return_color=cyan)
+    out = ""
+    status_string = process['status'].to_s
+    if status_string == 'complete'
+      out << "#{green}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'failed'
+      out << "#{red}#{status_string.upcase}#{return_color}"
+    elsif status_string == 'expired'
+      out << "#{red}#{status_string.upcase}#{return_color}"
+    else
+      out << "#{cyan}#{status_string.upcase}#{return_color}"
+    end
+    out
+  end
+
+  # decolorize, remove newlines and truncate for table cell
+  def format_process_error(process, max_length=20, return_color=cyan)
+    truncate_string(process['error'].to_s.strip.gsub("\n", " "), max_length)
+  end
+
+  # decolorize, remove newlines and truncate for table cell
+  def format_process_output(process, max_length=20, return_color=cyan)
+    truncate_string(process['output'].to_s.strip.gsub("\n", " "), max_length)
+  end
+
+  # format for either ETA/Duration
+  def format_process_duration(process, time_format="%H:%M:%S")
+    out = ""
+    if process['duration'] && process['duration'] > 0
+      out = format_duration_milliseconds(process['duration'], time_format)
+    elsif process['statusEta'] && process['statusEta'] > 0
+      out = format_duration_milliseconds(process['statusEta'], time_format)
+    elsif process['startDate'] && process['endDate']
+      out = format_duration(process['startDate'], process['endDate'], time_format)
+    else
+      ""
+    end
+    out
+  end
+
+  def wait_for_process_execution(process_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 process is complete...", "\n", reset
+    end
+    process = processes_interface.get(process_id)['process']
+    while ['new','queued','pending','running'].include?(process['status']) do
+      sleep(refresh_interval)
+      process = processes_interface.get(process_id)['process']
+    end
+    if print_output && options[:quiet] != true
+      print_h1 "Process Details", [], options
+      print_process_details(process, options)
+    end
+    return process
+  end
+
+  def handle_history_command(args, arg_name, label, ref_type, &block)
+    raw_args = args.dup
+    options = {}
+    #options[:show_output] = true
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = "Usage: #{prog_name} #{command_name} history [#{arg_name}]"
+      opts.on( nil, '--events', "Display sub processes (events)." ) do
+        options[:show_events] = true
+      end
+      opts.on( nil, '--output', "Display process output." ) do
+        options[:show_output] = true
+      end
+      opts.on('--details', "Display more details: memory and storage usage used / max values." ) do
+        options[:show_events] = true
+        options[:show_output] = true
+        options[:details] = true
+      end
+      # opts.on('--process-id ID', String, "Display details about a specfic process only." ) do |val|
+      #   options[:process_id] = val
+      # end
+      # opts.on('--event-id ID', String, "Display details about a specfic process event only." ) do |val|
+      #   options[:event_id] = val
+      # end
+      build_standard_list_options(opts, options)
+      opts.footer = "List historical processes for a specific #{label}.\n" + 
+                    "[#{arg_name}] is required. This is the name or id of an #{label}."
+    end
+    optparse.parse!(args)
+
+    # shortcut to other actions
+    # if options[:process_id]
+    #   return history_details(raw_args)
+    # elsif options[:event_id]
+    #   return history_event_details(raw_args)
+    # end
+
+    verify_args!(args:args, optparse:optparse, count:1)
+    connect(options)
+    
+    record = block.call(args[0])
+    # block should raise_command_error if not found
+    if record.nil?
+      raise_command_error "#{label} not found for name or id '#{args[0]}'"
+    end
+    params = {}
+    params.merge!(parse_list_options(options))
+    # params['query'] = params.delete('phrase') if params['phrase']
+    params['refType'] = ref_type
+    params['refId'] = record['id']
+    @processes_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @processes_interface.dry.list(params)
+      return
+    end
+    json_response = @processes_interface.list(params)
+    render_response(json_response, options, "processes") do
+      title = "#{label} History: #{record['name'] || record['id']}"
+      subtitles = parse_list_subtitles(options)
+      print_h1 title, subtitles, options
+      processes = json_response['processes']
+      if processes.empty?
+        print "#{cyan}No process history found.#{reset}\n\n"
+      else
+        history_records = []
+        processes.each do |process|
+          row = {
+            id: process['id'],
+            eventId: nil,
+            uniqueId: process['uniqueId'],
+            name: process['displayName'],
+            description: process['description'],
+            processType: process['processType'] ? (process['processType']['name'] || process['processType']['code']) : process['processTypeName'],
+            createdBy: process['createdBy'] ? (process['createdBy']['displayName'] || process['createdBy']['username']) : '',
+            startDate: format_local_dt(process['startDate']),
+            duration: format_process_duration(process),
+            status: format_process_status(process),
+            error: format_process_error(process, options[:details] ? nil : 20),
+            output: format_process_output(process, options[:details] ? nil : 20)
+          }
+          history_records << row
+          process_events = process['events'] || process['processEvents']
+          if options[:show_events]
+            if process_events
+              process_events.each do |process_event|
+                event_row = {
+                  id: process['id'],
+                  eventId: process_event['id'],
+                  uniqueId: process_event['uniqueId'],
+                  name: process_event['displayName'], # blank like the UI
+                  description: process_event['description'],
+                  processType: process_event['processType'] ? (process_event['processType']['name'] || process_event['processType']['code']) : process['processTypeName'],
+                  createdBy: process_event['createdBy'] ? (process_event['createdBy']['displayName'] || process_event['createdBy']['username']) : '',
+                  startDate: format_local_dt(process_event['startDate']),
+                  duration: format_process_duration(process_event),
+                  status: format_process_status(process_event),
+                  error: format_process_error(process_event, options[:details] ? nil : 20),
+                  output: format_process_output(process_event, options[:details] ? nil : 20)
+                }
+                history_records << event_row
+              end
+            else
+              
+            end
+          end
+        end
+        columns = [
+          {:id => {:display_name => "PROCESS ID"} },
+          :name, 
+          :description, 
+          {:processType => {:display_name => "PROCESS TYPE"} },
+          {:createdBy => {:display_name => "CREATED BY"} },
+          {:startDate => {:display_name => "START DATE"} },
+          {:duration => {:display_name => "ETA/DURATION"} },
+          :status, 
+          :error
+        ]
+        if options[:show_events]
+          columns.insert(1, {:eventId => {:display_name => "EVENT ID"} })
+        end
+        if options[:show_output]
+          columns << :output
+        end
+        # custom pretty table columns ...
+        if options[:include_fields]
+          columns = options[:include_fields]
+        end
+        print cyan
+        print as_pretty_table(history_records, columns, options)
+        #print_results_pagination(json_response)
+        print_results_pagination(json_response, {:label => "process", :n_label => "processes"})
+        print reset, "\n"
+      end
+    end
+    return 0, nil
+  end
+
+end

data/lib/mtncloud/cli/mixins/prompt_helper.rb

@@ -0,0 +1,136 @@
+require 'mtncloud/cli/option_types'
+
+# Mixin for MtnCloud::Cli command classes
+# Provides common methods for prompting for option type inputs and forms.
+# Prompting is delegated to the {MtnCloud::Cli::OptionTypes} module
+# while the provided {#prompt} simplifies the required parameters
+# The command class must establish the +@api_client+ on its own.
+#
+module MtnCloud::Cli::PromptHelper
+
+  # Prompt for a list of inputs (OptionType) and return a Hash containing
+  # all of the provides values.  The user is prompted to provide a value 
+  # for each input, unless the value is already set in the options.
+  # @param [Array, Hash] option_types the list of OptionType inputs with fieldName, fieldLabel, etc.
+  #   A single option type Hash can be passed instead.
+  # @param [Hash] options the standard command options
+  #   This map is a mixture of keys that are Symbols that provide some common
+  #   functionality like :no_prompt, :context_map, etc.
+  #   Any keys that are Strings get used to lookup input values, along with 
+  #   +options[:options]+ and +options[:params]+.
+  #   The precedence for providing option values is as follows: 
+  #   1. options['foo']  2. options[:params]['foo'] 3. options[:options]['foo'] 4. User is prompted.
+  # @option options [Hash] :options map of values provided by the user via the generic -O OPTIONS switch, gets merged into the context used for providing input values
+  # @option options [Hash] :params map of additional values provided by the user via explicite options, gets merged into the context used for providing input values
+  # @option options [Hash] :no_prompt supresses prompting, use default values and error if a required input is not provided. Default is of course +false+.
+  # @option options [Hash] :context_map Can to change the fieldContext of the option_types, eg. :context_map => {'networkDhcpRelay' => ''}
+  # @option options [APIClient] :api_client The {APIClient} to use for option types that request api calls. Default is the @api_client established by the class
+  # @option options [Hash] :api_params Optional map of parameters to include in API request for select option types
+  # @option options [Boolean] :paging_enabled Enable paging if there are a lot of available options to display. Default is +false+.
+  # @option options [Boolean] :ignore_empty Ignore inputs that have no options, this can be used to allow prompting to continue without error if a select input has no options.
+  # @option options [Boolean] :skip_sort Do not sort the inputs by displayOrder, assume they are already sorted. Default is +true+.
+  # @return [Hash] containing the values provided for each option type, the key is the input fieldName
+  #
+  # @example Prompt for name
+  #
+  #   results = prompt([{'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true}], options)
+  #   puts "Name: #{results['name']}"
+  #
+  def prompt(option_types, options={})
+    # option types can be passed as a single input instead of an array
+    option_types = option_types.is_a?(Hash) ? [option_types] : option_types #Array(option_types)
+    # construct options parameter for MtnCloud::Cli::OptionTypes.prompt
+    options = construct_prompt_options(options)
+    # by default the @api_client established by the command is used
+    api_client = options.key?(:api_client) ? options[:api_client] : @api_client
+    api_params = options.key?(:api_params) ? options[:api_params] : {}
+    no_prompt = options.key?(:no_prompt) ? options[:no_prompt] : false
+    paging_enabled = options.key?(:paging_enabled) ? options[:paging_enabled] : true
+    ignore_empty = options.key?(:ignore_empty) ? options[:ignore_empty] : false
+    # Defaulting skip_sort to true which is the opposite of OptionTypes.prompt()
+    # The API handles sorting most of the time now, calling function can sort before prompting if needed
+    # maybe switch this later if needed, removing skip_sort would be nice though...
+    skip_sort = options.key?(:skip_sort) ? options[:skip_sort] : true
+    results = MtnCloud::Cli::OptionTypes.prompt(option_types, options, api_client, api_params, no_prompt, paging_enabled, ignore_empty, skip_sort)
+    # trying to get rid of the need to do these compact and booleanize calls..
+    # for now you can use options.merge({compact: true,booleanize: true}) or modify the results yourself
+    results.deep_compact! if options[:compact]
+    results.booleanize! if options[:booleanize] # 'on' => true
+    return results
+  end
+
+  # Process 1-N inputs (OptionType) in a special 'edit mode' that supresses user interaction.
+  # This is used by +update+ commands where we want to process option types
+  # without prompting the user so that the results only contains values that are passed in explicitely as options and default values are not used.
+  # @see {#prompt} method for details on the supported options
+  #
+  def no_prompt(option_types, options={})
+    options = options.merge({:edit_mode => true, :no_prompt => true})
+    options.delete(:no_prompt) if options[:always_prompt] # --prompt to always prompt
+    return prompt(option_types, options)
+  end
+
+  # Prompt for a single input and return only the value
+  # @param [Hash] option_type the OptionType input record to prompt for, contains fieldName, fieldLabel, etc.
+  # @param [Hash] options the standard command options
+  # @see {#prompt} method for details on the supported options
+  # @return [String, Number, Hash, Array, nil] value provided by the options or user input, usually a string or a number or nil if no value is provided.
+  #
+  # @example Prompt for name value
+  #
+  #   chosen_name = prompt_value({'fieldName' => 'name', 'fieldLabel' => 'Name', 'type' => 'text', 'required' => true}, options)
+  #   puts "Chosen Name: #{chosen_name}"
+  #
+  def prompt_value(option_type, options={})
+    # this does not need with fieldContext, so get rid of it
+    # option_types = [option_type.merge({'fieldContext' => nil})]
+    # results = prompt(Array(option_type), options)
+    # return results[option_type['fieldName']]
+
+    # this works with fieldContext now, hooray
+    # use get_object_value() to traverse object to get the value
+    option_types = [option_type] # Array(option_type)
+    results = prompt(option_types, options)
+    return get_option_type_value(results, option_types.first)
+  end
+
+  # Process inputs of a form, prompting for its options and field groups
+  # @param [Hash] form the OptionTypeForm to process
+  # @param [Hash] options the standard command options
+  # @see {#prompt} method for defailts on the supported options
+  # @return Hash containing the values provided for each option type, the key is the fieldName
+  #
+  def prompt_form(form, options={})
+    form_results = {}
+    results = prompt(Array(form['options']), options.merge(form_results))
+    form_results.deep_merge!(results)
+    # prompt for each field group, merging results into options context as we go
+    Array(form['fieldGroups']).each do |field_group|
+      # todo: look at isCollapsible, defaultCollapsed and visibleOnCode to see if the group should
+      # if collapsed then just use options.merge({:no_prompt => true}) and maybe need to set :required => false ?
+      results = prompt(field_group['options'], options.merge(form_results))
+      form_results.deep_merge!(results)
+    end
+    return form_results
+  end
+
+  protected
+
+  # construct options parameter for MtnCloud::Cli::OptionTypes.prompt
+  # This options Hash is a mixture of Symbols that provide some common functionality like :no_prompt, and :context_map, etc.
+  # String keys are used to lookup values being passed into the command in order to prevent prompting the user
+  # The precedence for providing option values is as follows: 
+  #   1. options['foo']  2. options[:params]['foo'] 3. options[:options]['foo']
+  #
+  def construct_prompt_options(options)
+    passed_options = Hash(options[:options]).select {|k,v| k.is_a?(String) }
+    params = Hash(options[:params]).select {|k,v| k.is_a?(String) }
+    return passed_options.deep_merge(params).deep_merge!(options)
+  end
+
+  def get_option_type_value(results, option_type)
+    field_key = [option_type['fieldContext'], option_type['fieldName']].select {|it| it && it != '' }.join('.')
+    get_object_value(results, field_key)
+  end
+
+end