collins_shell 0.2.14

data/lib/collins_shell/console.rb

@@ -0,0 +1,129 @@
+require 'terminal-table'
+require 'pry'
+
+require 'collins_shell/console/commands'
+require 'collins_shell/console/filesystem'
+
+class Pry
+  # We kill the built in completion so we can tell users what things are available
+  module InputCompleter
+    class << self
+      def build_completion_proc(target, commands=[""])
+        proc do |input|
+          commands.map do |cmd|
+            cmd_s = cmd.to_s
+            if cmd_s.include?(":wtf") then
+              "wtf?"
+            else
+              cmd_s
+            end
+          end.select{|s| s.start_with?(input)}.uniq # commands.map
+        end # proc do
+      end # def build_completion_proc
+    end # class << self
+  end # module InputCompleter
+end # class Pry
+
+module CollinsShell; module Console
+
+  class << self
+    def run_pry_command command_string, options = {}
+      options = {
+        :show_output => true,
+        :output => Pry.output,
+        :commands => get_pry_commands
+      }.merge!(options)
+      output = options[:show_output] ? options[:output] : StringIO.new
+      pry = Pry.new(
+              :output => output, :input => StringIO.new(command_string),
+              :commands => options[:commands], :prompt => proc{""}, :hooks => Pry::Hooks.new
+      )
+      if options[:binding_stack] then
+        pry.binding_stack = options[:binding_stack]
+      end
+      pry.rep(options[:context])
+    end
+    def launch(options)
+      self.options = options
+      Pry.config.commands = get_pry_commands
+      Pry.config.pager = true
+      Pry.custom_completions = get_pry_custom_completions
+      Pry.config.exception_handler = get_pry_exception_handler
+      target = CollinsShell::Console::Filesystem.new options
+      setup_pry_hooks
+      Pry.start(target, :prompt => get_pry_prompt)
+    end
+    def options=(options)
+      @options = options
+    end
+    def options
+      @options
+    end
+    private
+    def setup_pry_hooks
+      before_message = [
+        'Welcome to the collins console. A few notes:',
+        ' - collins-shell interacts with real servers (BE CAREFUL).',
+        ' - collins-shell operates in contexts, which the prompt tells you about.',
+        ' - collins-shell can be customized to your tastes. Read the docs.',
+        ' - Type help at any time for help'
+      ].join("\n")
+      Pry.config.hooks.add_hook(:before_session, :session_start) do |out, *|
+        out.puts before_message
+      end
+      Pry.config.hooks.add_hook(:after_session, :session_end) do |out, *|
+        out.puts "Goodbye!"
+      end
+    end
+    def get_pry_prompt
+      get_prompt = proc { |o, waiting|
+        sym = waiting ? "*" : ">"
+        if o.is_a?(CollinsShell::Console::Filesystem) then
+          ext = ""
+          if o.asset? then
+            ext = "*"
+          end
+          "collins #{o.path}#{ext} #{sym} "
+        else
+          "collins-#{o.class} #{sym} "
+        end
+      }
+      [
+        proc { |o, *| get_prompt.call(o, false) },
+        proc { |o, *| get_prompt.call(o, true) }
+      ]
+    end
+    def get_pry_custom_completions
+      proc do
+        last = binding_stack.last
+        last = last.eval('self') unless last.nil?
+        if last.is_a?(CollinsShell::Console::Filesystem) then
+          (last.available_commands + commands.commands.keys).flatten
+        else
+          commands.commands.keys
+        end
+      end
+    end
+    def get_pry_exception_handler
+      proc do |output, exception, _pry_|
+        if exception.is_a?(Interrupt) then
+          output.puts ""
+        else
+          cli = CollinsShell::Cli.new [], {}
+          cli.print_error exception, "command failed"
+          output.puts ""
+          bold = Pry::Helpers::Text.bold("type 'bt' or 'wtf?!?' for more context")
+          output.puts bold
+        end
+      end
+    end
+    def get_pry_commands
+      Pry::CommandSet.new do
+        import_from Pry::Commands, "help", "history", "hist", "wtf?", "show-doc", "show-source"
+        alias_command "bt", "wtf?"
+        import CollinsShell::Console::Commands::Default
+      end
+    end
+  end
+
+end; end

data/lib/collins_shell/console/asset.rb

@@ -0,0 +1,127 @@
+module CollinsShell; module Console
+  class Asset
+    include CollinsShell::Console::CommandHelpers
+
+    attr_reader :tag
+    def initialize asset
+      @tag = asset
+      @asset_client = collins_client.with_asset(@tag)
+    end
+    def power! action = nil
+      Collins::Option(action).map do |action|
+        action = Collins::Power.normalize_action(action)
+        verifying_response("power #{action}") {
+          @asset_client.power!(action)
+        }
+      end.get_or_else {
+        cput("A power action argument is required. power <action>")
+      }
+    end
+    def reboot! how = "rebootSoft"
+      Collins::Option(how).map do |how|
+        action = Collins::Power.normalize_action(how)
+        verifying_response("reboot") {
+          @asset_client.power!(action)
+        }
+      end.get_or_else {
+        cput("A reboot argument is required. reboot <action>")
+      }
+    end
+    def stat
+      s = <<-STAT
+         Asset: #{underlying.tag}
+        Status: #{underlying.status}
+          Type: #{underlying.type}
+      Hostname: #{Collins::Option(underlying.hostname).get_or_else("(none)")}
+       Created: #{Collins::Option(underlying.created).get_or_else("(none)")}
+       Updated: #{Collins::Option(underlying.updated).get_or_else("(none)")}
+       Deleted: #{Collins::Option(underlying.deleted).get_or_else("(none)")}
+      STAT
+      cput(s)
+    end
+    def set_status! status = nil, reason = nil
+      msg = "set_status request a %s. set_status <status>, <reason>"
+      (raise sprintf(msg, "status")) if status.nil?
+      (raise sprintf(msg, "reason")) if reason.nil?
+      verifying_response("set the status to '#{status}' on") {
+        @asset_client.set_status!(status, reason)
+      }
+    end
+    def log! msg, level = nil
+      (raise "log requires a message. log <message>") if (msg.nil? || msg.to_s.empty?)
+      @asset_client.log!(msg, level)
+    end
+    def logs options = {}
+      @asset_client.logs(options)
+    end
+    def set! key = nil, value = nil, group_id = nil
+      msg = "set requires a %s. set <key>, <value>"
+      (raise sprintf(msg, "key")) if key.nil?
+      (raise sprintf(msg, "value")) if value.nil?
+      case value
+      when String, Symbol, Fixnum, TrueClass, FalseClass then
+        value = value.to_s
+      else
+        raise "value can't be a #{value.class}"
+      end
+      verifying_response("set the key '#{key}' to '#{value}' on") {
+        @asset_client.set_attribute!(key.to_s, value, group_id)
+      }
+    end
+    def rm! key = nil, group_id = nil
+      (raise "rm requires a key. rm <key>") if key.nil?
+      verifying_response("delete the key '#{key}' on") {
+        @asset_client.delete_attribute!(key, group_id)
+      }
+    end
+    def key? key = nil
+      (raise "key? requires a key. key? <key>") if key.nil?
+      @asset_client.get.send("#{key}?".to_sym)
+    end
+    def key key = nil
+      (raise "key requires a key. key <key>") if key.nil?
+      @asset_client.get.send(key.to_sym)
+    end
+    def on?
+      power? == "on"
+    end
+    def power?
+      @asset_client.power_status
+    end
+    def respond_to? meth, include_private = false
+      if meth.to_sym == :asset then
+        true
+      elsif @asset_client.respond_to?(meth) then
+        true
+      else
+        super
+      end
+    end
+    protected
+    def method_missing meth, *args, &block
+      if meth.to_sym == :asset then
+        underlying
+      elsif @asset_client.respond_to?(meth) then
+        @asset_client.send(meth, *args, &block)
+      else
+        super
+      end
+    end
+    def underlying
+      @underlying ||= get_asset(@tag)
+    end
+    def verifying_response message, &block
+      message = "You are about to #{message} asset #{tag}. Are you sure? "
+      if shell_handle.require_yes(message, :red, false) then
+        block.call
+      else
+        cput("Aborted operation")
+      end
+    end
+    def cput message
+      Pry.output.puts(message)
+    end
+
+  end # class CollinsShell::Console::Asset
+
+end; end

data/lib/collins_shell/console/cache.rb

@@ -0,0 +1,17 @@
+# This is a very basic shared cache class
+module CollinsShell; module Console; module Cache
+  @@_cache = {}
+
+  def clear_cache
+    @@_cache = {}
+  end
+
+  def cache_get_or_else key, &block
+    if @@_cache[key].nil? then
+      @@_cache[key] = block.call
+    else
+      @@_cache[key]
+    end
+  end
+
+end; end; end

data/lib/collins_shell/console/command_helpers.rb

@@ -0,0 +1,131 @@
+require 'collins_shell/console/cache'
+
+module CollinsShell; module Console; module CommandHelpers
+
+  include CollinsShell::Console::Cache
+
+  # @return [Boolean] true if asset associated with specified tag exists
+  def asset_exists? tag
+    m = "asset_exists?(#{tag})"
+    cache_get_or_else(m) {
+      call_collins(m) {|c| c.exists?(tag)}
+    }
+  end
+
+  # @return [Collins::Asset] associated with the specified tag
+  def get_asset tag
+    m = "get_asset(#{tag})"
+    cache_get_or_else(m) {
+      call_collins(m) {|c| c.get(tag)}
+    }
+  end
+
+  # @return [Object] result of calling collins using the specifed block
+  def call_collins operation, &block
+    shell_handle.call_collins(collins_client, operation, &block)
+  end
+  # @return [Collins::Client] A Collins::Client instance
+  def collins_client
+    shell_handle.get_collins_client cli_options
+  end
+
+  # @return [Hash] CLI specified options
+  def cli_options
+    CollinsShell::Console.options
+  end
+
+  # @return [Array<Collins::Asset>,NilClass]
+  def find_one_asset tags_values, details = true
+    find_assets(tags_values, details).first
+  end
+
+  # Given an array of keys and values, return matching assets
+  # @param [Array<String>] tags_values an array where even elements are keys for a search and odd elements are values
+  # @param [Boolean] details If true, return full assets, otherwise return a sorted array of tags
+  # @return [Array<Collins::Asset>,Array<String>]
+  def find_assets tags_values, details
+    q = tags_values.each_slice(2).inject({}) {|h,o| h.update(o[0].to_s.to_sym => o[1])}
+    q.update(:details => details)
+    selector = shell_handle.get_selector(q, nil, 5000)
+    call_collins("find(#{selector})") do |c|
+      if details then
+        c.find(selector)
+      else
+        c.find(selector).map{|a| a.tag}.sort
+      end
+    end
+  end
+
+  # @return [Array<String>,Array<Collins::Asset>] an array of values associated with the specified tag, or the asset associated with that tag if resolve asset is true.
+  def get_tag_values tag, resolve_asset = true
+    m = "get_tag_values(#{tag}, #{resolve_asset.to_s})"
+    cache_get_or_else(m) {
+      call_collins(m) {|c| c.get_tag_values(tag)}.sort
+    }
+  rescue Exception => e
+    if e.is_a?(Collins::RequestError) then
+      if e.code.to_i == 404 then
+        [get_asset(tag)] if resolve_asset
+      else
+        raise e
+      end
+    else
+      [get_asset(tag)] if resolve_asset
+    end
+  end
+
+  def virtual_tags
+    Collins::Asset::Find.to_a
+  end
+
+  # return known tags including virtual ones (ones not stored, but that can be used as
+  # query parameters
+  def get_all_tags include_virtual = true
+    begin
+      cache_get_or_else("get_all_tags(#{include_virtual.to_s})") {
+        tags = call_collins("get_all_tags"){|c| c.get_all_tags}.map{|t|t.name}
+        if include_virtual then
+          [tags + Collins::Asset::Find.to_a].flatten.sort
+        else
+          tags.sort
+        end
+      }
+    rescue Exception => e
+      puts "Error retrieving tags: #{e}"
+      []
+    end
+  end
+
+  # Given a possible string tag and the context stack, find the asset tag
+  # @param [NilClass,String] tag a possible tag for use
+  # @param [Array<Binding>] stack the context stack
+  # @return [String,NilClass] Either the given tag, the tag on the top of the context stack, or nil if neither is available
+  def resolve_asset_tag tag, stack
+    Collins::Option(tag).map{|s| s.strip}.filter_not{|s| s.empty?}.get_or_else {
+      tag_from_stack stack
+    }
+  end
+
+  # @return [CollinsShell::Util] a handle on the CLI interface
+  def shell_handle
+    CollinsShell::Asset.new([], cli_options)
+  end
+
+  # @param [Array<Binding>] stack the context stack
+  # @return [NilClass,String] the asset tag at the top of the stack, if it exists
+  def tag_from_stack stack
+    node = stack.last
+    node = node.eval('self') unless node.nil?
+    if node and node.asset? then
+      node.console_asset.tag
+    else
+      nil
+    end
+  end
+
+  # @return [Boolean] true if in asset context
+  def asset_context? stack
+    !tag_from_stack(stack).nil?
+  end
+
+end; end; end

data/lib/collins_shell/console/commands.rb

@@ -0,0 +1,28 @@
+require 'pry'
+
+require 'collins_shell/console/options_helpers'
+require 'collins_shell/console/command_helpers'
+require 'collins_shell/console/commands/cd'
+require 'collins_shell/console/commands/cat'
+require 'collins_shell/console/commands/tail'
+require 'collins_shell/console/commands/io'
+require 'collins_shell/console/commands/iterators'
+require 'collins_shell/console/commands/versions'
+
+# TODO List
+# * Confirmation for destructive options
+# * Docs
+# * Remote
+# * Testing
+# * Ssh
+# * Ping
+module CollinsShell; module Console; module Commands
+  Default = Pry::CommandSet.new do
+    import CollinsShell::Console::Commands::Cd
+    import CollinsShell::Console::Commands::Cat
+    import CollinsShell::Console::Commands::Tail
+    import CollinsShell::Console::Commands::Io
+    import CollinsShell::Console::Commands::Iterators
+    import CollinsShell::Console::Commands::Versions
+  end
+end; end; end

data/lib/collins_shell/console/commands/cat.rb

@@ -0,0 +1,123 @@
+require 'pry'
+
+module CollinsShell; module Console; module Commands
+  Cat = Pry::CommandSet.new do
+    create_command "cat", "Output data associated with the specified asset" do
+
+      include CollinsShell::Console::CommandHelpers
+
+      group "I/O"
+
+      def options(opt)
+        opt.banner <<-BANNER
+          Usage: cat [-l|--logs] [-b|--brief] [--help]
+
+          Cat the specified asset or log.
+
+          If you are in an asset context, cat does not require the asset tag. In an asset context you can do:
+            cat                               # no-arg displays current asset
+            cat -b                            # short-display
+            cat -l                            # table formatted logs
+            cat /var/log/SEVERITY             # display logs of a specified type
+            cat /var/log/messages             # all logs
+          If you are not in an asset context, cat requires the tag of the asset you want to display.
+            cat                               # display this help
+            cat asset-tag                     # display asset
+            cat -b asset-tag                  # short-display
+            cat -l asset-tag                  # table formatted logs
+            cat /var/log/assets/asset-tag     # display logs for asset
+            cat /var/log/hosts/hostname       # display logs for host with name
+        BANNER
+        opt.on :b, "brief", "Brief output, not detailed"
+        opt.on :l, "logs", "Display logs as well"
+      end
+
+      def process
+        stack = _pry_.binding_stack
+        if args.first.to_s.start_with?('/var/log/') then
+          display_logs args.first, stack
+        else
+          tag = resolve_asset_tag args.first, stack
+          if tag.nil? then
+            run "help", "cat"
+            return
+          end
+          display_asset tag
+        end
+      end
+
+      # Given a logfile specification, parse it and render it
+      def display_logs logfile, stack
+        rejects = ['var', 'log']
+        paths = logfile.split('/').reject{|s| s.empty? || rejects.include?(s)}
+        if paths.size == 2 then
+          display_sub_logs paths[0], paths[1]
+        elsif paths.size == 1 then
+          display_asset_logs tag_from_stack(stack), paths[0]
+        else
+          run "help", "cat"
+        end
+      end
+
+      # Render logs of the type `/var/log/assets/TAG` or `/var/log/hosts/HOSTNAME`
+      def display_sub_logs arg1, arg2
+        if arg1 == 'assets' then
+          display_asset_logs arg2, 'messages'
+        elsif arg1 == 'hosts' then
+          asset = find_one_asset(['HOSTNAME', arg2])
+          display_asset_logs asset, 'messages'
+        else
+          output.puts "#{text.bold('Invalid log type:')} Only 'assets' or 'hosts' are valid, found '#{arg1}'"
+          output.puts
+          run "help", "cat"
+        end
+      end
+
+      # Render logs for an asset according to type, where type is 'messages' (all) or a severity
+      def display_asset_logs asset_tag, type
+        begin
+          asset = Collins::Util.get_asset_or_tag(asset_tag).tag
+        rescue => e
+          output.puts "#{text.bold('Invalid asset:')} '#{asset_tag}' not valid - #{e}"
+          return
+        end
+        severity = Collins::Api::Logging::Severity
+        severity_level = severity.value_of type
+        if type == 'messages' then
+          get_and_print_logs asset_tag, "ASC"
+        elsif not severity_level.nil? then
+          get_and_print_logs asset_tag, "ASC", severity_level
+        else
+          message = "Only '/var/log/messages' or '/var/log/SEVERITY' are valid here"
+          sevs = severity.to_a.join(', ')
+          output.puts "#{text.bold('Invalid path specified:')}: #{message}"
+          output.puts "Valid severity levels are: #{sevs}"
+        end
+      end
+
+      def display_asset tag
+        if asset_exists? tag then
+          asset = get_asset tag
+          show_logs = opts.logs?
+          show_details = !opts.brief?
+          show_color = Pry.color
+          logs = []
+          logs = call_collins("logs(#{tag})") {|c| c.logs(tag, :size => 5000)} if show_logs
+          printer = CollinsShell::AssetPrinter.new asset, shell_handle, :logs => logs, :detailed => show_details, :color => show_color
+          render_output printer.to_s
+        else
+          output.puts  "#{text.bold('No such asset:')} #{tag}"
+        end
+      end
+
+      def get_and_print_logs asset_tag, sort, filter = nil, size = 5000
+        logs = call_collins "logs(#{asset_tag})" do |client|
+          client.logs asset_tag, :sort => sort, :size => size, :filter => filter
+        end
+        printer = CollinsShell::LogPrinter.new asset_tag, logs
+        output.puts printer.to_s
+      end
+
+    end # create_command
+  end # CommandSet
+end; end; end