morpheus-cli 3.6.21 → 3.6.22

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 789787ba7a4ccb2132d5bcc90b9a7d56201b16cfba7ea0033e853eeeb82745cb
-  data.tar.gz: '069c49c5ce79c069e5082fd6cbd18995f603a90e4be7562ddae2057ea9318d9a'
+  metadata.gz: ba216506570efee1b756a8b534dc529f006f9f8e939de8a1d4c4d549cd1a03c4
+  data.tar.gz: 127050886ebf02507861dfe55ca8e6c705e5404f15bc8c6c8cb25a17068f4589
 SHA512:
-  metadata.gz: 9b272c53c874322cdd53ab7b1fa75a53db2961149765bfc69682f9ea35eb4f342df69bb7b98d01d9caafb6ad2e4d7d6433ea5e5e22534a097ae2c5747bee3ece
-  data.tar.gz: 47e44158f0be09618e8c8285b691fb7a8d0d4aa50bd7452b020ba87259871ffd578172df8ba3dbb02a8f75eff62bde08ce8c6e40cdd06c654f8e389369d702ab
+  metadata.gz: 9b9c74b514d944013b7bf7b5086115377ef071fa3b04b27ba6edef9da036d3917c6c69224b53466a755d9df8d91e8a9f063e4a66d252d82055719928831355c2
+  data.tar.gz: a8523b27b0db023e3321763718a817d386741164bd04ee88fe8cd4213afd672cbf81440b1915252005fa3e2aa156dbb81b9168e47d21fa96e7151db7c8325ccb

data/lib/morpheus/benchmarking.rb

@@ -1,5 +1,6 @@
 require 'securerandom'
 require 'morpheus/logging'
+require 'morpheus/cli/cli_registry.rb'
 
 # Provides global Benchmarking functionality
 # This provides a store of benchmarking records which can be looked up by name.
@@ -124,25 +125,16 @@ module Morpheus::Benchmarking
         start_benchmark(opts)
         if block_given?
           result = block.call()
-          # exit_code, err = Morpheus::Cli.parse_command_result(result)
-          if result.is_a?(Array)
-            exit_code = result[0]
-            err = result[0]
-          elsif result == true || result == nil
-            exit_code = 0
-          elsif result == false
-            exit_code = 1
-          else
-            exit_code = result
-          end
+          exit_code, err = Morpheus::Cli::CliRegistry.parse_command_result(result)
         end
       rescue => ex
         raise ex
-        # exit_code = 1
-        # err = ex.msg
+        exit_code = 1
+        err = ex.msg
       ensure
         stop_benchmark(exit_code, err)
       end
+      #return result
       return exit_code, err
     end
 

data/lib/morpheus/cli.rb

@@ -25,6 +25,7 @@ module Morpheus
       end
     end
 
+    # check if this is a Windows environment.
     def self.windows?
       if defined?(@@is_windows)
         return @@is_windows
@@ -39,36 +40,6 @@ module Morpheus
       return @@is_windows
     end
 
-    def self.parse_command_result(cmd_result)
-      exit_code, err = nil, nil
-      if cmd_result.is_a?(Array)
-        exit_code, err = cmd_result[0], cmd_result[1]
-      elsif cmd_result.is_a?(Hash)
-        exit_code, err = cmd_result[:exit_code], (cmd_result[:error] || cmd_result[:err])
-      end
-      if cmd_result == nil || cmd_result == true
-        exit_code = 0
-      elsif cmd_result == false
-        exit_code = 1
-      elsif cmd_result.is_a?(Integer)
-        exit_code = cmd_result
-      elsif cmd_result.is_a?(Float)
-        exit_code = cmd_result.to_i
-      elsif cmd_result.is_a?(String)
-        exit_code = cmd_result.to_i
-      else
-        if cmd_result.respond_to?(:to_i)
-          exit_code = cmd_result.to_i
-        else
-          # happens for aliases right now.. and execution flow probably, need to handle Array
-          # uncomment to track them down, proceed with exit 0 for now
-          #Morpheus::Logging::DarkPrinter.puts "debug: command #{command_name} produced an unexpected result: (#{cmd_result.class}) #{cmd_result}" if Morpheus::Logging.debug?
-          exit_code = 0
-        end
-      end
-      return exit_code, err
-    end
-
     # load all the well known commands and utilties they need
     def self.load!()
       # load interfaces

data/lib/morpheus/cli/apps.rb

@@ -449,12 +449,6 @@ class Morpheus::Cli::Apps
               print_green_success "New app '#{payload['name']}' validation passed. #{json_response['msg']}".strip
             else
               print_red_alert "New app '#{payload['name']}' validation failed. #{json_response['msg']}".strip
-              # a default way to print errors
-              (json_response['errors'] || {}).each do |error_key, error_msg|
-                if error_key != 'instances'
-                  print_error red, " * #{error_key} : #{error_msg}", reset, "\n"
-                end
-              end
               # looks for special error format like instances.instanceErrors 
               if json_response['errors'] && json_response['errors']['instances']
                 json_response['errors']['instances'].each do |error_obj|
@@ -468,6 +462,13 @@ class Morpheus::Cli::Apps
                     end
                   end
                 end
+              else
+                # a default way to print errors
+                (json_response['errors'] || {}).each do |error_key, error_msg|
+                  if error_key != 'instances'
+                    print_error red, " * #{error_key} : #{error_msg}", reset, "\n"
+                  end
+                end
               end
             end
           end
@@ -511,7 +512,35 @@ class Morpheus::Cli::Apps
       end
       return 0
     rescue RestClient::Exception => e
-      print_rest_exception(e, options)
+      #print_rest_exception(e, options)
+      json_response = nil
+      begin
+        json_response = JSON.parse(e.response.to_s)
+      rescue TypeError, JSON::ParserError => ex
+        print_error red, "Failed to parse JSON response: #{ex}", reset, "\n"
+      end
+
+      # looks for special error format like instances.instanceErrors 
+      if json_response['errors'] && json_response['errors']['instances']
+        json_response['errors']['instances'].each do |error_obj|
+          tier_name = error_obj['tier']
+          instance_index = error_obj['index']
+          instance_errors = error_obj['instanceErrors']
+          print_error red, "#{tier_name} : #{instance_index}", reset, "\n"
+          if instance_errors
+            instance_errors.each do |err_key, err_msg|
+              print_error red, " * #{err_key} : #{err_msg}", reset, "\n"
+            end
+          end
+        end
+      else
+        # a default way to print errors
+        (json_response['errors'] || {}).each do |error_key, error_msg|
+          if error_key != 'instances'
+            print_error red, " * #{error_key} : #{error_msg}", reset, "\n"
+          end
+        end
+      end
       exit 1
     end
   end

data/lib/morpheus/cli/cli_command.rb

@@ -339,12 +339,20 @@ module Morpheus
             end
 
           when :list
-            opts.on( '-m', '--max MAX', "Max Results" ) do |max|
-              options[:max] = max.to_i
+            opts.on( '-m', '--max MAX', "Max Results" ) do |val|
+              max = val.to_i
+              if max <= 0
+                raise ::OptionParser::InvalidArgument.new("must be a positive integer")
+              end
+              options[:max] = max
             end
 
-            opts.on( '-o', '--offset OFFSET', "Offset Results" ) do |offset|
-              options[:offset] = offset.to_i.abs
+            opts.on( '-o', '--offset OFFSET', "Offset Results" ) do |val|
+              offset = val.to_i
+              if offset <= 0
+                raise ::OptionParser::InvalidArgument.new("must be a positive integer")
+              end
+              options[:offset] = offset
             end
 
             opts.on( '-s', '--search PHRASE', "Search Phrase" ) do |phrase|
@@ -719,7 +727,8 @@ module Morpheus
         cmd_method = subcommands[subcommand_name]
         if !cmd_method
           print_error Morpheus::Terminal.angry_prompt
-          puts_error "'#{subcommand_name}' is not recognized. See '#{my_help_command}'"
+          #puts_error "'#{subcommand_name}' is not recognized. See '#{my_help_command}'"
+          puts_error "'#{subcommand_name}' is not recognized.\n#{full_command_usage}"
           return 127
         end
         self.send(cmd_method, args[1..-1])

data/lib/morpheus/cli/cli_registry.rb

@@ -1,5 +1,10 @@
 require 'term/ansicolor'
+require 'shellwords'
 require 'morpheus/logging'
+require 'morpheus/cli/command_error'
+require 'morpheus/cli/error_handler'
+require 'morpheus/cli/expression_parser'
+
 module Morpheus
   module Cli
     class CliRegistry
@@ -57,8 +62,6 @@ module Morpheus
 
       class << self
         include Term::ANSIColor
-        
-        ALIAS_SPLIT_REGEX=/(\;)(?=(?:[^"']|"[^'"]*")*$)/
 
         def instance
           @instance ||= CliRegistry.new
@@ -72,43 +75,97 @@ module Morpheus
         def exec_command(command_name, args)
           #puts "exec_command(#{command_name}, #{args})"
           found_alias_command = instance.get_alias(command_name)
-          if found_alias_command
+          if has_alias?(command_name)
             exec_alias(command_name, args)
-          else
-            #puts "running regular command #{command_name} with arguments #{args.join(' ')}"
+          elsif has_command?(command_name)
             instance.get(command_name).new.handle(args)
+          else
+            raise Morpheus::Cli::CommandError.new("'#{command_name}' is not a command. See 'morpheus --help'.")
           end
         end
 
         def exec_alias(alias_name, args)
-          #puts "exec_alias(#{alias_name}, #{args})"
           found_alias_command = instance.get_alias(alias_name)
-          # support aliases of multiple commands, semicolon delimiter
-          # todo: 
-          all_commands = found_alias_command.gsub(ALIAS_SPLIT_REGEX, '__ALIAS_SPLIT_REGEX__').split('__ALIAS_SPLIT_REGEX__').collect {|it| it.to_s.strip }.select {|it| !it.empty?  }.compact
-          Morpheus::Logging::DarkPrinter.puts "executing alias #{alias_name} as #{all_commands.join('; ')}" if Morpheus::Logging.debug?
-          all_commands.each do |a_command_string|
-            alias_args = a_command_string.to_s.split(/\s+/) # or just ' '
-            command_name = alias_args.shift
-            command_args = alias_args + args
-            if command_name == alias_name
-              # needs to be better than this
-              print Term::ANSIColor.red,"alias '#{alias_name}' is calling itself? '#{found_alias_command}'", Term::ANSIColor.reset, "\n"
-              exit 1
+          if !found_alias_command
+            raise Morpheus::Cli::CommandError.new("'#{alias_name}' is not a defined alias.")
+          end
+          # if !is_valid_expression(found_alias_command)
+          #   raise Morpheus::Cli::CommandError.new("alias '#{alias_name}' is not a valid expression: #{found_alias_command}")
+          # end
+          input = found_alias_command
+          if args && !args.empty?
+            input = "#{found_alias_command} " + args.collect {|arg| arg.include?(" ") ? "\"#{arg}\"" : "#{arg}" }.join(" ")
+          end
+          exec_expression(input)
+        end
+
+        def exec_expression(input)
+          # puts "exec_expression(#{input})"
+          flow = input
+          if input.is_a?(String)
+            begin
+              flow = Morpheus::Cli::ExpressionParser.parse(input)
+            rescue Morpheus::Cli::ExpressionParser::InvalidExpression => e
+              raise e
             end
-            # this allows aliases to use other aliases
-            # todo: prevent recursion infinite loop
-            if has_alias?(command_name)
-              exec_alias(command_name, command_args)
-            elsif has_command?(command_name)
-              #puts "executing alias #{found_alias_command} as #{command_name} with args #{args.join(' ')}"
-              instance.get(command_name).new.handle(alias_args + args)
+          end
+          # puts "executing flow: #{flow.inspect}"
+          final_command_result = nil
+          if flow.size == 0
+            # no input eh?
+          else
+            last_command_result = nil
+            if ['&&','||', '|'].include?(flow.first)
+              raise Morpheus::Cli::ExpressionParser::InvalidExpression.new "#{Morpheus::Terminal.angry_prompt}invalid command format, begins with an operator: #{input}"
+            elsif ['&&','||', '|'].include?(flow.last)
+              raise Morpheus::Cli::ExpressionParser::InvalidExpression.new "#{Morpheus::Terminal.angry_prompt}invalid command format, ends with an operator: #{input}"
+            # elsif ['&&','||', '|'].include?(flow.last)
+            #   raise Morpheus::Cli::ExpressionParser::InvalidExpression.new "invalid command format, consecutive operators: #{cmd}"
             else
-              # raise UnrecognizedCommandError.new(command_name)
-              print Term::ANSIColor.red,"alias '#{alias_name}' uses and unknown command: '#{command_name}'", Term::ANSIColor.reset, "\n"
-              exit 1
+              #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
+                    exit_code, cmd_err = parse_command_result(previous_command_result)
+                    if exit_code != 0
+                      still_executing = false
+                    end
+                  elsif flow_cmd == '||' # or with previous command
+                    current_operator = flow_cmd
+                    exit_code, err = parse_command_result(previous_command_result)
+                    if exit_code == 0
+                      still_executing = false
+                    end
+                  elsif flow_cmd == '|' # or with previous command
+                    raise Morpheus::Cli::ExpressionParser::InvalidExpression.new "The PIPE (|) operator is not yet supported =["
+                    previous_command_result = nil
+                    still_executing = false
+                    # or just continue?
+                  elsif flow_cmd.is_a?(Array)
+                    # this is a subexpression, execute it as such
+                    current_operator = nil
+                    previous_command_result = exec_expression(flow_cmd)
+                  else # it's a command, not an operator
+                    current_operator = nil
+                    flow_argv = Shellwords.shellsplit(flow_cmd)
+                    previous_command_result = exec_command(flow_argv[0], flow_argv[1..-1])
+                  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
           end
+          return final_command_result
         end
 
         def add(klass, command_name=nil)
@@ -166,6 +223,42 @@ module Morpheus
           return alias_name, command_string
         end
 
+        # parse any object into a command result [exit_code, error]
+        # 0 means success.
+        # This treats nil, true, or an object success.
+        # 0 or
+        # @return [Array] exit_code, error. Success returns [0, nil].
+        def parse_command_result(cmd_result)
+          exit_code, err = nil, nil
+          if cmd_result.is_a?(Array)
+            exit_code = cmd_result[0] || 0
+            err = cmd_result[1]
+          elsif cmd_result.is_a?(Hash)
+            exit_code = cmd_result[:exit_code] || 0
+            err = cmd_result[:error] || cmd_result[:err]
+          elsif cmd_result == nil || cmd_result == true
+            exit_code = 0
+          elsif cmd_result == false
+            exit_code = 1
+          elsif cmd_result.is_a?(Integer)
+            exit_code = cmd_result
+          elsif cmd_result.is_a?(Float)
+            exit_code = cmd_result.to_i
+          elsif cmd_result.is_a?(String)
+            exit_code = cmd_result.to_i
+          else
+            if cmd_result.respond_to?(:to_i)
+              exit_code = cmd_result.to_i
+            else
+              # happens for aliases right now.. and execution flow probably, need to handle Array
+              # uncomment to track them down, proceed with exit 0 for now
+              #Morpheus::Logging::DarkPrinter.puts "debug: command #{command_name} produced an unexpected result: (#{cmd_result.class}) #{cmd_result}" if Morpheus::Logging.debug?
+              exit_code = 0
+            end
+          end
+          return exit_code, err
+        end
+
       end
 
     end

data/lib/morpheus/cli/commands/standard/benchmark_command.rb

@@ -1,6 +1,7 @@
 require 'morpheus/logging'
 require 'morpheus/benchmarking'
 require 'morpheus/cli/cli_command'
+require 'morpheus/cli/cli_registry'
 
 class Morpheus::Cli::BenchmarkCommand
   include Morpheus::Cli::CliCommand
@@ -293,10 +294,16 @@ EOT
   end
 
   def execute(args)
+    n = 1
     benchmark_name = nil
     options = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[command...]")
+      opts.on('-n', '--iterations NUMBER', Integer, "Number of iterations to run. The default is 1.") do |val|
+        if val.to_i > 1
+          n = val.to_i
+        end
+      end
       opts.on('--name NAME', String, "Name for the benchmark. Default is the command itself.") do |val|
         benchmark_name = val
       end
@@ -315,97 +322,88 @@ EOT
     end
     
     cmd = args.join(' ')
+    benchmark_name ||= cmd
+    if n == 1
+      start_benchmark(benchmark_name)
+      # exit_code, err = my_terminal.execute(cmd)
+      cmd_result = Morpheus::Cli::CliRegistry.exec_expression(cmd)
+      exit_code, err = Morpheus::Cli::CliRegistry.parse_command_result(cmd_result)
+      benchmark_record = stop_benchmark(exit_code, err)
+      Morpheus::Logging::DarkPrinter.puts(cyan + dark + benchmark_record.msg) if benchmark_record
+    else
+      benchmark_records = []
+      n.times do |iteration_index|
+        start_benchmark(benchmark_name)
+        # exit_code, err = my_terminal.execute(cmd)
+        cmd_result = Morpheus::Cli::CliRegistry.exec_expression(cmd)
+        exit_code, err = Morpheus::Cli::CliRegistry.parse_command_result(cmd_result)
+        benchmark_record = stop_benchmark(exit_code, err)
+        Morpheus::Logging::DarkPrinter.puts(cyan + dark + benchmark_record.msg) if Morpheus::Logging.debug?
+        benchmark_records << benchmark_record
+      end
+      # calc total and mean and print it
+      # all_durations = benchmark_records.collect {|benchmark_record| benchmark_record.duration }
+      # total_duration = all_durations.inject(0.0) {|acc, i| acc + i }
+      # avg_duration = total_duration / all_durations.size
+      # total_time_str = "#{total_duration.round((total_duration > 0.002) ? 3 : 6)}s"
+      # avg_time_str = "#{avg_duration.round((total_duration > 0.002) ? 3 : 6)}s"
 
-    #previous_terminal_benchmarking = my_terminal.benchmarking
-    start_benchmark(benchmark_name || cmd)
-    
-    # exit_code, err = my_terminal.execute(cmd)
-    # do this way until terminal supports expressions
-    cmd_result = execute_commands_as_expression(cmd)
-    exit_code, err = Morpheus::Cli.parse_command_result(cmd_result)
-  
-    benchmark_record = stop_benchmark(exit_code, err)
-    Morpheus::Logging::DarkPrinter.puts(cyan + dark + benchmark_record.msg) if benchmark_record
-    
-    #my_terminal.benchmarking = previous_terminal_benchmarking
-    return 0 
-  end
+      all_durations = []
+      stats = {total: 0, avg: nil, min: nil, max: nil}
+      benchmark_records.each do |benchmark_record| 
+        duration = benchmark_record.duration
+        if duration
+          all_durations << duration
+          stats[:total] += duration
+          if stats[:min].nil? || stats[:min] > duration
+            stats[:min] = duration
+          end
+          if stats[:max].nil? || stats[:max] < duration
+            stats[:max] = duration
+          end
+        end
+      end
+      if all_durations.size > 0
+        stats[:avg] = stats[:total].to_f / all_durations.size
+      end
 
-  protected
+      total_time_str = "#{stats[:total].round((stats[:total] > 0.002) ? 3 : 6)}s"
+      min_time_str = stats[:min] ? "#{stats[:min].round((stats[:min] > 0.002) ? 3 : 6)}s" : ""
+      max_time_str = stats[:max] ? "#{stats[:max].round((stats[:max] > 0.002) ? 3 : 6)}s" : ""
+      avg_time_str = stats[:avg] ? "#{stats[:avg].round((stats[:avg] > 0.002) ? 3 : 6)}s" : ""
 
-  # copied these over from shell, consolidate to terminal plz
+      out = ""
+      # <benchmark name or command>
+      out << "#{benchmark_name.ljust(30, ' ')}"
+      # exit: 0
+      exit_str = "0"
+      bad_benchmark = benchmark_records.find {|benchmark_record| benchmark_record.exit_code && benchmark_record.exit_code != 0 }
+      if bad_benchmark
+        bad_benchmark.exit_code.to_s
+        out << "\texit: #{bad_benchmark.exit_code.to_s.ljust(2, ' ')}"
+        out << "\terror: #{bad_benchmark.error.to_s.ljust(12, ' ')}"
+      else
+        out << "\texit: 0 "
+      end
 
-  def execute_command(cmd)
-    my_terminal.execute(cmd)
-  end
+      out << "\tn: #{n.to_s.ljust(4, ' ')}"
+      out << "\ttotal: #{total_time_str.ljust(9, ' ')}"
+      out << "\tmin: #{min_time_str.ljust(9, ' ')}"
+      out << "\tmax: #{max_time_str.ljust(9, ' ')}"
+      out << "\tavg: #{avg_time_str.ljust(9, ' ')}"
 
-  def execute_commands_as_expression(input)
-    flow = input
-    if input.is_a?(String)
-      begin
-        flow = Morpheus::Cli::ExpressionParser.parse(input)
-      rescue Morpheus::Cli::ExpressionParser::InvalidExpression => e
-        @history_logger.error "#{e.message}" if @history_logger
-        return Morpheus::Cli::ErrorHandler.new(my_terminal.stderr).handle_error(e) # lol
-      end
-    end
-    final_command_result = nil
-    if flow.size == 0
-      # no input eh?
-    else
-      last_command_result = nil
-      if ['&&','||', '|'].include?(flow.first)
-        puts_error "#{Morpheus::Terminal.angry_prompt}invalid command format, begins with an operator: #{input}"
-        return 99
-      elsif ['&&','||', '|'].include?(flow.last)
-        puts_error "#{Morpheus::Terminal.angry_prompt}invalid command format, ends with an operator: #{input}"
-        return 99
-      # elsif ['&&','||', '|'].include?(flow.last)
-      #   puts_error "invalid command format, consecutive operators: #{cmd}"
+
+      if bad_benchmark
+        print red,out,reset,"\n"
+        return 1
       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
-              exit_code, cmd_err = Morpheus::Cli.parse_command_result(previous_command_result)
-              if exit_code != 0
-                still_executing = false
-              end
-            elsif flow_cmd == '||' # or with previous command
-              current_operator = flow_cmd
-              exit_code, err = Morpheus::Cli.parse_command_result(previous_command_result)
-              if exit_code == 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?
-            elsif flow_cmd.is_a?(Array)
-              # this is a subexpression, execute it as such
-              current_operator = nil
-              previous_command_result = execute_commands_as_expression(flow_cmd)
-            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
+        print cyan,out,reset,"\n"
+        return 0
       end
+      
     end
-    return final_command_result
+
+    return 0 
   end
 
 end

data/lib/morpheus/cli/containers_command.rb

@@ -122,7 +122,7 @@ class Morpheus::Cli::ContainersCommand
       if options[:include_available_actions]
         if (container["availableActions"])
           print_h2 "Available Actions"
-          print as_pretty_table(container["availableActions"], [:id, :name])
+          print as_pretty_table(container["availableActions"], [:name, :code])
           print reset, "\n"
         else
           print "#{yellow}No available actions#{reset}\n\n"

data/lib/morpheus/cli/dot_file.rb

@@ -53,53 +53,28 @@ class Morpheus::Cli::DotFile
       next if line.empty?
       next if line =~ /^\#/ # skip comments
       
-      # print "#{dark} #=> executing source file line #{line_num}: #{line}#{reset}\n" if Morpheus::Logging.debug?
-
-      # allow semicolons inside arguments too..
-      #command_list = line.strip.split(';').compact
-      command_list = line.split(/(;)(?=(?:[^"']|["|'][^"']*")*$)/).reject {|it| it.to_s.strip.empty? || it.to_s.strip == ";" }
-      command_list.each do |input|
-        input = input.strip
-        if input.empty?
-          next
-        end
-        argv = nil
-        begin
-          argv = Shellwords.shellsplit(input)
-        rescue => err
-          cmd_result = false
-          puts "#{red} Unparsable source file: #{@filename} line: #{line_num} '#{input}' #{reset} - #{err}"
-        end
-        if argv[0] && Morpheus::Cli::CliRegistry.has_command?(argv[0]) || Morpheus::Cli::CliRegistry.has_alias?(argv[0])
-          #log_history_command(input)
-          cmd_result = nil
-          begin
-            cmd_result = Morpheus::Cli::CliRegistry.exec(argv[0], argv[1..-1])
-          rescue SystemExit => err
-            if err.success?
-              cmd_result = true
-            else
-              puts "#{red} source file: #{@filename} line: #{line_num} command: #{argv[0]}#{reset} error: exited non zero - #{err}"
-              cmd_result = false
-            end
-          rescue => err
-            # raise err
-            puts "#{red} source file: #{@filename} line: #{line_num} command: #{argv[0]}#{reset} error: unexpected error - #{err}"
-            cmd_result = false
-          end
-          cmd_results << cmd_result
-          # next command please!
+      cmd_exit_code = 0
+      cmd_err = nil
+      cmd_result = nil
+      begin
+        cmd_result = Morpheus::Cli::CliRegistry.exec_expression(line)
+      rescue SystemExit => err
+        if err.success?
+          cmd_result = true
         else
-          puts "#{red}Unrecognized source command file: #{@filename} line: #{line_num} command: #{argv[0]}#{reset}"
+          puts "#{red} source file: #{@filename} line: #{line_num} command: #{line}#{reset} error: exited non zero - #{err}"
           cmd_result = false
         end
-        if cmd_result == false
-          if stop_on_failure
-            return cmd_results
-          end
+      rescue => err
+        # raise err
+        puts "#{red} source file: #{@filename} line: #{line_num} command: #{line}#{reset} error: unexpected error - #{err}"
+        cmd_result = false
+      end
+      if cmd_result == false
+        if stop_on_failure
+          return cmd_results
         end
       end
-
     end
     return cmd_results
   end
@@ -130,6 +105,8 @@ class Morpheus::Cli::DotFile
     new_config_lines = []
     existing_alias_definitions = {}
     header_line_index = config_lines.index {|line| line.strip.include?(EXPORTED_ALIASES_HEADER) }
+    # JD: there's some bad bug here where it can clear all your aliases!
+    # it would be safer to export to another file at .morpheus/aliases or something.
     if header_line_index
       # keep everything before the exported alias section
       new_config_lines = config_lines[0..header_line_index-1]

data/lib/morpheus/cli/hosts.rb

@@ -392,8 +392,14 @@ class Morpheus::Cli::Hosts
         end
         return
       end
-      server = find_host_by_name_or_id(arg)
-      json_response = @servers_interface.get(server['id'])
+      json_response = nil
+      if arg.to_s =~ /\A\d{1,}\Z/
+        json_response = @servers_interface.get(arg.to_i)
+      else
+        server = find_host_by_name_or_id(arg)
+        json_response = @servers_interface.get(server['id'])
+        # json_response = {"server" => server} need stats
+      end
       if options[:json]
         json_response.delete('stats') if options[:include_fields]
         puts as_json(json_response, options, "server")

data/lib/morpheus/cli/instances.rb

@@ -70,6 +70,9 @@ class Morpheus::Cli::Instances
     end
     optparse.parse!(args)
     connect(options)
+    if args.count != 0
+      raise_command_error "wrong number of arguments, expected 0 and got (#{args.count}) #{args}\n#{optparse}"
+    end
     begin
       params = {}
       params.merge!(parse_list_options(options))
@@ -811,9 +814,11 @@ class Morpheus::Cli::Instances
       opts.on( nil, '--nodes', "Alias for --containers" ) do
         options[:include_containers] = true
       end
+      # opts.add_hidden_option('--nodes')
       opts.on( nil, '--vms', "Alias for --containers" ) do
         options[:include_containers] = true
       end
+      # opts.add_hidden_option('--vms')
       opts.on( nil, '--scaling', "Display Instance Scaling Settings" ) do
         options[:include_scaling] = true
       end

data/lib/morpheus/cli/shell.rb

@@ -6,6 +6,7 @@ require "shellwords"
 require 'readline'
 require 'logger'
 require 'fileutils'
+require 'morpheus/cli/cli_registry'
 require 'morpheus/cli/cli_command'
 require 'morpheus/cli/error_handler'
 require 'morpheus/cli/expression_parser'
@@ -117,7 +118,7 @@ class Morpheus::Cli::Shell
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = usage
       # change to a temporary home directory, delete it afterwards.
-      opts.on('-e','--exec COMMAND', "Execute the provided morpheus commands and exit.") do |val|
+      opts.on('-e','--exec EXPRESSION', "Execute the command(s) expression and exit.") do |val|
         @execute_mode = true
         @execute_mode_command = val
       end
@@ -249,80 +250,6 @@ class Morpheus::Cli::Shell
     unless input.strip.empty? || input.strip[0] == "!"
       log_history_command(input.strip)
     end
-    result = execute_commands_as_expression(input)
-    return result
-  end
-
-  def execute_commands_as_expression(input)
-    flow = input
-    if input.is_a?(String)
-      begin
-        flow = Morpheus::Cli::ExpressionParser.parse(input)
-      rescue Morpheus::Cli::ExpressionParser::InvalidExpression => e
-        @history_logger.error "#{e.message}" if @history_logger
-        return Morpheus::Cli::ErrorHandler.new(my_terminal.stderr).handle_error(e) # lol
-      end
-    end
-    final_command_result = nil
-    if flow.size == 0
-      # no input eh?
-    else
-      last_command_result = nil
-      if ['&&','||', '|'].include?(flow.first)
-        puts_error "#{Morpheus::Terminal.angry_prompt}invalid command format, begins with an operator: #{input}"
-        return 99
-      elsif ['&&','||', '|'].include?(flow.last)
-        puts_error "#{Morpheus::Terminal.angry_prompt}invalid command format, ends with an operator: #{input}"
-        return 99
-      # 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
-              exit_code, cmd_err = Morpheus::Cli.parse_command_result(previous_command_result)
-              if exit_code != 0
-                still_executing = false
-              end
-            elsif flow_cmd == '||' # or with previous command
-              current_operator = flow_cmd
-              exit_code, err = Morpheus::Cli.parse_command_result(previous_command_result)
-              if exit_code == 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?
-            elsif flow_cmd.is_a?(Array)
-              # this is a subexpression, execute it as such
-              current_operator = nil
-              previous_command_result = execute_commands_as_expression(flow_cmd)
-            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
-    end
-    return final_command_result
-  end
-
-  def execute_command(input)
 
     #Morpheus::Logging::DarkPrinter.puts "Shell command: #{input}"
     input = input.to_s.strip
@@ -525,7 +452,7 @@ class Morpheus::Cli::Shell
         @return_to_coloring = ["coloring"].include?(cmd_name) ? nil : Term::ANSIColor::coloring?
         @return_to_benchmarking = ["benchmark"].include?(cmd_name) ? nil : Morpheus::Benchmarking.enabled?
         
-        if Morpheus::Cli::CliRegistry.has_command?(cmd_name) || Morpheus::Cli::CliRegistry.has_alias?(cmd_name)
+        #if Morpheus::Cli::CliRegistry.has_command?(cmd_name) || Morpheus::Cli::CliRegistry.has_alias?(cmd_name)
           #log_history_command(input)
           # start a benchmark, unless the command is benchmark of course
           if my_terminal.benchmarking || cmd_args.include?("-B") || cmd_args.include?("--benchmark")
@@ -535,15 +462,16 @@ class Morpheus::Cli::Shell
               start_benchmark(benchmark_name)
             end
           end
-          cmd_result = Morpheus::Cli::CliRegistry.exec(cmd_name, cmd_args)
-          cmd_exit_code, cmd_err = Morpheus::Cli.parse_command_result(cmd_result)
+          cmd_exit_code, cmd_err = Morpheus::Cli::CliRegistry.exec_expression(input)
+          #cmd_result = Morpheus::Cli::CliRegistry.exec(cmd_name, cmd_args)
+          #cmd_exit_code, cmd_err = Morpheus::Cli::CliRegistry.parse_command_result(cmd_result)
           benchmark_record = stop_benchmark(cmd_exit_code, cmd_err) # if benchmarking?
           Morpheus::Logging::DarkPrinter.puts(cyan + dark + benchmark_record.msg) if benchmark_record
-        else
-          puts_error "#{Morpheus::Terminal.angry_prompt}'#{cmd_name}' is not recognized. Use 'help' to see the list of available commands."
-          @history_logger.warn "Unrecognized Command #{cmd_name}" if @history_logger
-          cmd_result = -1
-        end
+        # else
+        #   puts_error "#{Morpheus::Terminal.angry_prompt}'#{cmd_name}' is not recognized. 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
@@ -795,6 +723,8 @@ class Morpheus::Cli::Shell
           print_results_pagination({:meta => history_result[:meta]}, {:message =>"Viewing most recent %{size} of %{total} %{label}"})
         end
         print reset, "\n"
+      else
+        print reset
       end
     end
     #print "\n"

data/lib/morpheus/cli/version.rb

@@ -1,6 +1,6 @@
 
 module Morpheus
   module Cli
-    VERSION = "3.6.21"
+    VERSION = "3.6.22"
   end
 end

data/lib/morpheus/terminal.rb

@@ -6,6 +6,7 @@ require 'morpheus/rest_client'
 require 'morpheus/cli/cli_registry'
 require 'morpheus/cli/dot_file'
 require 'morpheus/cli/error_handler'
+require 'morpheus/cli/expression_parser'
 require 'morpheus/logging'
 require 'morpheus/benchmarking'
 require 'morpheus/cli'
@@ -48,7 +49,7 @@ module Morpheus
     end
 
     # DEFAULT_TERMINAL_WIDTH = 80
-    
+
     def self.default_color
       Term::ANSIColor.cyan
     end
@@ -216,9 +217,9 @@ module Morpheus
       # maybe OptionParser's recover() instance method will do the trick
       optparse = Morpheus::Cli::OptionParser.new do|opts|
         opts.banner = "Options:" # hack alert
-        opts.on('-v','--version', "Print the version.") do
-          @stdout.puts Morpheus::Cli::VERSION
-          # exit
+        opts.on('-e','--exec EXPRESSION', "Execute the command(s) expression. This is an alternative to passing [command] [options]") do |val|
+          @execute_mode = true
+          @execute_mode_command = val
         end
         opts.on('--noprofile','--noprofile', "Do not read and execute the personal initialization script .morpheus_profile") do
           @noprofile = true
@@ -236,6 +237,10 @@ module Morpheus
           Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
           ::RestClient.log = Morpheus::Logging.debug? ? Morpheus::Logging::DarkPrinter.instance : nil
         end
+        opts.on('-v','--version', "Print the version.") do
+          @stdout.puts Morpheus::Cli::VERSION
+          # exit
+        end
         opts.on( '-h', '--help', "Print this help" ) do
           @stdout.puts opts
           # exit
@@ -317,7 +322,6 @@ module Morpheus
         end
       end
       
-
       # process global options
 
       # raise log level right away
@@ -336,7 +340,7 @@ module Morpheus
       # ok, execute the command (or alias)
       result = nil
       begin
-      
+        
         # execute startup script .morpheus_profile  unless --noprofile is passed
         # todo: this should happen in initialize..
         noprofile = false
@@ -351,38 +355,69 @@ module Morpheus
           end
         end
 
-        # not enough arguments?
-        if args.count == 0
-          @stderr.puts "#{@angry_prompt}[command] argument is required."
-          #@stderr.puts "No command given, here's some help:"
-          @stderr.print usage
-          return 2, nil # CommandError.new("morpheus requires a command")
-        end
-        
-        cmd_name = args[0]
-        cmd_args = args[1..-1]
-
-        # unknown command?
-        # all commands should be registered commands or aliases
-        if !(Morpheus::Cli::CliRegistry.has_command?(cmd_name) || Morpheus::Cli::CliRegistry.has_alias?(cmd_name))
-          @stderr.puts "#{@angry_prompt}'#{cmd_name}' is not recognized. See 'morpheus --help'."
-          #@stderr.puts usage
-          return 127, nil
-        end
-        
-        if @benchmarking || args.include?('-B') || args.include?('--benchmark')
-          benchmark_name = "morpheus " + args.reject {|it| it == '-B' || it == '--benchmark' }.join(' ')
-          #benchmark_name = args.reject {|it| it == '-B' || it == '--benchmark' }.join(' ')
-          start_benchmark(benchmark_name)
+        # execute startup script .morpheus_profile  unless --noprofile is passed
+        # todo: this should happen in initialize..
+        @execute_mode = false
+        @execute_mode_command = nil
+        args.size.times do |i|
+          if args[i] == '-e' || args[i] == '--exec'
+            @execute_mode = true
+            # delete switch and value (command)
+            deleted_option = args.delete_at(i)
+            @execute_mode_command = args.delete_at(i)
+            if @execute_mode_command.nil?
+              raise ::OptionParser::MissingArgument.new(deleted_option)
+              #@stderr.puts "#{@angry_prompt}missing argument: #{deleted_option}."
+              #@stderr.puts "No command given, here's some help:"
+              #@stderr.print usage
+              return 1
+            end
+            break
+          end
         end
 
-        # shell is a Singleton command class
-        if args[0] == "shell"
-          result = Morpheus::Cli::Shell.instance.handle(args[1..-1])
+        if @execute_mode_command
+          # execute a single command and exit
+          result = Morpheus::Cli::CliRegistry.exec_expression(@execute_mode_command)
+          @execute_mode_command = nil
         else
-          result = Morpheus::Cli::CliRegistry.exec(args[0], args[1..-1])
+          # not enough arguments?
+          if args.count == 0
+            @stderr.puts "#{@angry_prompt}[command] argument is required."
+            #@stderr.puts "No command given, here's some help:"
+            @stderr.print usage
+            return 1, nil # CommandError.new("morpheus requires a command")
+          end
+          
+          cmd_name, *cmd_args = args
+
+          formatted_cmd = args.collect {|arg| arg.include?(' ') ? "\"#{arg}\"" : "#{arg}" }.join(" ")
+
+          # unknown command?
+          # all commands should be registered commands or aliases
+          # ahh, but it could support expressions (), use -e for that ..
+          # if !(Morpheus::Cli::CliRegistry.has_command?(cmd_name) || Morpheus::Cli::CliRegistry.has_alias?(cmd_name))
+          #   @stderr.puts "#{@angry_prompt}'#{cmd_name}' is not recognized. See 'morpheus --help'."
+          #   #@stderr.puts usage
+          #   return 127, nil
+          # end
+
+          if @benchmarking || args.include?('-B') || args.include?('--benchmark')
+            benchmark_name = "morpheus #{formatted_cmd}"
+            benchmark_name.sub!(' -B', '')
+            benchmark_name.sub!(' --benchmark', '')
+            start_benchmark(benchmark_name)
+          end
+
+          # shell is a Singleton command class
+          if args[0] == "shell"
+            result = Morpheus::Cli::Shell.instance.handle(args[1..-1])
+          else
+            #result = Morpheus::Cli::CliRegistry.exec_expression(formatted_cmd)
+            result = Morpheus::Cli::CliRegistry.exec(args[0], args[1..-1])
+          end
         end
-        exit_code, err = Morpheus::Cli.parse_command_result(result)
+        exit_code, err = Morpheus::Cli::CliRegistry.parse_command_result(result)
       rescue => e
         exit_code = Morpheus::Cli::ErrorHandler.new(@stderr).handle_error(e)
         err = e

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: morpheus-cli
 version: !ruby/object:Gem::Version
-  version: 3.6.21
+  version: 3.6.22
 platform: ruby
 authors:
 - David Estes
@@ -11,7 +11,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-03-01 00:00:00.000000000 Z
+date: 2019-03-05 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler