morpheus-cli 4.1.8 → 4.1.9

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

@@ -321,89 +321,137 @@ EOT
       return 1
     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|
+    exit_code = 0
+    out = ""
+
+    original_stdout = nil
+    begin
+      # --quiet actually unhooks stdout for this command
+      if options[:quiet]
+        original_stdout = my_terminal.stdout
+        my_terminal.set_stdout(Morpheus::Terminal::Blackhole.new)
+      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 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"
+        # Morpheus::Logging::DarkPrinter.puts(cyan + dark + benchmark_record.msg) if benchmark_record
+        # return 0
+        if original_stdout
+          my_terminal.set_stdout(original_stdout)
+          original_stdout = nil
+        end
+        out = ""
+        # <benchmark name or command>
+        out << "#{benchmark_name.ljust(30, ' ')}"
+        # exit: 0
+        exit_code = benchmark_record.exit_code
+        bad_benchmark = benchmark_record.exit_code && benchmark_record.exit_code != 0
+        if bad_benchmark
+          out << "\texit: #{bad_benchmark.exit_code.to_s.ljust(2, ' ')}"
+          out << "\terror: #{bad_benchmark.error.to_s.ljust(12, ' ')}"
+        else
+          out << "\texit: 0 "
+        end
+      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
+        if original_stdout
+          my_terminal.set_stdout(original_stdout)
+          original_stdout = nil
+        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"
 
-      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
+        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
-      end
-      if all_durations.size > 0
-        stats[:avg] = stats[:total].to_f / all_durations.size
-      end
+        if all_durations.size > 0
+          stats[:avg] = stats[:total].to_f / all_durations.size
+        end
 
-      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" : ""
+        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" : ""
 
-      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
+        out = ""
+        # <benchmark name or command>
+        out << "#{benchmark_name.ljust(30, ' ')}"
+        # exit: 0
+        bad_benchmark = benchmark_records.find {|benchmark_record| benchmark_record.exit_code && benchmark_record.exit_code != 0 }
+        if bad_benchmark
+          exit_code = bad_benchmark.exit_code.to_i
+          out << "\texit: #{bad_benchmark.exit_code.to_s.ljust(2, ' ')}"
+          out << "\terror: #{bad_benchmark.error.to_s.ljust(12, ' ')}"
+        else
+          out << "\texit: 0 "
+        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, ' ')}"
+        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, ' ')}"
 
 
-      if bad_benchmark
-        print red,out,reset,"\n"
-        return 1
-      else
+        # if bad_benchmark
+        #   print_error red,out,reset,"\n"
+        #   return 1
+        # else
+        #   print cyan,out,reset,"\n"
+        #   return 0
+        # end
+      end
+      if exit_code == 0
         print cyan,out,reset,"\n"
         return 0
+      else
+        print_error red,out,reset,"\n"
+        return exit_code
+      end
+    rescue => ex
+      raise ex
+      #raise_command_error "benchmark exec failed with error: #{ex}"
+      #puts_error "benchmark exec failed with error: #{ex}"
+      #return 1
+    ensure
+      if original_stdout
+        my_terminal.set_stdout(original_stdout)
+        original_stdout = nil
       end
-      
     end
-
-    return 0 
   end
 
 end

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

@@ -57,11 +57,13 @@ class Morpheus::Cli::ColoringCommand
       if Term::ANSIColor::coloring?
         if coloring_was_enabled == false
           Morpheus::Logging::DarkPrinter.puts "coloring enabled" if Morpheus::Logging.debug?
+          recalculate_after_color_change()
         end
         puts "#{cyan}coloring: #{bold}#{green}on#{reset}"
       else
         if coloring_was_enabled == true
           Morpheus::Logging::DarkPrinter.puts "coloring disabled" if Morpheus::Logging.debug?
+          recalculate_after_color_change()
         end
         puts "coloring: off"
       end
@@ -69,4 +71,14 @@ class Morpheus::Cli::ColoringCommand
     return exit_code
   end
 
+  protected
+
+  def recalculate_after_color_change()
+    # recalculate shell prompt after this change
+    Morpheus::Cli::Echo.recalculate_variable_map()
+    if Morpheus::Cli::Shell.has_instance?
+      Morpheus::Cli::Shell.instance.recalculate_prompt()
+    end
+  end
+
 end

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

@@ -12,6 +12,9 @@ class Morpheus::Cli::CurlCommand
     split_args = args.join(" ").split(" -- ")
     args = split_args[0].split(" ")
     curl_args = split_args[1] ? split_args[1].split(" ") : []
+    curl_method = nil
+    curl_data = nil
+    show_progress = false
     # puts "args is : #{args}"
     # puts "curl_args is : #{curl_args}"
     options = {}
@@ -20,11 +23,20 @@ class Morpheus::Cli::CurlCommand
       opts.on( '-p', '--pretty', "Print result as parsed JSON." ) do
         options[:pretty] = true
       end
+      opts.on( '-X', '--request METHOD', "HTTP request method. Default is GET" ) do |val|
+        curl_method = val
+      end
+      opts.on( '--data DATA', String, "HTTP request body for use with POST and PUT, typically JSON." ) do |val|
+        curl_data = val
+      end
+      opts.on( '--progress', '--progress', "Display progress output by excluding the -s option." ) do
+        show_progress = true
+      end
       build_common_options(opts, options, [:dry_run, :remote])
       opts.add_hidden_option('--curl')
       #opts.add_hidden_option('--scrub')
       opts.footer = <<-EOT
-This invokes the `curl` command with url "appliance_url/api/$0
+This invokes the `curl` command with url "appliance_url/$0
 and includes the authorization header -H "Authorization: Bearer access_token"
 Arguments for the curl command should be passed after ' -- '
 Example: morpheus curl "/api/servers/1" -- -XGET -sv
@@ -71,10 +83,21 @@ EOT
       api_path = api_path.sub(/^\//, "") # strip leading slash
       url = "#{@appliance_url.chomp('/')}/#{api_path}"
     end
-    curl_cmd = "curl \"#{url}\""
+    curl_cmd = "curl"
+    if show_progress == false
+      curl_cmd << " -s"
+    end
+    if curl_method
+      curl_cmd << " -X#{curl_method}"
+    end
+    curl_cmd << " \"#{url}\""
     if @access_token
       curl_cmd << " -H \"Authorization: Bearer #{@access_token}\""
     end
+    if curl_data
+      #todo: curl_data.gsub("'","\\'")
+      curl_cmd << " --data '#{curl_data}'"
+    end
     if !curl_args.empty?
       curl_cmd << " " + curl_args.join(' ')
     end
@@ -89,16 +112,18 @@ EOT
       print reset
       return 0
     end
-    print cyan
-    print "#{cyan}#{curl_cmd_str}#{reset}"
-    print "\n\n"
+    # print cyan
+    # print "#{cyan}#{curl_cmd_str}#{reset}"
+    # print "\n\n"
     print reset
     # print result
     curl_output = `#{curl_cmd}`
     if options[:pretty]
       output_lines = curl_output.split("\n")
       last_line = output_lines.pop
-      puts output_lines.join("\n")
+      if output_lines.size > 0
+        puts output_lines.join("\n")
+      end
       begin
         json_data = JSON.parse(last_line)
         json_string = JSON.pretty_generate(json_data)

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

@@ -10,8 +10,8 @@ class Morpheus::Cli::Echo
   set_command_name :echo
   set_command_hidden
 
-  unless defined?(DEFAULT_VARIABLE_MAP)
-    DEFAULT_VARIABLE_MAP = {'%cyan' => Term::ANSIColor.cyan, '%magenta' => Term::ANSIColor.magenta, '%red' => Term::ANSIColor.red, '%green' => Term::ANSIColor.green, '%yellow' => Term::ANSIColor.yellow, '%white' => Term::ANSIColor.white, '%dark' => Term::ANSIColor.dark, '%reset' => Term::ANSIColor.reset}
+  unless defined?(COLOR_VARIABLE_MAP)
+    COLOR_VARIABLE_MAP = {'%cyan' => Term::ANSIColor.cyan, '%magenta' => Term::ANSIColor.magenta, '%red' => Term::ANSIColor.red, '%green' => Term::ANSIColor.green, '%yellow' => Term::ANSIColor.yellow, '%white' => Term::ANSIColor.white, '%dark' => Term::ANSIColor.dark, '%reset' => Term::ANSIColor.reset}
   end
 
   def self.variable_map
@@ -20,7 +20,12 @@ class Morpheus::Cli::Echo
 
   def self.recalculate_variable_map()
     var_map = {}
-    var_map.merge!(DEFAULT_VARIABLE_MAP)
+    if Term::ANSIColor.coloring?
+      var_map.merge!(COLOR_VARIABLE_MAP)
+    else
+      COLOR_VARIABLE_MAP.each {|k,v| var_map[k] = "" }
+    end
+
     appliance = ::Morpheus::Cli::Remote.load_active_remote()
     if appliance
       var_map.merge!({'%remote' => appliance[:name], '%remote_url' => (appliance[:host].to_s || appliance[:url].to_s), '%username' => appliance[:username].to_s})

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

@@ -27,7 +27,7 @@ Examples:
     set-prompt "morpheus $ "
     set-prompt "%cyanmorpheus> "
     set-prompt "[%magenta%remote%reset] %cyan%username> "
-    set-prompt "%green%username%reset@%remote morph %magenta> %reset"
+    set-prompt "%green%username%reset@%remote %magenta> %reset"
     set-prompt "%cyan%username%reset@%magenta%remote %cyanmorpheus> %reset"
 
 The available variables are:

data/lib/morpheus/cli/containers_command.rb

@@ -4,11 +4,13 @@ require 'optparse'
 require 'filesize'
 require 'morpheus/cli/cli_command'
 require 'morpheus/cli/mixins/provisioning_helper'
+require 'morpheus/cli/mixins/logs_helper'
 require 'morpheus/cli/option_types'
 
 class Morpheus::Cli::ContainersCommand
   include Morpheus::Cli::CliCommand
   include Morpheus::Cli::ProvisioningHelper
+  include Morpheus::Cli::LogsHelper
 
   set_command_name :containers
 
@@ -507,8 +509,24 @@ class Morpheus::Cli::ContainersCommand
 
   def logs(args)
     options = {}
+    params = {}
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[id]")
+      opts.on('--start TIMESTAMP','--start TIMESTAMP', "Start timestamp. Default is 30 days ago.") do |val|
+        options[:start] = parse_time(val) #.utc.iso8601
+      end
+      opts.on('--end TIMESTAMP','--end TIMESTAMP', "End timestamp. Default is now.") do |val|
+        options[:end] = parse_time(val) #.utc.iso8601
+      end
+      opts.on('--level VALUE', String, "Log Level. DEBUG,INFO,WARN,ERROR") do |val|
+        params['level'] = params['level'] ? [params['level'], val].flatten : val
+      end
+      opts.on('--table', '--table', "Format ouput as a table.") do
+        options[:table] = true
+      end
+      opts.on('-a', '--all', "Display all details: entire message." ) do
+        options[:details] = true
+      end
       build_common_options(opts, options, [:list, :query, :json, :yaml, :csv, :fields, :dry_run, :remote])
       opts.footer = "List logs for a container.\n" +
                     "[id] is required. This is the id of a container."
@@ -523,47 +541,42 @@ class Morpheus::Cli::ContainersCommand
     id_list = parse_id_list(args)
     begin
       containers = id_list # heh
-      params = {}
       params.merge!(parse_list_options(options))
-      params[:query] = params.delete(:phrase) unless params[:phrase].nil?
-      params['order'] = params['direction'] unless params['direction'].nil? # old api version expects order instead of direction
+      params['query'] = params.delete('phrase') if params['phrase']
+      params[:order] = params[:direction] unless params[:direction].nil? # old api version expects order instead of direction
+      params['startMs'] = (options[:start].to_i * 1000) if options[:start]
+      params['endMs'] = (options[:end].to_i * 1000) if options[:end]
       @logs_interface.setopts(options)
       if options[:dry_run]
         print_dry_run @logs_interface.dry.container_logs(containers, params)
         return
       end
       json_response = @logs_interface.container_logs(containers, params)
-      render_result = render_with_format(json_response, options, 'data')
+      render_result = json_response['logs'] ? render_with_format(json_response, options, 'logs') : render_with_format(json_response, options, 'data')
       return 0 if render_result
 
       logs = json_response
       title = "Container Logs: #{containers.join(', ')}"
       subtitles = parse_list_subtitles(options)
+      if options[:start]
+        subtitles << "Start: #{options[:start]}".strip
+      end
+      if options[:end]
+        subtitles << "End: #{options[:end]}".strip
+      end
       if params[:query]
         subtitles << "Search: #{params[:query]}".strip
       end
-      # todo: startMs, endMs, sorts insteaad of sort..etc
+      if params['level']
+        subtitles << "Level: #{params['level']}"
+      end
+      logs = json_response['data'] || json_response['logs']
       print_h1 title, subtitles, options
-      if logs['data'].empty?
-        puts "#{cyan}No logs found.#{reset}"
+      if logs.empty?
+        print "#{cyan}No logs found.#{reset}\n"
       else
-        logs['data'].each do |log_entry|
-          log_level = ''
-          case log_entry['level']
-          when 'INFO'
-            log_level = "#{blue}#{bold}INFO#{reset}"
-          when 'DEBUG'
-            log_level = "#{white}#{bold}DEBUG#{reset}"
-          when 'WARN'
-            log_level = "#{yellow}#{bold}WARN#{reset}"
-          when 'ERROR'
-            log_level = "#{red}#{bold}ERROR#{reset}"
-          when 'FATAL'
-            log_level = "#{red}#{bold}FATAL#{reset}"
-          end
-          puts "[#{log_entry['ts']}] #{log_level} - #{log_entry['message'].to_s.strip}"
-        end
-        print_results_pagination({'meta'=>{'total'=>json_response['total'],'size'=>json_response['data'].size,'max'=>(json_response['max'] || options[:max]),'offset'=>(json_response['offset'] || options[:offset] || 0)}})
+        print format_log_records(logs, options)
+        print_results_pagination({'meta'=>{'total'=>(json_response['total']['value'] rescue json_response['total']),'size'=>logs.size,'max'=>(json_response['max'] || options[:max]),'offset'=>(json_response['offset'] || options[:offset] || 0)}})
       end
       print reset,"\n"
       return 0

data/lib/morpheus/cli/cypher_command.rb

@@ -66,6 +66,7 @@ class Morpheus::Cli::CypherCommand
         puts records_as_csv([json_response], options)
         return 0
       end
+      cypher_items = json_response["cypherItems"] || json_response["cyphers"]
       cypher_data = json_response["data"]
       title = "Morpheus Cypher Key List"
       subtitles = []
@@ -93,13 +94,15 @@ class Morpheus::Cli::CypherCommand
           "EXPIRATION" => lambda {|it| 
             format_expiration_date(it["expireDate"])
           },
-          "DATE CREATED" => lambda {|it| format_local_dt(it["dateCreated"]) },
-          "LAST ACCESS" => lambda {|it| format_local_dt(it["lastAccessed"]) }
+          # "DATE CREATED" => lambda {|it| format_local_dt(it["dateCreated"]) },
+          "LAST UPDATED" => lambda {|it| format_local_dt(it["lastUpdated"]) },
+          "LAST ACCESSED" => lambda {|it| format_local_dt(it["lastAccessed"]) }
         }
         print cyan
-        print as_pretty_table(json_response["cypherItems"], cypher_columns, options)
+        print as_pretty_table(cypher_items, cypher_columns, options)
         print reset
-        print_results_pagination({size:cypher_keys.size,total:cypher_keys.size.to_i})
+        # print_results_pagination({size:cypher_keys.size,total:cypher_keys.size.to_i})
+        print_results_pagination(json_response)
       end
       print reset,"\n"
       return 0
@@ -114,7 +117,7 @@ class Morpheus::Cli::CypherCommand
     params = {}
     value_only = false
     do_decrypt = false
-    item_ttl = nil
+    ttl = nil
     optparse = Morpheus::Cli::OptionParser.new do |opts|
       opts.banner = subcommand_usage("[key]")
       # opts.on(nil, '--decrypt', 'Display the decrypted value') do
@@ -127,14 +130,14 @@ class Morpheus::Cli::CypherCommand
         value_only = true
       end
       opts.on( '-t', '--ttl SECONDS', "Time to live, the lease duration before this key expires. Use if creating new key." ) do |val|
-        item_ttl = val
+        ttl = val
         if val.to_s.empty? || val.to_s == '0'
-          item_ttl = 0
+          ttl = 0
         else
-          item_ttl = val
+          ttl = val
         end
       end
-      build_common_options(opts, options, [:json, :yaml, :csv, :fields, :dry_run, :quiet, :remote])
+      build_common_options(opts, options, [:query, :json, :yaml, :csv, :fields, :outfile, :dry_run, :quiet, :remote])
       opts.footer = "Read a cypher item and display the decrypted value." + "\n" +
                     "[key] is required. This is the cypher key to read." + "\n" +
                     "Use --ttl to specify a ttl if expecting cypher engine to automatically create the key."
@@ -148,33 +151,24 @@ class Morpheus::Cli::CypherCommand
     connect(options)
     begin
       item_key = args[0]
-      if item_ttl
-        params["ttl"] = item_ttl
+      if ttl
+        params["ttl"] = ttl
       end
       @cypher_interface.setopts(options)
       if options[:dry_run]
         print_dry_run @cypher_interface.dry.get(item_key, params)
         return 0
       end
+      params.merge!(parse_list_options(options))
       json_response = @cypher_interface.get(item_key, params)
-
-      if options[:quiet]
+      render_result = render_with_format(json_response, options)
+      if render_result
         return 0
       end
-
-      if options[:json]
-        puts as_json(json_response, options)
-        return 0
-      elsif options[:yaml]
-        puts as_yaml(json_response, options)
-        return 0
-      elsif options[:csv]
-        puts records_as_csv([json_response], options)
-        return 0
-      end
-
+      
       cypher_item = json_response['cypher']
       decrypted_value = json_response["data"]
+      data_type = decrypted_value.is_a?(String) ? 'string' : 'object'
 
       if value_only
         print cyan
@@ -201,19 +195,24 @@ class Morpheus::Cli::CypherCommand
         "TTL" => lambda {|it| 
           format_expiration_ttl(it["expireDate"])
         },
+        # "Type" => lambda {|it| 
+        #   data_type
+        # },
         "Expiration" => lambda {|it| 
           format_expiration_date(it["expireDate"])
         },
-        "Date Created" => lambda {|it| format_local_dt(it["dateCreated"]) },
-        "Last Access" => lambda {|it| format_local_dt(it["lastAccessed"]) }
+        # "Date Created" => lambda {|it| format_local_dt(it["dateCreated"]) },
+        "Last Updated" => lambda {|it| format_local_dt(it["lastUpdated"]) },
+        "Last Accessed" => lambda {|it| format_local_dt(it["lastAccessed"]) }
       }
       if cypher_item["expireDate"].nil?
         description_cols.delete("Expires")
       end
       print_description_list(description_cols, cypher_item)
 
-      print_h2 "Value", options
-      # print_h2 "Decrypted Value"
+      # print_h2 "Value", options
+      # print_h2 "Data", options
+      print_h2 "Data (#{data_type})", options
       
       if decrypted_value
         print cyan
@@ -247,36 +246,44 @@ class Morpheus::Cli::CypherCommand
   end
 
   def put(args)
+        usage = <<-EOT
+Usage: morpheus #{command_name} put [key] [value] [options] to store a string.
+       morpheus #{command_name} put [key] [k=v] [k=v] [options] to store an object.
+EOT
     options = {}
     params = {}
     item_key = nil
     item_value = nil
-    item_ttl = nil
+    ttl = nil
     no_overwrite = nil
     optparse = Morpheus::Cli::OptionParser.new do |opts|
-      opts.banner = subcommand_usage("[key] [value]")
-      # opts.on( '--key VALUE', String, "Key" ) do |val|
-      #   item_key = val
-      # end
-      opts.on( '-v', '--value VALUE', "Secret value" ) do |val|
+      # opts.banner = subcommand_usage("[key] [value]\n\t[key] [k=v] [k=v] [k=v]") 
+      opts.banner = usage 
+      opts.on( '--key KEY', String, "Key. This can also be passed as the first argument." ) do |val|
+        item_key = val
+      end
+      opts.on( '-v', '--value VALUE', "Secret value. This can be used to store a string instead of an object, and can also be passed as the second argument." ) do |val|
         item_value = val
       end
       opts.on( '-t', '--ttl SECONDS', "Time to live, the lease duration before this key expires." ) do |val|
-        item_ttl = val
+        ttl = val
         if val.to_s.empty? || val.to_s == '0'
-          item_ttl = 0
+          ttl = 0
         else
-          item_ttl = val
+          ttl = val
         end
       end
       # opts.on( '--no-overwrite', '--no-overwrite', "Do not overwrite existing keys. Existing keys are overwritten by default." ) do
       #   params['overwrite'] = false
       # end
-      build_common_options(opts, options, [:auto_confirm, :options, :payload, :json, :dry_run, :quiet, :remote])
+      build_common_options(opts, options, [:auto_confirm, :options, :payload, :json, :yaml, :csv, :fields, :outfile, :dry_run, :quiet, :remote])
       opts.footer = "Create or update a cypher key." + "\n" +
-                    "[key] is required. This is the key of the cypher being created or updated." + "\n" +
-                    "[value] is required. This is the new value or value pairs being stored. Supports format foo=bar, 1-N arguments." + "\n" +
-                    "The --payload option can be used instead of passing [value] argument."
+                    "[key] is required. This is the key of the cypher being created or updated. The key includes the mount prefix eg. secret/hello" + "\n" +
+                    "[value] is required for some cypher engines, such as secret. This is the secret value or k=v pairs being stored. Supports 1-N arguments." + "\n" +
+                    "If a single [value] is passed, it is stored as type string." + "\n" +
+                    "If more than one [value] is passed, the format is expected to be k=v and the value will be stored as an object." + "\n" +
+                    "The --value option can be used to store a string value." + "\n" +
+                    "The --payload option can be used to store an object."
     end
     optparse.parse!(args)
     # if args.count < 1
@@ -285,126 +292,160 @@ class Morpheus::Cli::CypherCommand
     #   return 1
     # end
     connect(options)
-    begin
-      if args[0]
-        item_key = args[0]
+    
+    # parse arguments like [value] or [k=v]
+    item_key = args[0]
+    item_value = args[1]
+    if args.count == 0
+      # prompt for key and value
+    elsif args.count == 1
+      # prompt for value
+    elsif args.count == 2
+      # expecting [value] or [k=v]
+      item_value_object = {}
+      item_value_pair = item_value.split("=")
+      if item_value_pair.size == 2
+        item_value_object[item_value_pair[0].to_s] = item_value_pair[1]
+        item_value = item_value_object
+      else
+        # item_value = item_value
+      end
+    elsif args.count > 2
+      # expecting [k=v] [k=v]
+      item_value_object = {}
+      args[1..(args.size-1)].each do |arg|
+        item_value_pair = arg.split("=")
+        item_value_object[item_value_pair[0].to_s] = item_value_pair[1]
       end
-      options[:options] ||= {}
-      options[:options]['key'] = item_key if item_key
-      # Key prompt
+      item_value = item_value_object
+    end
+
+    # this is redunant and silly, refactor soon
+
+    # Key prompt
+    if item_key
+      options[:options]['key'] = item_key
+    end
+    if item_key.nil?
       v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'key', 'fieldLabel' => 'Key', 'type' => 'text', 'required' => true, 'description' => cypher_key_help}], options[:options])
       item_key = v_prompt['key']
+    end
 
-      payload = nil
-      if options[:payload]
-        payload = options[:payload]
-        payload.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) || ['key','value'].include?(k)}) if options[:options] && options[:options].keys.size > 0
-      else
-        # merge -O options into normally parsed options
-        params.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) || ['key','value'].include?(k)}) if options[:options] && options[:options].keys.size > 0
-        
-        # Value prompt
-        value_is_required = false
-        cypher_mount_type = item_key.split("/").first
-        if ["secret"].include?(cypher_mount_type)
-          value_is_required = true
-        end
+    payload = nil
+    if options[:payload]
+      payload = options[:payload]
+      payload.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) || ['key','value'].include?(k)}) if options[:options] && options[:options].keys.size > 0
+    else
+      # merge -O options into normally parsed options
+      params.deep_merge!(options[:options].reject {|k,v| k.is_a?(Symbol) || ['key','value'].include?(k)}) if options[:options] && options[:options].keys.size > 0
+      
+      # Value prompt
+      value_is_required = false
+      cypher_mount_type = item_key.split("/").first
+      if ["secret","tfvars"].include?(cypher_mount_type)
+        value_is_required = true
+      end
 
-        # todo: read value from STDIN shall we?
-
-        # cool, we got value as arguments like foo=bar
-        if args.count > 1
-          # parse one and only arg as the value like password/mine mypassword123
-          if args.count == 2 && args[1].split("=").size() == 1
-            item_value = args[1]
-          elsif args.count > 1
-            # parse args as key value pairs like secret/config foo=bar thing=myvalue
-            value_arguments = args[1..-1]
-            value_arguments_map = {}
-            value_arguments.each do |value_argument|
-              value_pair = value_argument.split("=")
-              value_arguments_map[value_pair[0]] = value_pair[1] ? value_pair[1..-1].join("=") : nil
-            end
-            item_value = value_arguments_map
-          end
-        else
-          # Prompt for a single text value to be sent as {"value":"my secret"}
-          if value_is_required
-            options[:options]['value'] = item_value if item_value
-            v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'value', 'fieldLabel' => 'Value', 'type' => 'text', 'required' => value_is_required, 'description' => "Secret value for this cypher"}], options[:options])
-            item_value = v_prompt['value']
+      # todo: read value from STDIN shall we?
+
+      # cool, we got value as arguments like foo=bar
+      if args.count > 1
+        # parse one and only arg as the value like password/mine mypassword123
+        if args.count == 2 && args[1].split("=").size() == 1
+          item_value = args[1]
+        elsif args.count > 1
+          # parse args as key value pairs like secret/config foo=bar thing=myvalue
+          value_arguments = args[1..-1]
+          value_arguments_map = {}
+          value_arguments.each do |value_argument|
+            value_pair = value_argument.split("=")
+            value_arguments_map[value_pair[0]] = value_pair[1] ? value_pair[1..-1].join("=") : nil
           end
+          item_value = value_arguments_map
         end
-
-        # construct payload
-        # payload = {
-        #   'cypher' => params
-        # }
-        
-        # if value is valid json, then the payload IS the value
-        if item_value.is_a?(String) && item_value.to_s[0] == '{' && item_value.to_s[-1] == '}'
-          begin
-            json_object = JSON.parse(item_value)
-            item_value = json_object
-          rescue => ex
-            Morpheus::Logging::DarkPrinter.puts "Failed to parse cypher value '#{item_value}' as JSON. Error: #{ex}" if Morpheus::Logging.debug?
-            raise_command_error "Failed to parse cypher value as JSON: #{item_value}"
-            # return 1
-          end
-        else
-          # it is just a string
-          if item_value.is_a?(String)
-            payload = {"value" => item_value}
-          elsif item_value.nil?
-            payload = {}
-          else item_value
-            # great, a Hash I hope
-            payload = item_value
-          end
+      else
+        # Prompt for a single text value to be sent as {"value":"my secret"}
+        if value_is_required
+          options[:options]['value'] = item_value if item_value
+          v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'value', 'fieldLabel' => 'Value', 'type' => 'text', 'required' => value_is_required, 'description' => "Secret value for this cypher"}], options[:options])
+          item_value = v_prompt['value']
         end
       end
 
-      # prompt for Lease
-      options[:options]['ttl'] = item_ttl if item_ttl
-      v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'ttl', 'fieldLabel' => 'Lease (TTL in seconds)', 'type' => 'text', 'required' => false, 'description' => cypher_ttl_help}], options[:options])
-      item_ttl = v_prompt['ttl']
-
+      # make sure not to pass a value for these or it will not save them.
+      # if ['uuid','key','password'].include?(cypher_mount_type)
+      #   item_value = nil
+      # end
 
-      if item_ttl
-        # I would like this better as params...
-        payload["ttl"] = item_ttl
-      end
-      @cypher_interface.setopts(options)
-      if options[:dry_run]
-        print_dry_run @cypher_interface.dry.create(item_key, payload)
-        return
-      end
-      existing_cypher = nil
-      json_response = @cypher_interface.list(item_key)
-      if json_response["data"] && json_response["data"]["keys"]
-        existing_cypher = json_response["data"]["keys"].find {|k| k == item_key }
-      end
-      if existing_cypher
-        unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to overwrite the cypher key #{item_key}?")
-          return 9, "aborted command"
+      # construct payload
+      # payload = {
+      #   'cypher' => params
+      # }
+      payload = {}
+      # if value is valid json, then the payload IS the value
+      if item_value.is_a?(String) && item_value.to_s[0] == '{' && item_value.to_s[-1] == '}'
+        begin
+          json_object = JSON.parse(item_value)
+          item_value = json_object
+        rescue => ex
+          Morpheus::Logging::DarkPrinter.puts "Failed to parse cypher value '#{item_value}' as JSON. Error: #{ex}" if Morpheus::Logging.debug?
+          raise_command_error "Failed to parse cypher value as JSON: #{item_value}"
+          # return 1
+        end
+      else
+        # it is just a string
+        if item_value.is_a?(String)
+          params['type'] = 'string'
+          #params["value"] = item_value
+          payload["value"] = item_value
+        elsif item_value.nil?
+          payload = {}
+        else item_value
+          # great, a Hash I hope
+          payload = item_value
         end
       end
-      json_response = @cypher_interface.create(item_key, payload)
-      if options[:json]
-        puts as_json(json_response, options)
-      elsif !options[:quiet]
-        print_green_success "Wrote cypher #{item_key}"
-        # should print without doing get, because that can use a token.
-        cypher_item = json_response['cypher']
-        get([item_key])
+    end
+
+    # prompt for Lease
+    options[:options]['ttl'] = ttl if ttl
+    v_prompt = Morpheus::Cli::OptionTypes.prompt([{'fieldName' => 'ttl', 'fieldLabel' => 'Lease (TTL in seconds)', 'type' => 'text', 'required' => false, 'description' => cypher_ttl_help, 'defaultValue' => '0'}], options[:options])
+    ttl = v_prompt['ttl']
+
+    if ttl
+      params['ttl'] = ttl
+      #payload["ttl"] = ttl
+    end
+    @cypher_interface.setopts(options)
+    if options[:dry_run]
+      print_dry_run @cypher_interface.dry.create(item_key, params, payload)
+      return
+    end
+    existing_cypher = nil
+    json_response = @cypher_interface.list(item_key)
+    if json_response["data"] && json_response["data"]["keys"]
+      existing_cypher = json_response["data"]["keys"].find {|k| k == item_key }
+    end
+    if existing_cypher
+      unless options[:yes] || Morpheus::Cli::OptionTypes.confirm("Are you sure you want to overwrite the cypher key #{item_key}?")
+        return 9, "aborted command"
       end
+    end
+    json_response = @cypher_interface.create(item_key, params, payload)
+    render_result = render_with_format(json_response, options)
+    if render_result
       return 0
-    rescue RestClient::Exception => e
-      print_rest_exception(e, options)
-      exit 1
     end
+    #print_green_success "Cypher #{item_key} updated"
+    # print_green_success "Wrote cypher #{item_key}"
+    print_green_success "Success! Data written to: #{item_key}"
+    # should print without doing get, because that can use a token.
+    cypher_item = json_response['cypher']
+    get_args = [item_key] + (options[:remote] ? ["-r",options[:remote]] : [])
+    get(get_args)
+    return 0
   end
-
+  
   def remove(args)
     options = {}
     params = {}
@@ -412,7 +453,7 @@ class Morpheus::Cli::CypherCommand
       opts.banner = subcommand_usage("[key]")
       build_common_options(opts, options, [:auto_confirm, :json, :dry_run, :quiet, :remote])
       opts.footer = "Delete a cypher." + "\n" +
-                    "[key] is required. This is the key of a cypher."
+                    "[key] is required. This is the cypher key to be deleted."
     end
     optparse.parse!(args)
 
@@ -478,16 +519,16 @@ key - Generates a Base 64 encoded AES Key of specified bit length in the key pat
 
   def cypher_ttl_help
     """
-Lease time in seconds
+TTL in seconds
 Quick Second Time Reference:
 Hour: 3600
 Day: 86400
 Week: 604800
 Month (30 days): 2592000
 Year: 31536000
-This can also be passed in abbreviated format with the unit as the suffix. eg. 32d, 90s, 5y
-This can be passed as 0 to disable expiration and never expire.
-The default is 32 days (2764800).
+Unlimited: 0
+This can be passed in abbreviated duration format. eg. 32d, 90s, 5y
+The default is 0, meaning Unlimited.
 """
   end