mtncloud-cli 1.0.0

data/lib/mtncloud/cli/commands/logs_command.rb

@@ -0,0 +1,140 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::LogsCommand
+  include MtnCloud::Cli::CliCommand
+  include MtnCloud::Cli::LogsHelper
+  register_subcommands :list
+  set_command_name :'logs'
+
+  def initialize()
+    # @appliance_name, @appliance_url = MtnCloud::Cli::Remote.active_appliance
+  end
+
+  def connect(opts)
+    @api_client = establish_remote_appliance_connection(opts)
+    @logs_interface = @api_client.logs
+    @servers_interface = @api_client.servers
+    @containers_interface = @api_client.containers
+    @clusters_interface = @api_client.clusters
+  end
+
+  def usage
+    "Usage: #{prog_name} #{command_name}"
+  end
+
+  def handle(args)
+    # list(args)
+    handle_subcommand(args)
+  end
+
+  def list(args)
+    options = {}
+    params = {}
+    optparse = MtnCloud::Cli::OptionParser.new do |opts|
+      opts.banner = subcommand_usage("[search]")
+      opts.on('--hosts HOSTS', String, "Filter logs to specific Host ID(s)") do |val|
+        params['servers'] = val.to_s.split(",").collect {|it| it.to_s.strip }.select {|it| it }.compact
+      end
+      opts.on('--servers HOSTS', String, "alias for --hosts") do |val|
+        params['servers'] = val.to_s.split(",").collect {|it| it.to_s.strip }.select {|it| it }.compact
+      end
+      opts.on('--vms HOSTS', String, "alias for --hosts") do |val|
+        params['servers'] = val.to_s.split(",").collect {|it| it.to_s.strip }.select {|it| it }.compact
+      end
+      opts.on('--container CONTAINER', String, "Filter logs to specific Container ID(s)") do |val|
+        params['containers'] = val.to_s.split(",").collect {|it| it.to_s.strip }.select {|it| it }.compact
+      end
+      # opts.on('--nodes HOST', String, "alias for --containers") do |val|
+      #   params['containers'] = val.to_s.split(",").collect {|it| it.to_s.strip }.select {|it| it }.compact
+      # end
+      opts.on('--cluster ID', String, "Filter logs to specific Cluster ID") do |val|
+        params['clusters'] = val.to_s.split(",").collect {|it| it.to_s.strip }.select {|it| it }.compact
+      end
+      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('--interval TIME','--interval TIME', "Interval of time to include, in seconds. Default is 30 days ago.") do |val|
+      #   options[:interval] = 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('-t', '--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 all hosts and containers."
+    end
+    optparse.parse!(args)
+    if args.count > 0
+      options[:phrase] = args.join(" ")
+    end
+    connect(options)
+    begin
+      params['level'] = params['level'].collect {|it| it.to_s.upcase }.join('|') if params['level'] # api works with INFO|WARN
+      params.merge!(parse_list_options(options))
+      if params['phrase']
+        options.delete(:phrase)
+        search_phrase = params.delete('phrase')
+        params['query'] = search_phrase
+      end
+      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]
+      params['interval'] = options[:interval].to_s if options[:interval]
+      # could find_by_name_or_id for params['servers'] and params['containers']
+      @logs_interface.setopts(options)
+      if options[:dry_run]
+        print_dry_run @logs_interface.dry.list(params)
+        return
+      end
+      json_response = @logs_interface.list(params)
+      render_result = json_response['logs'] ? render_with_format(json_response, options, 'logs') : render_with_format(json_response, options, 'data')
+      return 0 if render_result
+
+      title = "Logs"
+      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
+      if params['servers']
+        subtitles << "Servers: #{params['servers']}".strip
+      end
+      if params['containers']
+        subtitles << "Containers: #{params['containers']}".strip
+      end
+      if params['clusters']
+        subtitles << "Clusters: #{params['clusters']}".strip
+      end
+      if params['level']
+        subtitles << "Level: #{params['level']}"
+      end
+      print_h1 title, subtitles, options
+      logs = json_response['data'] || json_response['logs']
+      if logs.empty?
+        print "#{cyan}No logs found.#{reset}\n"
+      else
+        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
+    rescue RestClient::Exception => e
+      print_rest_exception(e, options)
+      exit 1
+    end
+  end
+
+end

data/lib/mtncloud/cli/commands/man_command.rb

@@ -0,0 +1,409 @@
+require 'mtncloud/cli/cli_command'
+
+class MtnCloud::Cli::ManCommand
+  include MtnCloud::Cli::CliCommand
+  set_command_name :man
+  set_command_hidden
+
+  # this should be read only anyway...
+  @@default_editor = "less" # ENV['EDITOR']
+
+  def self.man_file_path
+    File.join(MtnCloud::Cli.home_directory, "CLI-Manual-#{MtnCloud::Cli::VERSION}.md")
+  end
+
+  def handle(args)
+    options = {}
+    regenerate = false
+    open_as_link = false # true please
+    editor = @@default_editor
+    #todo: windows
+    if !$stdin.tty?
+      editor = "cat"
+    end
+    # no editor for windows atm
+    if MtnCloud::Cli.windows?
+      open_as_link = true
+    end
+    optparse = MtnCloud::Cli::OptionParser.new do|opts|
+      opts.banner = "Usage: #{prog_name} man"
+      opts.on('-e','--editor EDITOR', "Specify which program to open the manual with. Default is '#{editor}'.") do |val|
+        editor = val
+        open_as_link = false
+      end
+      opts.on('-g','--generate', "Regenerate the manual file") do
+        regenerate = true
+      end
+      opts.on('-o','--out FILE', "Write manual file to a custom location") do |val|
+        options[:outfile] = val
+      end
+      opts.on('--overwrite', '--overwrite', "Overwrite output file if it already exists.") do |val|
+        options[:overwrite] = true
+      end
+      opts.on('-q','--quiet', "Do not open manual, for use with the -g option.") do
+        options[:quiet] = true
+      end
+      #build_common_options(opts, options, [:quiet])
+      # disable ANSI coloring
+      opts.on('-C','--nocolor', "Disable ANSI coloring") do
+        Term::ANSIColor::coloring = false
+      end
+
+      opts.on('-V','--debug', "Print extra output for debugging. ") do
+        MtnCloud::Logging.set_log_level(MtnCloud::Logging::Logger::DEBUG)
+        ::RestClient.log = MtnCloud::Logging.debug? ? MtnCloud::Logging::DarkPrinter.instance : nil
+      end
+      opts.on('-h', '--help', "Print this help" ) do
+        puts opts
+        exit
+      end
+      opts.footer = <<-EOT
+Open the #{prog_name} manual located at #{MtnCloud::Cli::ManCommand.man_file_path}
+The -g option can be used to regenerate the file.
+The --out FILE option be used to write the manual file to a custom location.
+EOT
+    end
+    optparse.parse!(args)
+    verify_args!(args:args, optparse:optparse, count:0)
+
+    fn = MtnCloud::Cli::ManCommand.man_file_path
+    if options[:outfile]
+      regenerate = true
+      fn = File.expand_path(options[:outfile])
+      if File.directory?(fn)
+        # if you give me a directory, could still work and use the default filename
+        # fn = File.join(fn, "CLI-Manual-#{MtnCloud::Cli::VERSION}.md")
+        # raise_command_error "outfile is invalid. It is the name of an existing directory: #{fn}"
+        print_error "#{red}Output file '#{fn}' is invalid.#{reset}\n"
+        print_error "#{red}It is the name of an existing directory.#{reset}\n"
+        return 1
+      end
+      if File.exist?(fn) && options[:overwrite] != true
+        print_error "#{red}Output file '#{fn}' already exists.#{reset}\n"
+        print_error "#{red}Use --overwrite to overwrite the existing file.#{reset}\n"
+        return 1
+      end
+    end
+    exit_code, err = 0, nil
+    if regenerate || !File.exist?(fn)
+      #MtnCloud::Logging::DarkPrinter.puts "generating manual #{fn} ..." if MtnCloud::Logging.debug? && !options[:quiet]
+      exit_code, err = generate_manual(options)
+    end
+    
+    if options[:quiet]
+      return exit_code, err
+    end
+    
+    MtnCloud::Logging::DarkPrinter.puts "opening manual file #{fn}" if MtnCloud::Logging.debug? && !options[:quiet]
+    
+    if open_as_link # windows only atm
+      link = "file://#{fn}"
+      if RbConfig::CONFIG['host_os'] =~ /mswin|mingw|cygwin/
+        system "start #{link}"
+      elsif RbConfig::CONFIG['host_os'] =~ /darwin/
+        system "open #{link}"
+      elsif RbConfig::CONFIG['host_os'] =~ /linux|bsd/
+        system "xdg-open #{link}"
+      end
+      return 0, nil
+    else
+      if editor
+        if !system_command_available?(editor)
+          raise_command_error "The editor program '#{editor}' is not available on your system."
+          # puts_error "#{red}The editor program '#{editor}' is not available on your system.#{reset}"
+          # return 1
+        end        
+        system("#{editor} #{fn}")
+      else
+        raise_command_error "Tell me how to open the manual file #{fn}. Try -e emacs or run export EDITOR=emacs"
+        return 1
+      end
+    end
+
+    return 0, nil
+  end
+
+  # determine if system command is available
+  # uses *nix's `which` command.
+  # Prevents using dangerous commands rm,mv,passwd
+  # todo: support for Windows and PowerShell
+  def system_command_available?(cmd)
+    has_it = false
+    begin
+      cmd = cmd.strip.gsub("'",'')
+      system("which '#{cmd}' > /dev/null 2>&1")
+      has_it = $?.success?
+    rescue => e
+      raise e
+    end
+    return has_it
+  end
+
+  # def self.save_manual(fn, content)
+  #   # fn = MtnCloud::Cli::ManCommand.man_file_path
+  #   if !Dir.exist?(File.dirname(fn))
+  #     FileUtils.mkdir_p(File.dirname(fn))
+  #   end
+  #   MtnCloud::Logging::DarkPrinter.puts "saving manual to #{fn}" if MtnCloud::Logging.debug?
+  #   File.open(fn, 'w') {|f| f.write content.to_s } #Store
+  #   FileUtils.chmod(0600, fn)
+  # end
+
+  def generate_manual(options={})
+    # todo: use pandoc or something else to convert the CLI-Manual.md to a man page
+    # and install it, so the os command `man mtncloud` will work too.
+    fn = MtnCloud::Cli::ManCommand.man_file_path
+    if options[:outfile]
+      fn = File.expand_path(options[:outfile])
+      if File.exist?(fn) && options[:overwrite] != true
+        print_error "#{red}Output file '#{options[:outfile]}' already exists.#{reset}\n"
+        print_error "#{red}Use --overwrite to overwrite the existing file.#{reset}\n"
+        return 1, "output file already exists"
+      end
+    end
+    if !Dir.exist?(File.dirname(fn))
+      FileUtils.mkdir_p(File.dirname(fn))
+    end
+    MtnCloud::Logging::DarkPrinter.puts "generating manual #{fn}" if MtnCloud::Logging.debug? && !options[:quiet]
+
+    File.open(fn, 'w') {|f| f.write("") } # clear file
+    FileUtils.chmod(0600, fn)
+
+    manpage = File.new(fn, 'w')
+    # previous_stdout = $stdout
+    # previous_stdout = STDOUT
+    # $stdout = manpage
+    begin
+
+      manpage.print <<-ENDTEXT
+#{prog_name} v#{MtnCloud::Cli::VERSION}
+
+## NAME
+
+    mtncloud - the command line interface for MTN Cloud
+
+    mcs is a short alias for mtncloud. Both commands run the same CLI.
+
+## SYNOPSIS
+
+    mtncloud [command] [<args>] [options]
+    mcs [command] [<args>] [options]
+
+## DESCRIPTION
+
+    MTN Cloud CLI
+
+    This is a command line interface for managing MTN Cloud.
+    All communication with the remote appliance is done via the MTN Cloud API.
+
+    Use the command `#{prog_name} remote add` to connect to MTN Cloud.
+
+## GLOBAL OPTIONS
+
+    There are several global options available.
+
+    -v, --version                    Print the version.
+        --noprofile                  Do not read and execute the personal initialization script .mtncloud_profile
+    -C, --nocolor                    Disable ANSI coloring
+    -V, --debug                      Print extra output for debugging. 
+    -h, --help                       Print this help
+
+## COMMON OPTIONS
+
+    There are many common options that are supported by a most commands.
+
+    -O, --option OPTION              Option value in the format -O var="value" (deprecated soon in favor of first class options)
+    -N, --no-prompt                  Skip prompts. Use default values for all optional fields.
+        --payload FILE               Payload from a local JSON or YAML file, skip all prompting
+        --payload-dir DIRECTORY      Payload from a local directory containing 1-N JSON or YAML files, skip all prompting
+        --payload-json JSON          Payload JSON, skip all prompting
+        --payload-yaml YAML          Payload YAML, skip all prompting
+    -j, --json                       JSON Output
+    -d, --dry-run                    Dry Run, print the API request instead of executing it
+        --curl                       Dry Run to output API request as a curl command.
+        --scrub                      Mask secrets in output, such as the Authorization header. For use with --curl and --dry-run.
+    -r, --remote REMOTE              Remote name. The current remote is used by default.
+        --remote-url URL             Remote url. This allows adhoc requests instead of using a configured remote.
+    -T, --token TOKEN                Access token for authentication with --remote. Saved credentials are used by default.
+    -U, --username USERNAME          Username for authentication.
+    -P, --password PASSWORD          Password for authentication.
+    -I, --insecure                   Allow insecure HTTPS communication.  i.e. bad SSL certificate.
+    -H, --header HEADER              Additional HTTP header to include with requests.
+        --timeout SECONDS            Timeout for api requests. Default is typically 30 seconds.
+    -y, --yes                        Auto Confirm
+    -q, --quiet                      No Output, do not print to stdout
+
+## COMMANDS
+
+    The mtncloud executable is divided into commands.
+    Each command may have 0-N sub-commands that it supports.
+    Commands generally map to the functionality provided in the MTN Cloud UI.
+
+    You can get help for any command by using the -h option.
+
+    The available commands and their options are documented below.
+ENDTEXT
+      
+      
+      #terminal = MtnCloud::Terminal.new($stdin, manpage)
+      terminal = my_terminal
+      terminal.with_stdout(manpage) do
+
+      MtnCloud::Logging::DarkPrinter.puts "appending command help `#{prog_name} --help`" if MtnCloud::Logging.debug? && !options[:quiet]
+
+      manpage.print "\n"
+      manpage.print "## #{prog_name}\n"
+      manpage.print "\n"
+      manpage.print "```\n"
+      exit_code, err = terminal.execute("--help")
+      manpage.print "```\n"
+      manpage.print "\n"
+      # output help for every command (that is not hidden)
+      MtnCloud::Cli::CliRegistry.all.keys.sort.each do |cmd|
+        cmd_klass = MtnCloud::Cli::CliRegistry.instance.get(cmd)
+        cmd_instance = cmd_klass.new
+        MtnCloud::Logging::DarkPrinter.puts "appending command help `#{prog_name} #{cmd} --help`" if MtnCloud::Logging.debug? && !options[:quiet]
+        #help_cmd = "mtncloud #{cmd} --help"
+        #help_output = `#{help_cmd}`
+        manpage.print "\n"
+        manpage.print "### #{prog_name} #{cmd}\n"
+        manpage.print "\n"
+        manpage.print "```\n"
+        begin
+          cmd_instance.handle(["--help"])
+        rescue SystemExit => err
+          raise err unless err.success?
+        end
+        manpage.print "```\n"
+        # subcommands = cmd_klass.subcommands
+        subcommands = cmd_klass.visible_subcommands
+        if subcommands && subcommands.size > 0
+          subcommands.sort.each do |subcommand, subcommand_method|
+            MtnCloud::Logging::DarkPrinter.puts "appending command help `#{prog_name} #{cmd} #{subcommand} --help`" if MtnCloud::Logging.debug? && !options[:quiet]
+            manpage.print "\n"
+            manpage.print "#### #{prog_name} #{cmd} #{subcommand}\n"
+            manpage.print "\n"
+            manpage.print "```\n"
+            begin
+              cmd_instance.handle([subcommand, "--help"])
+            rescue SystemExit => err
+              raise err unless err.success?
+            end
+            manpage.print "```\n"
+            # manpage.print "\n"
+          end
+        end
+        manpage.print "\n"
+      end
+
+      manpage.print <<-ENDTEXT
+
+## ENVIRONMENT VARIABLES
+
+### MTNCLOUD_CLI_HOME
+
+The **MTNCLOUD_CLI_HOME** variable is where mtncloud stores its configuration files.
+This can be set to allow a single system user to maintain many different configurations.
+If the directory does not exist, mtncloud will attempt to create it.
+
+The default home directory is **$HOME/.mtncloud**
+
+To see how this works, run the following:
+
+```shell
+MTNCLOUD_CLI_HOME=~/.mtncloud_test mtncloud shell
+```
+
+Now, in your new mtncloud shell, you can see that it is a fresh environment.
+There are no remotes configured.
+
+```shell
+mtncloud> remote list
+No remote appliances configured. See the command `remote add`.
+```
+
+You can use this to create isolated environments (sandboxes), within which to execute your mtncloud commands.
+
+```shell
+export MTNCLOUD_CLI_HOME=~/mtncloud_test
+mtncloud remote add demo https://console.cloud.mtn.ng
+mtncloud instances list
+```
+
+mtncloud saves the remote appliance information, including API access tokens,
+to the CLI home directory. These files are saved with file permissions **0600**.
+So, only one system user should be allowed to execute mtncloud with that home directory.
+See [Configuration](#Configuration) for more information on the files mtncloud reads and writes.
+
+## CONFIGURATION
+
+mtncloud reads and writes several configuration files within the $MTNCLOUD_CLI_HOME directory.
+
+**Note:** These files are maintained by the program. It is not recommended for you to manipulate them.
+
+### appliances file
+
+The `appliances` YAML file contains a list of known appliances, keyed by name.
+
+Example:
+```yaml
+:mtncloud:
+  :url: https://console.cloud.mtn.ng
+:test:
+  :url: https://test.example.com
+```
+
+### credentials file
+
+The `.mtncloud/credentials` YAML file contains access tokens for each known appliance.
+
+### groups file
+
+The `.mtncloud/groups` YAML file contains the active group information for each known appliance.
+
+
+## Startup scripts
+
+When mtncloud starts, it executes the commands in a couple of dot files.
+
+These scripts are written in mtncloud commands, not bash, so they can only execute mtncloud commands and aliases.
+
+### .mtncloud_profile file
+
+It looks for `$MTNCLOUD_CLI_HOME/.mtncloud_profile`, and reads and executes it (if it exists).
+
+This may be inhibited by using the `--noprofile` option.
+
+### .mtncloudrc file
+
+When started as an interactive shell with the `#{prog_name} shell` command,
+mtncloud reads and executes `$MTNCLOUD_CLI_HOME/.mtncloudrc` (if it exists). This may be inhibited by using the `--norc` option.
+
+An example startup script might look like this:
+
+```
+# .mtncloudrc
+
+set-prompt "%cyan%username%reset@%magenta%remote %cyanmtncloud> %reset"
+version
+remote current
+echo "Welcome back %username"
+echo
+
+```
+
+ENDTEXT
+    
+    end # end with_stdout(manpage)
+
+    ensure
+      manpage.close if manpage
+      # $stdout = previous_stdout if previous_stdout
+      # this is needed to re-establish instance with STDOUT, STDIN
+      #terminal = MtnCloud::Terminal.new()
+    end
+
+    return 0, nil
+  end
+
+end