morpheus-cli 2.10.3 → 2.11.0

data/lib/morpheus/cli/workflows.rb

@@ -49,9 +49,14 @@ class Morpheus::Cli::Workflows
         print JSON.pretty_generate(json_response)
       else
         task_sets = json_response['taskSets']
-        print "\n" ,cyan, bold, "Morpheus Workflows\n","==================", reset, "\n\n"
+        title = "Morpheus Workflows"
+        subtitles = []
+        if params[:phrase]
+          subtitles << "Search: #{params[:phrase]}".strip
+        end
+        print_h1 title, subtitles
         if task_sets.empty?
-          puts yellow,"No workflows currently configured.",reset
+          print cyan,"No workflows found.",reset,"\n"
         else
           print cyan
           print_workflows_table(task_sets)
@@ -142,15 +147,25 @@ class Morpheus::Cli::Workflows
         #   tasks << find_task_by_name_or_id(task_name)['id']
         # end
         tasks = workflow['taskSetTasks'].sort { |x,y| x['taskOrder'].to_i <=> y['taskOrder'].to_i }
-        print "\n" ,cyan, bold, "Workflow Details\n","==================", reset, "\n\n"
+        print_h1 "Workflow Details"
+
         print cyan
-        puts "ID: #{workflow['id']}"
-        puts "Name: #{workflow['name']}"
-        #puts "Description: #{workflow['description']}"
+        description_cols = {
+          "ID" => 'id',
+          "Name" => 'name',
+          #"Description" => 'description',
+        }
+        print_description_list(description_cols, workflow)
+
         #task_names = tasks.collect {|it| it['name'] }
-        print "\n", cyan, "Tasks:\n"
-        tasks.each_with_index do |taskSetTask, index|
-          puts "#{(index+1).to_s.rjust(3, ' ')}. #{taskSetTask['task']['name']}"
+        print_h2 "Tasks"
+        if tasks.empty?
+          print yellow,"No tasks in this workflow.",reset,"\n"
+        else
+          print cyan
+          tasks.each_with_index do |taskSetTask, index|
+            puts "#{(index+1).to_s.rjust(3, ' ')}. #{taskSetTask['task']['name']}"
+          end
         end
         print reset,"\n"
       end

data/lib/morpheus/formatters.rb

@@ -1,13 +1,37 @@
 require 'time'
 
+DEFAULT_TIME_FORMAT = "%x %I:%M %p %Z"
+
 # returns an instance of Time
-def parse_time(dt)
+def parse_time(dt, format=nil)
   if dt.nil? || dt == '' || dt.to_i == 0
     return nil
   elsif dt.is_a?(Time)
     return dt
   elsif dt.is_a?(String)
-    return Time.parse(dt)
+    result = nil
+    err = nil
+    begin
+      result = Time.parse(dt)
+    rescue => e
+      err = e
+    end
+    if !result
+      format ||= DEFAULT_TIME_FORMAT
+      if format
+        begin
+          result = Time.strptime(dt, format)
+        rescue => e
+          err = e
+        end
+      end
+    end
+    if result
+      return result
+    else
+      raise "unable to parse time '#{dt}'. #{err}"
+    end
+    
   elsif dt.is_a?(Numeric)
     return Time.at(dt)
   else
@@ -21,7 +45,7 @@ def format_dt(dt, options={})
   if options[:local]
     dt = dt.getlocal
   end
-  format = options[:format] || "%x %I:%M %p %Z"
+  format = options[:format] || DEFAULT_TIME_FORMAT
   return dt.strftime(format)
 end
 
@@ -42,6 +66,77 @@ def format_dt_as_param(dt)
   format_dt(dt, {format: "%Y-%m-%d %X"})
 end
 
+def format_duration(start_time, end_time=nil, format="human")
+  if !start_time
+    return ""
+  end
+  start_time = parse_time(start_time)
+  if end_time
+    end_time = parse_time(end_time)
+  else
+    end_time = Time.now
+  end
+  seconds = (end_time - start_time).abs
+  format_duration_seconds(seconds, format)
+end
+
+def format_duration_seconds(seconds, format="human")
+  seconds = seconds.abs
+  out = ""
+  # interval = Math.abs(interval)
+  if format == "human"
+    out = format_human_duration(seconds)
+  elsif format
+    interval_time = Time.mktime(0) + seconds
+    out = interval_time.strftime(format)
+  else
+    interval_time = Time.mktime(0) + seconds
+    out = interval_time.strftime("%H:%M:%S")
+  end
+  out
+end
+
+# returns a human readable time duration
+# @param seconds - duration in seconds
+def format_human_duration(seconds)
+  out = ""
+  #seconds = seconds.round
+  days, hours, minutes = (seconds / (60*60*24)).floor, (seconds / (60*60)).floor, (seconds / (60)).floor
+  if days > 365
+    out << "#{days.floor} days (more than a year!!)"
+  elsif days > 61
+    out << "#{days.floor} days (months!)"
+  elsif days > 31
+    out << "#{days.floor} days (over a month)"
+  elsif days > 0
+    if days.floor == 1
+      out << "1 day"
+    else
+      out << "#{days.floor} days"
+    end
+  elsif hours > 1
+    if hours == 1
+      out << "1 hour"
+    else
+      out << "#{hours.floor} hours"
+    end
+  elsif minutes > 1
+    if minutes == 1
+      out << "1 minute"
+    else
+      out << "#{minutes.floor} minutes"
+    end
+  else
+    seconds = seconds.floor
+    if seconds == 1
+      out << "1 second"
+    else
+      out << "#{seconds} seconds"
+    end
+  end
+  out
+end
+
 def display_appliance(name, url)
   "#{name} - #{url}"
 end
@@ -49,3 +144,100 @@ end
 def iso8601(dt)
   dt.instance_of(Time) ? dt.iso8601 : "#{dt}"
 end
+
+# get_object_value returns a value within a Hash like object
+# Usage: get_object_value(host, "plan.name")
+def get_object_value(data, key)
+  value = nil
+  if key.is_a?(Proc)
+    return key.call(data)
+  end
+  key = key.to_s
+  if key.include?(".")
+    namespaces = key.split(".")
+    value = data
+    namespaces.each do |ns|
+      if value.respond_to?("key?")
+        if value.key?(ns.to_s)
+          value = value[ns]
+        elsif value.key?(ns.to_sym)
+          value = value[ns.to_sym]
+        else
+          value = nil
+        end
+      else
+        value = nil
+      end
+    end
+  else
+    value = data[key] || data[key.to_sym]
+  end
+  return value
+end
+
+# filter_data filters Hash-like data to only the specified fields
+# To specify fields of child objects, use a "."
+# Usage: filter_data(instance, ["id", "name", "plan.name"])
+def filter_data(data, include_fields=nil, exclude_fields=nil)
+  if !data
+    return data
+  elsif data.is_a?(Array)
+    new_data = data.collect { |it| filter_data(it, include_fields, exclude_fields) }
+    return new_data
+  elsif data.is_a?(Hash)
+    if include_fields
+      #new_data = data.select {|k, v| include_fields.include?(k.to_s) || include_fields.include?(k.to_sym) }
+      # allow extracting dot pathed fields, just like get_object_value
+      my_data = {}
+      include_fields.each do |field|
+        if field.nil?
+          next
+        end
+        field = field.to_s
+        if field.empty?
+          next
+        end
+        if field.include?(".")
+          # could do this instead...
+          # namespaces = field.split(".")
+          # cur_data = data
+          # namespaces.each
+          #   if index != namespaces.length - 1
+          #     cur_data[ns] ||= {}
+          #   else
+          #     cur_data[ns] = get_object_value(new_data, field)
+          #   end
+          # end
+          namespaces = field.split(".")
+          cur_data = data
+          cur_filtered_data = my_data
+          namespaces.each_with_index do |ns, index|
+            if index != namespaces.length - 1
+              if cur_data
+                cur_data = cur_data[ns] || cur_data[ns.to_sym]
+              else
+                cur_data = nil
+              end
+              cur_filtered_data[ns] ||= {}
+              cur_filtered_data = cur_filtered_data[ns]
+            else
+              if cur_data.respond_to?("[]")
+                cur_filtered_data[ns] = cur_data[ns] || cur_data[ns.to_sym]
+              else
+                cur_filtered_data[ns] = nil
+              end
+            end
+          end
+        else
+          my_data[field] = data[field] || data[field.to_sym]
+        end
+      end
+      return my_data
+    elsif exclude_fields
+      new_data = data.reject {|k, v| exclude_fields.include?(k.to_s) || exclude_fields.include?(k.to_sym) }
+      return new_data
+    end
+  else
+    return data # .clone
+  end
+end

data/lib/morpheus/logging.rb

@@ -1,4 +1,5 @@
 require 'logger'
+require 'term/ansicolor'
 
 # Provides global Logging behavior
 # By default, Morpheus::Logging.logger is set to STDOUT with level INFO
@@ -75,4 +76,89 @@ module Morpheus::Logging
     self.debug?
   end
 
+  # An IO class for printing debugging info
+  # This is used as a proxy for ::RestClient.log printing right now.
+  class DarkPrinter
+    include Term::ANSIColor
+
+    # [IO] to write to
+    attr_accessor :io
+
+    # [String] ansi color code for output. Default is dark
+    attr_accessor :color
+
+    # DarkPrinter with io STDOUT
+    def self.instance
+      @instance ||= self.new(STDOUT, nil, true)
+    end
+
+    def self.print(*messages)
+      instance.print(*messages)
+    end
+
+    def self.puts(*messages)
+      instance.puts(*messages)
+    end
+
+    def self.<<(*messages)
+      instance.<<(*messages)
+    end
+
+    def initialize(io, color=nil, is_dark=true)
+      @io = io # || $stdout
+      @color = color # || cyan
+      @is_dark = is_dark
+    end
+
+    # mask well known secrets
+    def scrub_message(msg)
+      if msg.is_a?(String)
+        msg.gsub!(/Authorization\"\s?\=\>\s?\"Bearer [^"]+/, 'Authorization"=>"Bearer ************')
+        msg.gsub!(/Authorization\:\s?Bearer [^"]+/, 'Authorization"=>"Bearer ************')
+        msg.gsub!(/password\"\s?\=\>\s?\"[^"]+/, 'password"=>"************')
+        msg.gsub!(/password\=\"[^"]+/, 'password="************')
+      end
+      msg
+    end
+
+    def print_with_color(&block)
+      if Term::ANSIColor.coloring?
+        @io.print Term::ANSIColor.reset
+        @io.print @color if @color
+        @io.print Term::ANSIColor.dark if @is_dark
+      end
+      yield
+      if Term::ANSIColor.coloring?
+        @io.print Term::ANSIColor.reset
+      end
+    end
+
+    def print(*messages)
+      if @io
+        messages = messages.flatten.collect {|it| scrub_message(it) }
+        print_with_color do 
+          messages.each do |msg|
+            @io.print msg
+          end
+        end
+      end
+    end
+
+    def puts(*messages)
+      if @io
+        messages = messages.flatten.collect {|it| scrub_message(it) }
+        print_with_color do 
+          messages.each do |msg|
+            @io.puts msg
+          end
+        end
+      end
+    end
+
+    def <<(*messages)
+      print(*messages)
+    end
+
+  end
+
 end

data/lib/morpheus/terminal.rb

@@ -0,0 +1,371 @@
+#!/usr/bin/env ruby
+require 'term/ansicolor'
+require 'optparse'
+require 'morpheus/cli'
+require 'morpheus/rest_client'
+require 'morpheus/cli/cli_registry'
+require 'morpheus/cli/dot_file'
+require 'morpheus/cli/error_handler'
+require 'morpheus/logging'
+require 'morpheus/cli'
+
+module Morpheus
+  
+  # Terminal is a class for executing morpheus commands
+  # The default IO is STDIN, STDOUT, STDERR
+  # The default home directory is $HOME/.morpheus
+  #
+  # ==== Example Usage
+  #
+  #    morph = Morpheus::Terminal.new
+  #    exit_code, err = morph.execute("instances list -m 10")
+  #    assert exit_code == 0
+  #    assert err == nil
+  #
+  #    morph = Morpheus::Terminal.new(STDIN, File.new("/tmp/morph.log", "w+"))
+  #    morph.execute("hosts get 23")
+  #
+  #    morph = Morpheus::Terminal.new(STDIN, File.new("/tmp/host23.json", "w"))
+  #    morph.execute("hosts get 23 --json")
+  #    puts File.read("/tmp/host23.json")
+  #
+  class Terminal
+    
+    # todo: this can be combined with Cli::Shell
+
+    class Blackhole # < IO
+      def accrete_data(*mgs)
+        # Singularity.push(*msgs)
+        return nil
+      end
+      alias :print :accrete_data
+      alias :puts :accrete_data
+      alias :'<<' :accrete_data
+      alias :write :accrete_data
+      alias :write :accrete_data
+      # alias :gets :do_nothing
+    end
+
+    # DEFAULT_TERMINAL_WIDTH = 80
+    
+    def self.default_color
+      Term::ANSIColor.cyan
+    end
+
+    def self.prompt
+      if @prompt.nil?
+        if ENV['MORPHEUS_PS1']
+          @prompt = ENV['MORPHEUS_PS1'].dup
+        else
+          #ENV['MORPHEUS_PS1'] = "#{Term::ANSIColor.cyan}morpheus> #{Term::ANSIColor.reset}"
+          @prompt = "#{Term::ANSIColor.cyan}morpheus>#{Term::ANSIColor.reset} "
+        end
+      end
+      @prompt
+    end
+
+    def self.prompt=(v)
+      @prompt = v
+    end
+
+    def self.angry_prompt
+      "#{Term::ANSIColor.red}morpheus: #{Term::ANSIColor.reset}"
+    end
+
+    def self.custom_prompt
+      #export MORPHEUS_PS1='\[\e[1;32m\]\u@\h:\w${text}$\[\e[m\] '
+    end
+
+    # the global Morpheus::Terminal instance
+    # This should go away, but it needed for now...
+    def self.instance
+      @morphterm
+    end
+
+    # hack alert! This should go away, but it needed for now...
+    def self.new(*args)
+      obj = super(*args)
+      @morphterm = obj
+      obj
+    end
+
+    attr_accessor :prompt #, :angry_prompt
+    attr_reader :stdin, :stdout, :stderr, :homedir
+
+
+    # @param stdin  [IO] Default is STDIN
+    # @param stdout [IO] Default is STDOUT
+    # @param stderr [IO] Default is STDERR
+    # @param [IO] stderr
+    # @stderr = stderr
+    # @homedir = homedir
+    # instead, setup global stuff for now...
+    def initialize(stdin=STDIN,stdout=STDOUT, stderr=STDERR, homedir=nil)
+      # todo: establish config context for executing commands, 
+    #       so you can run them in parallel within the same process
+    #       that means not using globals and class instance vars
+    #       just return an exit code / err, instead of raising SystemExit
+    
+      
+      # establish IO
+      # @stdin, @stdout, @stderr = stdin, stdout, stderr
+      set_stdin(stdin)
+      set_stdout(stdout)
+      set_stderr(stderr)
+      
+      # establish home directory
+      @homedir = homedir || ENV['MORPHEUS_CLI_HOME'] || File.join(Dir.home, ".morpheus")
+      Morpheus::Cli.home_directory = @homedir
+      
+      # use colors by default
+      set_coloring(STDOUT.isatty)
+      # Term::ANSIColor::coloring = STDOUT.isatty
+      # @coloring = Term::ANSIColor::coloring?
+
+      # startup script
+      if File.exists? Morpheus::Cli::DotFile.morpheus_profile_filename
+        @profile_dot_file = Morpheus::Cli::DotFile.new(Morpheus::Cli::DotFile.morpheus_profile_filename)
+      else
+        @profile_dot_file = nil
+      end
+      
+      # the string to prompt for input with
+      @prompt ||= Morpheus::Terminal.prompt
+      @angry_prompt ||= Morpheus::Terminal.angry_prompt
+    end
+
+    # execute .morpheus_profile startup script
+    def execute_profile_script(rerun=false)
+      if @profile_dot_file
+        if rerun || !@profile_dot_file_has_run
+          @profile_dot_file_has_run = true
+          return @profile_dot_file.execute() # todo: pass io in here
+        else
+          return false # already run
+        end
+      else
+        return nil
+      end
+    end
+
+    def set_stdin(io)
+      # if io.nil? || io == 'blackhole' || io == '/dev/null'
+      #   @stdout = Morpheus::Terminal::Blackhole.new
+      # else
+      #   @stdout = io
+      # end
+      @stdin = io
+    end
+
+    def set_stdout(io)
+      if io.nil? || io == 'blackhole' || io == '/dev/null'
+        @stdout = Morpheus::Terminal::Blackhole.new
+      else
+        @stdout = io
+      end
+      @stdout
+    end
+
+    def set_stderr(io)
+      if io.nil? || io == 'blackhole' || io == '/dev/null'
+        @stderr = Morpheus::Terminal::Blackhole.new
+      else
+        @stderr = io
+      end
+      @stderr
+    end
+
+    # def coloring=(v)
+    #   set_coloring(enabled)
+    # end
+
+    def set_coloring(enabled)
+      @coloring = !!enabled
+      Term::ANSIColor::coloring = @coloring
+      coloring?
+    end
+
+    def coloring?
+      @coloring == true
+    end
+
+    # alias :'coloring=' :set_coloring
+
+    def usage
+      out = "Usage: morpheus [command] [options]\n"
+      # just for printing help. todo: start using this. maybe in class Cli::MainCommand
+      # 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
+        end
+        opts.on('--noprofile','--noprofile', "Do not read and execute the personal initialization script .morpheus_profile") do
+          @noprofile = true
+        end
+        opts.on('-C','--nocolor', "Disable ANSI coloring") do
+          @coloring = false
+          Term::ANSIColor::coloring = false
+        end
+        opts.on('-V','--debug', "Print extra output for debugging. ") do |json|
+          @terminal_log_level = Morpheus::Logging::Logger::DEBUG
+          Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
+          ::RestClient.log = Morpheus::Logging.debug? ? Morpheus::Logging::DarkPrinter.instance : nil
+        end
+        opts.on( '-h', '--help', "Prints this help" ) do
+          @stdout.puts opts
+          # exit
+        end
+      end
+      out << "Commands:\n"
+      Morpheus::Cli::CliRegistry.all.keys.sort.each {|cmd|
+        out << "\t#{cmd.to_s}\n"
+      }
+      # out << "Options:\n"
+      out << optparse.to_s
+      out << "\n"
+      out << "For more information, see https://github.com/gomorpheus/morpheus-cli/wiki"
+      out << "\n"
+      out
+    end
+
+    def prompt
+      @prompt # ||= Morpheus::Terminal.default_prompt
+    end
+
+    def prompt=(str)
+      @prompt = str
+    end
+
+    def angry_prompt
+      @angry_prompt ||= Morpheus::Terminal.angry_prompt
+    end
+
+    # def gets
+    #   Readline.completion_append_character = " "
+    #   Readline.completion_proc = @auto_complete
+    #   Readline.basic_word_break_characters = ""
+    #   #Readline.basic_word_break_characters = "\t\n\"\‘`@$><=;|&{( "
+    #   input = Readline.readline("#{@prompt}", true).to_s
+    #   input = input.strip
+    #   execute(input)
+    # end
+
+    # def puts(*cmds)
+    #   cmds.each do |cmd|
+    #     self.execute(cmd) # exec
+    #   end
+    # end
+
+    # def gets(*args)
+    #   $stdin.gets(*args)
+    # end
+
+# protected
+
+    def execute(input)
+      exit_code = 0
+      err = nil
+      args = nil
+      if input.is_a? String
+        args = Shellwords.shellsplit(input)
+      elsif input.is_a?(Array)
+        args = input.dup
+      else
+        raise "terminal execute() expects a String to be split or an Array of String arguments and instead got (#{args.class}) #{args}"
+      end
+
+      # include Term::ANSIColor # tempting
+
+      # short circuit version switch
+      if args.length == 1
+        if args[0] == '-v' || args[0] == '--version'
+          @stdout.puts Morpheus::Cli::VERSION
+          return 0, nil
+        end
+      end
+
+      # looking for global help?
+      if args.length == 1
+        if args[0] == '-h' || args[0] == '--help' || args[0] == 'help'
+          @stdout.puts usage
+          return 0, nil
+        end
+      end
+      
+
+      # process global options
+
+      # raise log level right away
+      if args.find {|it| it == '-V' || it == '--debug'}
+        @terminal_log_level = Morpheus::Logging::Logger::DEBUG
+        Morpheus::Logging.set_log_level(Morpheus::Logging::Logger::DEBUG)
+        ::RestClient.log = Morpheus::Logging.debug? ? Morpheus::Logging::DarkPrinter.instance : nil
+      end
+
+      # execute startup script .morpheus_profile  unless --noprofile is passed
+      # todo: this should happen in initialize..
+      noprofile = false
+      if args.find {|it| it == '--noprofile' }
+        noprofile = true
+        args.delete_if {|it| it == '--noprofile' }
+      end
+
+      if @profile_dot_file && !@profile_dot_file_has_run
+        if !noprofile && File.exists?(@profile_dot_file.filename)
+          execute_profile_script()
+        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 a morpheus command. See 'morpheus --help'."
+        #@stderr.puts usage
+        return 127, nil
+      end
+
+      # ok, execute the command (or alias)
+      result = nil
+      begin
+        # 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(args[0], args[1..-1])
+        end
+        # todo: clean up CliCommand return values, handle a few diff types for now
+        if result == nil || result == true || result == 0
+          exit_code = 0
+        elsif result == false
+          exit_code = 1
+        elsif result.is_a?(Array) # exit_code, err
+          exit_code = result[0] #.to_i
+          err = result[1]
+        else
+          exit_code = result #.to_i
+        end
+      rescue => e
+        exit_code = Morpheus::Cli::ErrorHandler.new(@stderr).handle_error(e)
+        err = e
+      end
+
+      return exit_code, err
+
+    end
+
+  end
+end
+