morpheus-cli 3.3.2.5 → 3.3.2.6

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 43f88e813f909c4b50f7b18219e0a3a4b298cc44
-  data.tar.gz: c5f23f5767cb4d60bae998e21f82abf78d452239
+  metadata.gz: a3638fa392f4c3276cb8f7dcfcde61cde875325a
+  data.tar.gz: 00c82492c99d9cedd9b0c9920bdace3d7ed8ed3c
 SHA512:
-  metadata.gz: a012937d6dc02d54e8b204b34b1ae98297017c66c70df6c114be7ccd98e49282202ca379ad7b6c2e4efa677a051dfe4a3fbd62d744d19e38ff5ed385b365f479
-  data.tar.gz: ca965fcec4b654400a983975e6905275f12c2ef973932d0ec1ce76bb9126868f4970f3beac3a503c369c735746cf80c154e18ef7bb6ef1f0b06d33b6d6b90e69
+  metadata.gz: a45a54a113a42d63ad41177a236ab9e5997937b29553464b0f607d7d8a7b5fc990b724901432b028d227ddf15de0a3d32f4f833a2f1b36c398d6f44f8395541c
+  data.tar.gz: 59710c0c7075f01223d6a02f4594af4978860c8cf390cb850f8d63eb2c800c5d9ab5d646e1895de30bdbec33c7b3010ea6ea5990fb42e7ee7fa202ebf22d81d7

data/lib/morpheus/cli.rb

@@ -53,6 +53,7 @@ module Morpheus
 
       # utilites
       require 'morpheus/cli/cli_registry.rb'
+      require 'morpheus/cli/expression_parser.rb'
       require 'morpheus/cli/dot_file.rb'
       require 'morpheus/cli/command_error'
 
@@ -60,6 +61,9 @@ module Morpheus
       load 'morpheus/cli/option_types.rb'
       load 'morpheus/cli/credentials.rb'
       
+      # all standard commands
+      Dir[File.dirname(__FILE__)  + "/cli/commands/standard/**/*.rb"].each {|file| load file }
+
       # shell scripting commands
       load 'morpheus/cli/source_command.rb'
       load 'morpheus/cli/echo_command.rb'

data/lib/morpheus/cli/clouds.rb

@@ -177,8 +177,15 @@ class Morpheus::Cli::Clouds
         server_counts = json_response['serverCounts'] # legacy
       end
       if options[:json]
-        print JSON.pretty_generate(json_response), "\n"
-        return
+        puts as_json(json_response, options, 'zone')
+        return 0
+      elsif options[:yaml]
+        puts as_yaml(json_response, options, 'zone')
+        return 0
+      end
+      if options[:csv]
+        puts records_as_csv([json_response['zone']], options)
+        return 0
       end
       cloud_type = cloud_type_for_id(cloud['zoneTypeId'])
       print_h1 "Cloud Details"

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

@@ -0,0 +1,36 @@
+require 'morpheus/cli/cli_command'
+require 'term/ansicolor'
+require 'json'
+
+# Utility command for exiting a shell
+class Morpheus::Cli::ExitCommand
+  include Morpheus::Cli::CliCommand
+  
+  set_command_name :'exit'
+  
+  set_command_hidden
+
+  def handle(args)
+    exit_code = 0
+    options = {}
+    filename = Morpheus::Cli::DotFile.morpheus_profile_filename
+    optparse = Morpheus::Cli::OptionParser.new do|opts|
+      opts.banner = "Usage: exit [code]"
+      build_common_options(opts, options, [])
+      opts.footer = "Exit morpheus . Default is 0"
+    end
+    optparse.parse!(args)
+    
+    if args[0]
+      exit_code = args[0].to_i
+    end
+
+    if options[:debug]
+      puts "#{dark}exit #{exit_code}#{reset}"
+    end
+
+    exit exit_code
+
+  end
+
+end

data/lib/morpheus/cli/error_handler.rb

@@ -5,6 +5,7 @@ require 'rest_client'
 require 'net/https'
 require 'morpheus/logging'
 require 'morpheus/cli/command_error'
+require 'morpheus/cli/expression_parser'
 
 class Morpheus::Cli::ErrorHandler
   include Term::ANSIColor
@@ -35,6 +36,11 @@ class Morpheus::Cli::ErrorHandler
       puts_angry_error err.message
       do_print_stacktrace = false
       # @stderr.puts "Try -h for help with this command."
+    when Morpheus::Cli::ExpressionParser::InvalidExpression
+      # @stderr.puts "#{red}#{err.message}#{reset}"
+      puts_angry_error err.message
+      do_print_stacktrace = false
+      exit_code = 99
     when SocketError
       @stderr.puts "#{red}Error Communicating with the Appliance.#{reset}"
       @stderr.puts "#{red}#{err.message}#{reset}"

data/lib/morpheus/cli/expression_parser.rb

@@ -0,0 +1,149 @@
+require 'shellwords'
+
+# Provides parsing of user input into an Array of expressions for execution
+# Syntax currently supports the && and || operators, and the use of parenthesis
+# returns an Array of objects.
+# Each object might be a command (String), an operator (well known String) 
+# or another expression (Array)
+module Morpheus::Cli::ExpressionParser
+
+  # An error class for invalid expressions
+  class InvalidExpression < StandardError
+  end
+
+  ## constants used internally for parsing morpheus expressions
+  # note: the space padding in the _TOKEN strings is important for splitting
+
+  OPEN_PARENTHESIS = "("
+  OPEN_PARENTHESIS_TOKEN = "___+++OPEN_PARENTHESIS+++___"
+  OPEN_PARENTHESIS_REGEX = /(\()(?=(?:[^"']|"[^'"]*")*$)/
+
+  CLOSED_PARENTHESIS = ")"
+  CLOSED_PARENTHESIS_TOKEN = "___+++CLOSED_PARENTHESIS+++___"
+  CLOSED_PARENTHESIS_REGEX = /(\))(?=(?:[^"']|"[^'"]*")*$)/
+
+  AND_OPERATOR = "&&"
+  AND_OPERATOR_TOKEN = "___+++AND_OPERATOR+++___"
+  AND_OPERATOR_REGEX = /(\&\&)(?=(?:[^"']|"[^'"]*")*$)/
+
+  OR_OPERATOR = "||"
+  OR_OPERATOR_TOKEN = "___+++OR_OPERATOR+++___"
+  OR_OPERATOR_REGEX = /(\|\|)(?=(?:[^"']|"[^'"]*")*$)/
+
+  PIPE_OPERATOR = "|"
+  PIPE_OPERATOR_TOKEN = "___+++PIPE_OPERATOR+++___"
+  PIPE_OPERATOR_REGEX = /(\|)(?=(?:[^"']|"[^'"]*")*$)/
+
+  COMMAND_DELIMETER = ";"
+  COMMAND_DELIMETER_REGEX = /(\;)(?=(?:[^"']|"[^'"]*")*$)/
+  COMMAND_DELIMETER_TOKEN = "___+++COMMAND_DELIMETER+++___"
+
+  # parse an expression of morpheus commands into a list of expressions
+  def self.parse(input)
+    result = []
+    # first, build up a temporary command string
+    # swap in well known tokens so we can split it safely
+    expression_str = input.dup.to_s
+    expression_str.gsub!(OPEN_PARENTHESIS_REGEX, " #{OPEN_PARENTHESIS_TOKEN} ")
+    expression_str.gsub!(CLOSED_PARENTHESIS_REGEX, " #{CLOSED_PARENTHESIS_TOKEN} ")
+    expression_str.gsub!(AND_OPERATOR_REGEX, " #{AND_OPERATOR_TOKEN} ")
+    expression_str.gsub!(OR_OPERATOR_REGEX, " #{OR_OPERATOR_TOKEN} ")
+    expression_str.gsub!(PIPE_OPERATOR_REGEX, " #{PIPE_OPERATOR_TOKEN} ")
+    expression_str.gsub!(COMMAND_DELIMETER_REGEX, " #{COMMAND_DELIMETER_TOKEN} ")
+    # split on unquoted whitespace
+    tokens = expression_str.split(/(\s)(?=(?:[^"']|"[^'"]*")*$)/).collect {|it| it.to_s.strip }.select {|it| !it.empty?  }.compact
+    # swap back for nice looking tokens
+    tokens = tokens.map do |t|
+      case t
+      when OPEN_PARENTHESIS_TOKEN then OPEN_PARENTHESIS
+      when CLOSED_PARENTHESIS_TOKEN then CLOSED_PARENTHESIS
+      when AND_OPERATOR_TOKEN then AND_OPERATOR
+      when OR_OPERATOR_TOKEN then OR_OPERATOR
+      when PIPE_OPERATOR_TOKEN then PIPE_OPERATOR
+      when COMMAND_DELIMETER_TOKEN then COMMAND_DELIMETER
+      else
+        t
+      end
+    end
+    
+    # result = parse_expression_from_tokens(tokens)
+    begin
+      result = parse_expression_from_tokens(tokens)
+    rescue InvalidExpression => ex
+      raise InvalidExpression.new("#{ex}. Invalid Expression: #{input}")
+    end
+    return result
+  end
+
+  # turn a flat list of tokens into an array of expressions
+  def self.parse_expression_from_tokens(tokens)
+    result = []
+    remaining_tokens = tokens.dup
+    current_command_tokens = []
+    while !remaining_tokens.empty?
+      token = remaining_tokens.shift
+      if token == CLOSED_PARENTHESIS
+        raise InvalidExpression.new("Encountered a closed parenthesis ')' with no matching open parenthesis '('")
+      elsif token == OPEN_PARENTHESIS
+        # add the command
+        if current_command_tokens.size != 0
+          result << current_command_tokens.join(" ")
+          current_command_tokens = []
+        end
+        # start of a new sub expression
+        # find the index of the matching closed parenthesis
+        cur_expression_index = 0
+        closed_parenthesis_index = nil
+        remaining_tokens.each_with_index do |t, index|
+          if t == OPEN_PARENTHESIS
+            cur_expression_index += 1
+          elsif t == CLOSED_PARENTHESIS
+            if cur_expression_index == 0
+              closed_parenthesis_index = index
+              break
+            else
+              cur_expression_index -= 1
+            end
+          end
+          if cur_expression_index < 0
+            raise InvalidExpression.new("Encountered a closed parenthesis ')' with no matching open parenthesis '('")
+          end
+        end
+        if !closed_parenthesis_index
+          raise InvalidExpression.new("Encountered an open parenthesis '(' with no matching closed parenthesis ')'")
+        end
+        # ok, parse a subexpression for the tokens up that index
+        sub_tokens = remaining_tokens[0..closed_parenthesis_index-1]
+        result << parse_expression_from_tokens(sub_tokens)
+        # continue on parsing the remaining tokens
+        remaining_tokens = remaining_tokens[closed_parenthesis_index + 1..remaining_tokens.size - 1]
+      elsif token == AND_OPERATOR || token == OR_OPERATOR || token == PIPE_OPERATOR
+        # add the command
+        if current_command_tokens.size != 0
+          result << current_command_tokens.join(" ")
+          current_command_tokens = []
+        end
+        # add the operator
+        result << token
+      elsif token == COMMAND_DELIMETER
+        # add the command
+        if current_command_tokens.size != 0
+          result << current_command_tokens.join(" ")
+          current_command_tokens = []
+        end
+      else
+        # everything else is assumed to be part of a command, inject it
+        current_command_tokens << token
+      end
+    end
+    
+    # add the command
+    if current_command_tokens.size != 0
+      result << current_command_tokens.join(" ")
+      current_command_tokens = []
+    end
+
+    return result
+  end
+
+end

data/lib/morpheus/cli/hosts.rb

@@ -925,54 +925,80 @@ class Morpheus::Cli::Hosts
   end
 
   def run_workflow(args)
+    params = {}
     options = {}
-    optparse = OptionParser.new do|opts|
-      opts.banner = subcommand_usage("run-workflow", "[name]", "[workflow]")
-      build_common_options(opts, options, [:json, :dry_run, :quiet, :remote])
+    optparse = Morpheus::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[name] [workflow] [options]")
+      build_common_options(opts, options, [:options, :payload, :json, :dry_run, :quiet, :remote])
     end
     optparse.parse!(args)
-    if args.count < 2
-      puts optparse
-      exit 1
+    if args.count != 2
+      puts_error  "#{Morpheus::Terminal.angry_prompt}wrong number of arguments. Expected 2 and received #{args.count} #{args.inspect}\n#{optparse}"
+      return 1
     end
     connect(options)
+
     host = find_host_by_name_or_id(args[0])
+    return 1 if host.nil?
     workflow = find_workflow_by_name(args[1])
-    task_types = @tasks_interface.task_types()
-    editable_options = []
-    workflow['taskSetTasks'].sort{|a,b| a['taskOrder'] <=> b['taskOrder']}.each do |task_set_task|
-      task_type_id = task_set_task['task']['taskType']['id']
-      task_type = task_types['taskTypes'].find{ |current_task_type| current_task_type['id'] == task_type_id}
-      task_opts = task_type['optionTypes'].select { |otype| otype['editable']}
-      if !task_opts.nil? && !task_opts.empty?
-        editable_options += task_opts.collect do |task_opt|
-          new_task_opt = task_opt.clone
-          new_task_opt['fieldContext'] = "#{task_set_task['id']}.#{new_task_opt['fieldContext']}"
+    return 1 if workflow.nil?
+
+    # support -O options as arbitrary params
+    old_option_options = (options[:options] || {}).reject {|k,v| k.is_a?(Symbol) }
+    params.deep_merge!(old_option_options) unless old_option_options.empty?
+
+    # the payload format is unusual
+    # payload example: {"taskSet": {taskSetId": {"taskSetTaskId": {"customOptions": {"dbVersion":"5.6"}}}}}
+    payload = nil
+    if options[:payload]
+      payload = options[:payload]
+    else
+      payload = {}
+      # i guess you must pass an option if there are editable options
+      # any option, heh
+      task_types = @tasks_interface.task_types()
+      editable_options = []
+      workflow['taskSetTasks'].sort{|a,b| a['taskOrder'] <=> b['taskOrder']}.each do |task_set_task|
+        task_type_id = task_set_task['task']['taskType']['id']
+        task_type = task_types['taskTypes'].find{ |current_task_type| current_task_type['id'] == task_type_id}
+        task_opts = task_type['optionTypes'].select { |otype| otype['editable']}
+        if !task_opts.nil? && !task_opts.empty?
+          editable_options += task_opts.collect do |task_opt|
+            new_task_opt = task_opt.clone
+            new_task_opt['fieldContext'] = "#{task_set_task['id']}.#{new_task_opt['fieldContext']}"
+          end
         end
       end
+      if params.empty? && !editable_options.empty?
+        puts optparse
+        option_lines = editable_options.collect {|it| "\t-O #{it['fieldContext'] ? (it['fieldContext'] + '.') : ''}#{it['fieldName']}=\"value\"" }.join("\n")
+        puts "\nAvailable Options:\n#{option_lines}\n\n"
+        return 1
+      end
+
     end
-    params = options[:options] || {}
 
-    if params.empty? && !editable_options.empty?
-      puts optparse
-      option_lines = editable_options.collect {|it| "\t-O #{it['fieldContext'] ? (it['fieldContext'] + '.') : ''}#{it['fieldName']}=\"value\"" }.join("\n")
-      puts "\nAvailable Options:\n#{option_lines}\n\n"
-      exit 1
+    if !params.empty?
+      payload['taskSet'] ||= {}
+      payload['taskSet']["#{workflow['id']}"] ||= {}
+      payload['taskSet']["#{workflow['id']}"].deep_merge!(params)
     end
 
-    workflow_payload = {taskSet: {"#{workflow['id']}" => params }}
     begin
       if options[:dry_run]
-        print_dry_run @servers_interface.dry.workflow(host['id'],workflow['id'], workflow_payload)
+        print_dry_run @servers_interface.dry.workflow(host['id'],workflow['id'], payload)
         return
       end
-      json_response = @servers_interface.workflow(host['id'],workflow['id'], workflow_payload)
+      json_response = @servers_interface.workflow(host['id'],workflow['id'], payload)
       if options[:json]
-        print JSON.pretty_generate(json_response)
-        print "\n"
-      elsif !options[:quiet]
-        puts "Workflow #{workflow['name']} is running..."
+        print as_json(json_response, options), "\n"
+        return
+      elsif options[:quiet]
+        return 0
+      else
+        print_green_success "Running workflow #{workflow['name']} on host #{host['name']} ..."
       end
+      return 0
     rescue RestClient::Exception => e
       print_rest_exception(e, options)
       exit 1

data/lib/morpheus/cli/instances.rb

@@ -1872,9 +1872,9 @@ class Morpheus::Cli::Instances
       build_common_options(opts, options, [:options, :json, :dry_run, :remote])
     end
     optparse.parse!(args)
-    if args.count < 2
-      puts "\n#{optparse}\n\n"
-      exit 1
+    if args.count != 2
+      puts_error  "#{Morpheus::Terminal.angry_prompt}wrong number of arguments. Expected 2 and received #{args.count} #{args.inspect}\n#{optparse}"
+      return 1
     end
     connect(options)
     instance = find_instance_by_name_or_id(args[0])

data/lib/morpheus/cli/shell.rb

@@ -8,6 +8,7 @@ require 'logger'
 require 'fileutils'
 require 'morpheus/cli/cli_command'
 require 'morpheus/cli/error_handler'
+require 'morpheus/cli/expression_parser'
 require 'morpheus/terminal'
 
 #class Morpheus::Cli::Shell < Morpheus::Terminal
@@ -196,7 +197,7 @@ class Morpheus::Cli::Shell
     result = nil
     if @execute_mode_command
       # execute a single command and exit
-      result = execute_commands(@execute_mode_command)
+      result = execute(@execute_mode_command)
     else
       # interactive prompt
       result = 0
@@ -209,7 +210,7 @@ class Morpheus::Cli::Shell
         input = Readline.readline(@calculated_prompt, true).to_s
         input = input.strip
 
-        result = execute_commands(input)
+        result = execute(input)
       end
     end
     
@@ -256,117 +257,84 @@ class Morpheus::Cli::Shell
   def execute(input)
     # args = Shellwords.shellsplit(input)
     #cmd = args.shift
-    execute_commands(input)
+    #execute_commands(input)
+    result = execute_commands_as_expression(input)
+    # 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 result
   end
 
-  def execute_commands(input)
-    # input = input.to_s.sub(/^morpheus\s+/, "") # meh
-    # split the command on unquoted semicolons.
-    # so you can run multiple commands at once! eg hosts list; instances list
-    # 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}"
+  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
-    all_commands.each do |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 parse_result_exitstatus(previous_command_result) != 0
-                  still_executing = false
-                end
-              elsif flow_cmd == '||' # or with previous command
-                current_operator = flow_cmd
-                if parse_result_exitstatus(previous_command_result) == 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
+    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
+              if parse_result_exitstatus(previous_command_result) != 0
+                still_executing = false
+              end
+            elsif flow_cmd == '||' # or with previous command
+              current_operator = flow_cmd
+              if parse_result_exitstatus(previous_command_result) == 0
                 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
+            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
-          final_command_result = previous_command_result
+          # previous_command = flow_cmd
         end
-      else
-        # just one command, this else is not needed tho
-        final_command_result = execute_command(cmd)
+        final_command_result = previous_command_result
       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)
-    #puts "shell execute_command(#{input})"
+    #Morpheus::Logging::DarkPrinter.puts "Shell command: #{input}"
     input = input.to_s.strip
 
     if !input.empty?
@@ -519,7 +487,7 @@ class Morpheus::Cli::Shell
           puts "There is no previous command"
           return false
         end
-        execute_commands(input)
+        return execute(input)
       elsif input =~ /^\!.+/
         cmd_number = input.sub("!", "").to_i
         if cmd_number != 0
@@ -533,7 +501,7 @@ class Morpheus::Cli::Shell
           # remove this from readline, and replace it with the old command
           Readline::HISTORY.pop
           Readline::HISTORY << old_input
-          return execute_commands(old_input)
+          return execute(old_input)
         end
 
       elsif input == "insecure"

data/lib/morpheus/cli/version.rb

@@ -1,6 +1,6 @@
 
 module Morpheus
   module Cli
-    VERSION = "3.3.2.5"
+    VERSION = "3.3.2.6"
   end
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: morpheus-cli
 version: !ruby/object:Gem::Version
-  version: 3.3.2.5
+  version: 3.3.2.6
 platform: ruby
 authors:
 - David Estes
@@ -218,6 +218,7 @@ files:
 - lib/morpheus/cli/clouds.rb
 - lib/morpheus/cli/coloring_command.rb
 - lib/morpheus/cli/command_error.rb
+- lib/morpheus/cli/commands/standard/exit_command.rb
 - lib/morpheus/cli/containers_command.rb
 - lib/morpheus/cli/credentials.rb
 - lib/morpheus/cli/curl_command.rb
@@ -229,6 +230,7 @@ files:
 - lib/morpheus/cli/edit_profile_command.rb
 - lib/morpheus/cli/edit_rc_command.rb
 - lib/morpheus/cli/error_handler.rb
+- lib/morpheus/cli/expression_parser.rb
 - lib/morpheus/cli/groups.rb
 - lib/morpheus/cli/hosts.rb
 - lib/morpheus/cli/image_builder_command.rb