morpheus-cli 3.3.1.4 → 3.3.2

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

@@ -0,0 +1,123 @@
+require 'morpheus/cli/mixins/print_helper'
+require 'morpheus/cli/option_types'
+# Mixin for Morpheus::Cli command classes
+# Provides common methods for library management commands
+module Morpheus::Cli::LibraryHelper
+
+  def self.included(klass)
+    klass.send :include, Morpheus::Cli::PrintHelper
+  end
+
+  def api_client
+    raise "#{self.class} has not defined @api_client" if @api_client.nil?
+    @api_client
+  end
+
+  def find_instance_type_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_instance_type_by_id(val)
+    else
+      return find_instance_type_by_name(val)
+    end
+  end
+
+  def find_instance_type_by_id(id)
+    begin
+      json_response = @library_instance_types_interface.get(id.to_i)
+      return json_response['instanceType']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Instance Type not found by id #{id}"
+      else
+        raise e
+      end
+    end
+  end
+
+  def find_instance_type_by_name(name)
+    json_response = @library_instance_types_interface.list({name: name.to_s})
+    instance_types = json_response['instanceTypes']
+    if instance_types.empty?
+      print_red_alert "Instance Type not found by name #{name}"
+      return nil
+    elsif instance_types.size > 1
+      print_red_alert "#{instance_types.size} instance types found by name #{name}"
+      print_instance_types_table(instance_types, {color: red})
+      print_red_alert "Try using ID instead"
+      print reset,"\n"
+      return nil
+    else
+      return instance_types[0]
+    end
+  end
+
+  def print_instance_types_table(instance_types, opts={})
+    columns = [
+      {"ID" => lambda {|instance_type| instance_type['id'] } },
+      {"NAME" => lambda {|instance_type| instance_type['name'] } },
+      {"CODE" => lambda {|instance_type| instance_type['code'] } },
+      {"TECHNOLOGY" => lambda {|instance_type| format_instance_type_technology(instance_type) } },
+      {"CATEGORY" => lambda {|instance_type| instance_type['category'].to_s.capitalize } },
+      {"FEATURED" => lambda {|instance_type| format_boolean instance_type['featured'] } },
+      {"OWNER" => lambda {|instance_type| instance_type['account'] ? instance_type['account']['name'] : '' } },
+    ]
+    if opts[:include_fields]
+      columns = opts[:include_fields]
+    end
+    print as_pretty_table(instance_types, columns, opts)
+  end
+
+  def format_instance_type_technology(instance_type)
+    if instance_type
+      instance_type['provisionTypeCode'].to_s.capitalize
+    else
+      ""
+    end
+  end
+
+  def load_balance_protocols_dropdown
+    [
+      {'name' => 'None', 'value' => ''},
+      {'name' => 'HTTP', 'value' => 'HTTP'},
+      {'name' => 'HTTPS', 'value' => 'HTTPS'},
+      {'name' => 'TCP', 'value' => 'TCP'}
+    ]
+  end
+
+  # Prompts user for exposed ports array
+  # returns array of port objects
+  def prompt_exposed_ports(options={}, api_client=nil, api_params={})
+    #puts "Configure ports:"
+    no_prompt = (options[:no_prompt] || (options[:options] && options[:options][:no_prompt]))
+
+    ports = []
+    port_index = 0
+    has_another_port = options[:options] && options[:options]["exposedPort#{port_index}"]
+    add_another_port = has_another_port || (!no_prompt && Morpheus::Cli::OptionTypes.confirm("Add an exposed port?"))
+    while add_another_port do
+      field_context = "exposedPort#{port_index}"
+
+      port = {}
+      #port['name'] ||= "Port #{port_index}"
+      port_label = port_index == 0 ? "Port" : "Port [#{port_index+1}]"
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'name', 'type' => 'text', 'fieldLabel' => "#{port_label} Name", 'required' => false, 'description' => 'Choose a name for this port.', 'defaultValue' => port['name']}], options[:options])
+      port['name'] = v_prompt[field_context]['name']
+
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'port', 'type' => 'number', 'fieldLabel' => "#{port_label} Number", 'required' => true, 'description' => 'A port number. eg. 8001', 'defaultValue' => (port['port'] ? port['port'].to_i : nil)}], options[:options])
+      port['port'] = v_prompt[field_context]['port']
+
+      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldContext' => field_context, 'fieldName' => 'loadBalanceProtocol', 'type' => 'select', 'fieldLabel' => "#{port_label} LB", 'selectOptions' => load_balance_protocols_dropdown, 'required' => false, 'skipSingleOption' => true, 'description' => 'Choose a load balance protocol.', 'defaultValue' => port['loadBalanceProtocol']}], options[:options])
+      port['loadBalanceProtocol'] = v_prompt[field_context]['loadBalanceProtocol']
+
+      ports << port
+      port_index += 1
+      has_another_port = options[:options] && options[:options]["exposedPort#{port_index}"]
+      add_another_port = has_another_port || (!no_prompt && Morpheus::Cli::OptionTypes.confirm("Add another exposed port?"))
+
+    end
+
+
+    return ports
+  end
+
+end

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

@@ -58,7 +58,7 @@ module Morpheus::Cli::PrintHelper
     out << "\n"
     out << "#{color}#{bold}#{title}#{reset}"
     if !subtitles.empty?
-      out << "#{color} - #{subtitles.join(', ')}#{reset}"
+      out << "#{color} | #{subtitles.join(', ')}#{reset}"
     end
     out << "\n"
     out << "#{color}#{bold}==================#{reset}"
@@ -574,8 +574,15 @@ module Morpheus::Cli::PrintHelper
     columns.each do |col|
       # determine label
       if col.is_a?(String)
-        k = col
-        v = col
+        # supports "field as Label"
+        field_key, field_label = col.split(/\s+as\s+/)
+        if field_key && field_label
+          k = field_label.strip
+          v = field_key.strip
+        else
+          k = col.strip
+          v = col.strip
+        end
         build_column_definitions([{(k) => v}]).each do |r|
           results << r if r
         end
@@ -684,15 +691,13 @@ module Morpheus::Cli::PrintHelper
     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
+
+    column_defs = build_column_definitions(columns)
+    #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 }
+      headers = column_defs.collect {|column_def| column_def.label }
       if do_quotes
         headers = headers.collect {|it| quote_csv_value(it) }
       end
@@ -703,8 +708,10 @@ module Morpheus::Cli::PrintHelper
     data_array.each do |obj|
       if obj
         cells = []
-        columns.each do |column_def|
-          value = get_object_value(obj, column_def)
+        column_defs.each do |column_def|
+          label = column_def.label
+          value = column_def.display_method.call(obj)
+          # value = get_object_value(obj, column_def)
           if do_quotes
             cells << quote_csv_value(value)
           else
@@ -718,6 +725,7 @@ module Morpheus::Cli::PrintHelper
     out << lines.join(newline)
     #out << delim
     out
+
   end
 
   def records_as_csv(records, opts={}, default_columns=nil)
@@ -748,16 +756,7 @@ module Morpheus::Cli::PrintHelper
     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] = filter_data(data[json_fields_for], include_fields)
-    #   else
-    #     data = filter_data(data, include_fields)
-    #   end
-    # end
+
     do_pretty = options.key?(:pretty_json) ? options[:pretty_json] : true
     if do_pretty
       out << JSON.pretty_generate(data)

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

@@ -117,24 +117,63 @@ module Morpheus::Cli::ProvisioningHelper
       return find_cloud_by_name_for_provisioning(group_id, val)
     end
   end
+
+  def find_instance_type_by_id(id)
+    begin
+      json_response = instance_types_interface.get(id.to_i)
+      return json_response['instanceType']
+    rescue RestClient::Exception => e
+      if e.response && e.response.code == 404
+        print_red_alert "Instance Type not found by id #{id}"
+        return nil
+      else
+        raise e
+      end
+    end
+  end
+
   def find_instance_type_by_code(code)
-    results = instance_types_interface.get({code: code})
-    if results['instanceTypes'].empty?
+    results = instance_types_interface.list({code: code})
+    instance_types = results['instanceTypes']
+    if instance_types.empty?
       print_red_alert "Instance Type not found by code #{code}"
-      # return nil
-      exit 1
+      return nil
     end
-    return results['instanceTypes'][0]
+    if instance_types.size() > 1
+      print as_pretty_table(instance_types, [:id,:name,:code], {color:red})
+      print_red_alert "Try using ID instead"
+      return nil
+    end
+    # return instance_types[0]
+    # fetch by ID to get full details
+    # could also use ?details-true with search
+    return find_instance_type_by_id(instance_types[0]['id'])
   end
 
   def find_instance_type_by_name(name)
-    results = instance_types_interface.get({name: name})
-    if results['instanceTypes'].empty?
+    results = instance_types_interface.list({name: name})
+    instance_types = results['instanceTypes']
+    if instance_types.empty?
       print_red_alert "Instance Type not found by name #{name}"
-      # return nil
-      exit 1
+      return nil
+    end
+    if instance_types.size() > 1
+      print as_pretty_table(instance_types, [:id,:name,:code], {color:red})
+      print_red_alert "Try using ID instead"
+      return nil
+    end
+    # return instance_types[0]
+    # fetch by ID to get full details
+    # could also use ?details-true with search
+    return find_instance_type_by_id(instance_types[0]['id'])
+  end
+
+  def find_instance_type_by_name_or_id(val)
+    if val.to_s =~ /\A\d{1,}\Z/
+      return find_instance_type_by_id(val)
+    else
+      return find_instance_type_by_name(val)
     end
-    return results['instanceTypes'][0]
   end
 
   def find_instance_by_name_or_id(val)
@@ -205,6 +244,7 @@ module Morpheus::Cli::ProvisioningHelper
       instance_type_code = instance_type_prompt['type']
     end
     instance_type = find_instance_type_by_code(instance_type_code)
+    exit 1 if !instance_type
 
     # Instance Name
 
@@ -269,7 +309,12 @@ module Morpheus::Cli::ProvisioningHelper
     service_plans = service_plans_json["plans"]
     service_plans_dropdown = service_plans.collect {|sp| {'name' => sp["name"], 'value' => sp["id"]} } # already sorted
     plan_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'servicePlan', 'type' => 'select', 'fieldLabel' => 'Plan', 'selectOptions' => service_plans_dropdown, 'required' => true, 'description' => 'Choose the appropriately sized plan for this instance'}],options[:options])
-    service_plan = service_plans.find {|sp| sp["id"] == plan_prompt['servicePlan'].to_i }
+    plan_id = plan_prompt['servicePlan']
+    service_plan = service_plans.find {|sp| sp["id"] == plan_id.to_i }
+    if !service_plan
+      print_red_alert "Plan not found by id #{plan_id}"
+      exit 1
+    end
     payload['instance']['plan'] = {'id' => service_plan["id"]}
 
     # prompt for volumes

data/lib/morpheus/cli/network_services_command.rb

@@ -77,7 +77,7 @@ class Morpheus::Cli::NetworkServicesCommand
           row = {
             id: network_service['id'],
             name: network_service['name'],
-            type: network_service['type'] ? network_service['type']['name'] : '',
+            type: network_service['typeName'] || network_service['type'],
           }
           row
         }

data/lib/morpheus/cli/option_types.rb

@@ -233,7 +233,12 @@ module Morpheus
           else
             print Term::ANSIColor.red, "\nInvalid Option #{option_type['fieldLabel']}: [#{use_value}]\n\n", Term::ANSIColor.reset
             print Term::ANSIColor.red, "  * #{option_type['fieldLabel']} [-O #{option_type['fieldContext'] ? (option_type['fieldContext']+'.') : ''}#{option_type['fieldName']}=] - #{option_type['description']}\n", Term::ANSIColor.reset
-            display_select_options(opt, select_options)
+            if select_options && select_options.size > 10
+              display_select_options(option_type, select_options.first(10))
+              puts " (#{select_options.size-1} more)"
+            else
+              display_select_options(option_type, select_options)
+            end
             print "\n"
             exit 1
           end
@@ -247,7 +252,12 @@ module Morpheus
             if option_type['required']
               print Term::ANSIColor.red, "\nMissing Required Option\n\n", Term::ANSIColor.reset
               print Term::ANSIColor.red, "  * #{option_type['fieldLabel']} [-O #{option_type['fieldContext'] ? (option_type['fieldContext']+'.') : ''}#{option_type['fieldName']}=] - #{option_type['description']}\n", Term::ANSIColor.reset
-              display_select_options(option_type, select_options)
+              if select_options && select_options.size > 10
+                display_select_options(option_type, select_options.first(10))
+                puts " (#{select_options.size-1} more)"
+              else
+                display_select_options(option_type, select_options)
+              end
               print "\n"
               exit 1
             else

data/lib/morpheus/cli/power_scheduling_command.rb

@@ -797,7 +797,7 @@ class Morpheus::Cli::PowerSchedulingCommand
   end
 
   def find_server_by_name(name)
-    servers = @servers_interface.get({name: name.to_s})['servers']
+    servers = @servers_interface.list({name: name.to_s})['servers']
     if servers.empty?
       print_red_alert "Host not found by name #{name}"
       return nil

data/lib/morpheus/cli/shell.rb

@@ -118,7 +118,7 @@ class Morpheus::Cli::Shell
       opts.on('-C','--nocolor', "Disable ANSI coloring") do
         Term::ANSIColor::coloring = false
       end
-      opts.on('-V','--debug', "Print extra output for debugging. ") do |json|
+      opts.on('-V','--debug', "Print extra output for debugging.") do |json|
         Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
         ::RestClient.log = Morpheus::Logging.debug? ? Morpheus::Logging::DarkPrinter.instance : nil
       end
@@ -174,13 +174,103 @@ class Morpheus::Cli::Shell
     # all_commands = input.gsub(/(\;)(?=(?:[^"]|"[^"]*")*$)/, '__CMDDELIM__').split('__CMDDELIM__').collect {|it| it.to_s.strip }.select {|it| !it.empty?  }.compact
     all_commands = input.gsub(/(\;)(?=(?:[^"']|"[^'"]*")*$)/, '__CMDDELIM__').split('__CMDDELIM__').collect {|it| it.to_s.strip }.select {|it| !it.empty?  }.compact
     #puts "executing #{all_commands.size} commands: #{all_commands}"
+    final_command_result = nil
     all_commands.each do |cmd|
-      execute_command(cmd)
+      flow = parse_commands_and_operators(cmd)
+      if flow.size > 1
+        last_command_result = nil
+        if ['&&','||', '|'].include?(flow.first)
+          puts_error "invalid command format, begins with an operator: #{cmd}"
+          return 9
+        elsif ['&&','||', '|'].include?(flow.last)
+          puts_error "invalid command format, ends with an operator: #{cmd}"
+          return 9
+        # elsif ['&&','||', '|'].include?(flow.last)
+        #   puts_error "invalid command format, consecutive operators: #{cmd}"
+        else
+          #Morpheus::Logging::DarkPrinter.puts "Executing command flow: #{flow.inspect}" if Morpheus::Logging.debug?
+          previous_command = nil
+          previous_command_result = nil
+          current_operator = nil
+          still_executing = true
+          flow.each do |flow_cmd|
+            if still_executing
+              if flow_cmd == '&&'
+                # AND operator
+                current_operator = flow_cmd
+                if previous_command_result.to_i != 0
+                  still_executing = false
+                end
+              elsif flow_cmd == '||' # or with previous command
+                current_operator = flow_cmd
+                if previous_command_result.to_i == 0
+                  still_executing = false
+                end
+              elsif flow_cmd == '|' # or with previous command
+                puts_error "The PIPE (|) operator is not yet supported =["
+                previous_command_result = nil
+                still_executing = false
+                # or just continue?
+              else # it's a command, not an operator
+                current_operator = nil
+                previous_command_result = execute_command(flow_cmd)
+              end
+              previous_command = flow_cmd
+            else
+              #Morpheus::Logging::DarkPrinter.puts "operator skipped command: #{flow_cmd}" if Morpheus::Logging.debug?
+            end 
+            # previous_command = flow_cmd
+          end
+          final_command_result = previous_command_result
+        end
+      else
+        # just one command, this else is not needed tho
+        final_command_result = execute_command(cmd)
+      end
     end
     # skip logging of exit and !cmd
     unless input.strip.empty? || (["exit", "history"].include?(input.strip)) || input.strip[0].to_s.chr == "!"
       log_history_command(input.strip)
     end
+    return final_command_result
+  end
+
+  # returns Array of strings like [command1, operator, command2, operator, command3]
+  # eg. ["instances get 555", "||", "echo '%redInstance 555 is missing!'"]
+  def parse_commands_and_operators(input)
+    cmd = input
+    cmd_flow = []
+    begin
+      and_regex = /\s+\&\&\s+/
+      or_regex = /\s+\|\|\s+/
+      pipe_regex = /\s+\|\s+/
+      still_parsing = true
+      while still_parsing
+        and_index = cmd.index(and_regex)
+        or_index = cmd.index(or_regex)
+        pipe_index = cmd.index(pipe_regex)
+        if and_index # && (or_index == nil || or_index > and_index) && (pipe_index == nil || pipe_index > and_index)
+          cmd_flow << cmd[0..and_index-1]
+          cmd_flow << "&&"
+          cmd = cmd[and_index..-1].sub(and_regex, '')
+        elsif or_index && (and_index == nil || and_index > or_index) && (pipe_index == nil || pipe_index > or_index)
+          cmd_flow << cmd[0..or_index-1]
+          cmd_flow << "||"
+          cmd = cmd[or_index..-1].sub(or_regex, '')
+        elsif pipe_index && (and_index == nil || and_index > pipe_index) && (or_index == nil || or_index > pipe_index)
+          cmd_flow << cmd[0..pipe_index-1]
+          cmd_flow << "|"
+          cmd = cmd[pipe_index..-1].sub(pipe_regex, '')
+        else
+          cmd_flow << cmd
+          still_parsing = false
+        end
+      end
+      return cmd_flow
+    rescue => ex
+      puts_error "error parsing command flow: #{ex.message}"
+      return [input]
+    end
   end
 
   def execute_command(input)
@@ -219,21 +309,22 @@ class Morpheus::Cli::Shell
       elsif input =~ /^\s*#/
         Morpheus::Logging::DarkPrinter.puts "comment ignored" if Morpheus::Logging.debug?
         return 0
-      elsif input =~ /^sleep/
-        sleep_sec = input.sub("sleep ", "").to_f
-        if (!(sleep_sec > 0))
-          # raise_command_error "sleep requires the argument [seconds]. eg. sleep 3.14"
-          puts_error  "sleep requires argument [seconds]. eg. sleep 3.14"
-          return false
-        end
-        log_history_command(input)
-        Morpheus::Logging::DarkPrinter.puts "sleeping for #{sleep_sec}s ... zzzZzzzZ" if Morpheus::Logging.debug?
-        begin
-          sleep(sleep_sec)
-        rescue Interrupt
-          Morpheus::Logging::DarkPrinter.puts "\nInterrupt. waking up from sleep early"
-        end
-        return 0
+      # this is a full blown command now
+      # elsif input =~ /^sleep/
+      #   sleep_sec = input.sub("sleep ", "").to_f
+      #   if (!(sleep_sec > 0))
+      #     # raise_command_error "sleep requires the argument [seconds]. eg. sleep 3.14"
+      #     puts_error  "sleep requires argument [seconds]. eg. sleep 3.14"
+      #     return false
+      #   end
+      #   log_history_command(input)
+      #   Morpheus::Logging::DarkPrinter.puts "sleeping for #{sleep_sec}s ... zzzZzzzZ" if Morpheus::Logging.debug?
+      #   begin
+      #     sleep(sleep_sec)
+      #   rescue Interrupt
+      #     Morpheus::Logging::DarkPrinter.puts "\nInterrupt. waking up from sleep early"
+      #   end
+      #   return 0
       elsif input =~ /^history/
         n_commands = input.sub(/^history\s?/, '').sub(/\-n\s?/, '')
         n_commands = n_commands.empty? ? 25 : n_commands.to_i
@@ -374,28 +465,30 @@ class Morpheus::Cli::Shell
         log_history_command(input)
         return Morpheus::Cli::SourceCommand.new.handle(input.split[1..-1])
       end
-
+      cmd_result = nil
       begin
         argv = Shellwords.shellsplit(input)
         cmd_name = argv[0]
         cmd_args = argv[1..-1]
         if Morpheus::Cli::CliRegistry.has_command?(cmd_name) || Morpheus::Cli::CliRegistry.has_alias?(cmd_name)
           #log_history_command(input)
-          Morpheus::Cli::CliRegistry.exec(cmd_name, cmd_args)
+          cmd_result = Morpheus::Cli::CliRegistry.exec(cmd_name, cmd_args)
         else
           puts_error "#{Morpheus::Terminal.angry_prompt}'#{cmd_name}' is not a morpheus command. Use 'help' to see the list of available commands."
           @history_logger.warn "Unrecognized Command #{cmd_name}" if @history_logger
+          cmd_result = -1
         end
       rescue Interrupt
         # nothing to do
         @history_logger.warn "shell interrupt" if @history_logger
         print "\nInterrupt. aborting command '#{input}'\n"
-      rescue SystemExit
+      rescue SystemExit => cmdexit
         # nothing to do
         # print "\n"
+        cmd_result = cmdexit.status
       rescue => e
         @history_logger.error "#{e.message}" if @history_logger
-        Morpheus::Cli::ErrorHandler.new(my_terminal.stderr).handle_error(e) # lol
+        cmd_result = Morpheus::Cli::ErrorHandler.new(my_terminal.stderr).handle_error(e) # lol
         # exit 1
       end
 
@@ -404,7 +497,12 @@ class Morpheus::Cli::Shell
         ::RestClient.log = Morpheus::Logging.debug? ? Morpheus::Logging::DarkPrinter.instance : nil
         @return_to_log_level = nil
       end
-
+      
+      # commands should be a number or nil (treated as 0)
+      if cmd_result == true
+        cmd_result = 0
+      end
+      return cmd_result
     end
 
   end