collins_shell 0.2.14

data/lib/collins_shell/util.rb

@@ -0,0 +1,120 @@
+require 'collins_shell/monkeypatch'
+require 'collins_shell/util/asset_stache'
+
+module CollinsShell
+  module Util
+
+    SIZABLE_ATTRIBUTES = [:memory_size_total, :disk_storage_total]
+
+    def call_collins client, operation, &block
+      begin
+        block.call(client)
+      rescue SystemExit => e
+      end
+    end
+
+    def get_selector selector, tags, size, remote = false
+      asset_params = ::Collins::Asset::Find.to_a.inject({}) {|res,el| res.update(el.to_s.upcase => el)}
+      selector = symbolize_hash(selector).inject({}) do |result, (k,v)|
+        upcase_key = k.to_s.upcase
+        if asset_params.key?(upcase_key) then # normalized reserved params
+          corrected_key = asset_params[upcase_key]
+          if ::Collins::Asset::Find::DATE_PARAMS.include?(corrected_key) then
+            result[corrected_key.to_sym] = ::Collins::Asset.format_date_string(v)
+          else
+            result[corrected_key.to_sym] = v
+          end
+        elsif upcase_key == k.to_s then # respect case
+          result[k] = v
+        else # otherwise downcase
+          result[k.downcase] = v
+        end
+        result
+      end
+      if not selector.include?(:operation) then
+        selector.update(:operation => 'and')
+      end
+      if not selector.include?(:remoteLookup) and remote then
+        selector.update(:remoteLookup => remote.to_s)
+      end
+      if not selector.include?(:size) and size then
+        selector.update(:size => size)
+      end
+      selector.update(:details => true) if is_array?(tags)
+      CollinsShell::Util::SIZABLE_ATTRIBUTES.each do |attrib|
+        attrib_value = selector[attrib]
+        if attrib_value && attrib_value.to_s.is_disk_size? then
+          selector.update(attrib => attrib_value.to_s.to_bytes)
+        end
+      end
+      selector
+    end
+
+    def asset_exec asset, execs, confirm = true
+      return unless execs
+      mustache = CollinsShell::Util::AssetStache.new asset
+      rendered = mustache.render "/bin/bash -c '#{execs}'"
+      say_status("exec", rendered, :red)
+      require_yes("Running on #{asset.tag}. ARE YOU SURE?", :red) if confirm
+      system(rendered)
+    end
+
+    def asset_get tag, options
+      call_collins get_collins_client, "get asset" do |client|
+        as_asset = Collins::Asset.new(tag)
+        as_asset.location = options.remote
+        asset = client.get as_asset
+      end
+    end
+
+    def print_find_results assets, tags, options = {}
+      tags = [:tag,:status,:type,:created,:updated,:location] if not is_array?(tags)
+      if options[:url] then
+        tags << :url
+      end
+      if options[:header] then
+        puts(tags.join(','))
+      end
+      [assets].flatten.each do |asset|
+        puts format_asset_tags(asset, tags)
+      end
+    end
+
+    def format_asset_tags asset, tags
+      tags.map do |tag|
+        if tag.to_s =~ /^ipmi_(.*)/ then
+          asset.ipmi.send($1.to_sym)
+        elsif tag.to_s.split('.').length == 2 then
+          o, m = tag.to_s.split('.')
+          result = asset.send(o.to_sym)
+          if result.nil? then
+            "nil"
+          else
+            format_asset_value result.send(m.to_sym)
+          end
+        elsif tag == :url then
+          config = get_collins_config
+          " #{config[:host]}/asset/#{asset.tag}"
+        else
+          result = asset.send(tag.to_sym)
+          format_asset_value result
+        end
+      end.join(',')
+    end
+
+    def format_asset_value value
+      if is_array? value then
+        value.map {|v| format_asset_value v}
+      elsif value.is_a?(Collins::Address) then
+        [:address,:gateway,:netmask].map {|s| value.send(s)}.join('|')
+      else
+        value.to_s
+      end
+    end
+
+    def is_array? tags
+      tags && tags.is_a?(Array) && tags.length > 0
+    end
+
+  end
+end

data/lib/collins_shell/util/asset_printer.rb

@@ -0,0 +1,265 @@
+require 'terminal-table'
+require 'collins_shell/util/printer_util'
+
+module CollinsShell
+
+  class AssetPrinter
+
+    include CollinsShell::PrinterUtil
+
+    attr_accessor :asset, :detailed, :table, :col_size, :thor, :separator, :logs, :color
+
+    def initialize asset, thor, options = {}
+      @asset = asset
+      @table = Terminal::Table.new
+      @thor = thor
+      @separator = options[:separator]
+      @detailed = options.fetch(:detailed, true)
+      @col_size = 6
+      @color = options.fetch(:color, true)
+      @logs = options[:logs]
+    end
+
+    def render
+      table.title = header_text("Asset #{asset.tag}")
+      collect_asset_basics
+      collect_disk_data if detailed
+      collect_ip_data if detailed
+      collect_ipmi_data if detailed
+      collect_nic_data if detailed
+      collect_mem_data if detailed
+      collect_power_data if detailed
+      collect_xtra_data
+      collect_log_data
+      table_s = table.render
+      if separator then
+        width = (0...@col_size).inject(0) do |result, idx|
+          result + table.column_width(idx)
+        end
+        sep_s = separator * (1.13 * width.to_f).to_i
+        table_s + "\n#{sep_s}\n"
+      else
+        table_s
+      end
+    end
+    alias :to_s :render
+
+    def collect_asset_basics
+      header = [:tag,:status,:type,:created,:updated,:location]
+      table << get_row(header, true, header.length)
+      table << :separator
+      table << get_row(header.map{|s| asset.send(s)}, false, header.length)
+      if asset.state && !asset.state.empty? then
+        state = asset.state
+        state_headers = [
+          title_text("State Name"),
+          title_text("State Label"),
+          {:value => title_text("State Description"), :colspan => 4}
+        ]
+        table << :separator
+        table << state_headers
+        table << :separator
+        table << [state.name, state.label, {:value => state.description, :colspan => 4}]
+      end
+      @col_size = table.number_of_columns
+    end
+
+    def collect_disk_data
+      disk_header = ["SIZE_HUMAN", "SIZE", "TYPE", "DESCRIPTION"]
+      row_title "Disks"
+      table << get_row(disk_header, true)
+      table << :separator
+      asset.disks.each do |disk|
+        table << get_row(disk_header.map{|s| disk[s]})
+      end
+    end
+
+    def collect_log_data
+      return if (not logs or logs.empty?)
+      row_title "Log Entries"
+      headers = [
+        title_text("Created"),
+        title_text("Severity"),
+        title_text("Source"),
+        title_text("Format"),
+        {:value => title_text("Message"), :colspan => 2}
+      ]
+      table << headers
+      table << :separator
+      have_multi_row = false
+      logs_formatted = logs.map do |log|
+        rewritten_msg = log.MESSAGE.strip
+        message = wrap_text(rewritten_msg).strip
+        if message != rewritten_msg then
+          have_multi_row = true
+        end
+        [
+          format_datetime(log.CREATED), log.TYPE, log.SOURCE, log.FORMAT,
+          {:value => message, :colspan => 2}
+        ]
+      end
+      last_log_idx = logs.length - 1
+      logs_formatted.each_with_index do |row, index|
+        table << row
+        # Don't print a separator if we don't have a multi-row message
+        if index != last_log_idx && have_multi_row then
+          table << :separator
+        end
+      end
+    end
+
+    def collect_ip_data
+      address_header = [:address,:gateway,:netmask,:pool,:is_private?,:is_public?]
+      row_title "IP Addresses"
+      table << get_row(address_header, true)
+      table << :separator
+      asset.addresses.each{|a| table << get_row(address_header.map{|s| a.send(s)})}
+    end
+
+    def collect_ipmi_data
+      ipmi_header = [:address,:gateway,:netmask,:username,:password]
+      row_title "IPMI Information"
+      table << get_row(ipmi_header, true)
+      table << :separator
+      table << get_row(ipmi_header.map {|i| asset.ipmi.send(i)})
+    end
+
+    def collect_nic_data
+      nic_header = ["SPEED_HUMAN", "MAC_ADDRESS", "DESCRIPTION"]
+      row_title "Network Interfaces"
+      table << get_row(nic_header, true)
+      table << :separator
+      asset.nics.each {|nic| table << get_row(nic_header.map{|s| nic[s]})}
+    end
+
+    def collect_mem_data
+      memory_header = ["BANK","SIZE","SIZE_HUMAN","DESCRIPTION"]
+      row_title "Physical Memory"
+      table << get_row(memory_header, true)
+      table << :separator
+      memory_total = 0
+      asset.memory.each do |mem|
+        memory_total += mem["SIZE"].to_i
+        if mem["SIZE"].to_i != 0 then
+          table << get_row(memory_header.map{|s| mem[s]})
+        end
+      end
+      table << :separator
+      table << [title_text("TOTAL SIZE (Bytes)"), {:value => memory_total.to_s, :colspan => 5}]
+      table << [title_text("TOTAL SIZE (Human)"), {:value => memory_total.to_human_size, :colspan => 5}]
+    end
+
+    def collect_power_data
+      power_header = [:type,:key,:value,:label]
+      row_title "Power Information"
+      table << get_row(power_header, true)
+      table << :separator
+      asset.power.each do |power|
+        power.units.each do |unit|
+          table << get_row(power_header.map {|key| unit.send(key)})
+        end
+      end
+    end
+
+    def format_text key, value
+      key_s = key.to_s.downcase
+      if key_s.start_with?("json_") or key_s.end_with?("_json") then
+        begin
+          JSON.parse(value, :symbolize_names => true).to_s
+        rescue Exception => e
+          value
+        end
+      else
+        value
+      end
+    end
+
+    def collect_xtra_data
+      return unless (asset.extras and asset.extras["ATTRIBS"] && asset.extras["ATTRIBS"]["0"])
+      row_title "Extra Attributes"
+      attribs = []
+      attribs_unsorted = asset.extras["ATTRIBS"]["0"]
+      attribs_sorted = attribs_unsorted.keys.sort.inject({}) do |result,key|
+        result.update(key => attribs_unsorted[key])
+      end
+      attribs_sorted.each do |key,value|
+        attribs << title_text(key)
+        attribs << format_text(key, value)
+        if attribs.length == 6 then
+          table << attribs
+          attribs = []
+        end
+        if CollinsShell::Util::SIZABLE_ATTRIBUTES.include?(key.downcase.to_sym) then
+          attribs << title_text("#{key} (Human)")
+          attribs << value.to_f.to_human_size
+        end
+        if attribs.length == 6 then
+          table << attribs
+          attribs = []
+        end
+      end
+      if attribs.length != 0 then
+        until attribs.length == 6
+          attribs << " "
+        end
+        table << attribs
+      end
+    end
+
+    def header_text txt
+      if @color then
+        thor.set_color(txt, :bold, :magenta)
+      else
+        txt
+      end
+    end
+    def title_text txt
+      if @color then
+        thor.set_color(txt, :bold, :white)
+      else
+        txt
+      end
+    end
+    def regular_text txt
+      txt
+    end
+
+    def get_row row_data, header = false, cols = 0
+      num_cols = @col_size
+      row_length = row_data.length
+      last_index = row_length - 1
+      average_size = (num_cols.to_f / row_length.to_f)
+      est_size = (num_cols / row_length)
+      est_is_actual = (average_size == est_size)
+      used_cols = 0
+      row = []
+      row_data.each_with_index do |col,index|
+        if est_is_actual then
+          size_per_col = est_size
+        elsif index == 0 then
+          size_per_col = 1
+        elsif average_size > (used_cols.to_f/index.to_f) then
+          size_per_col = 2
+        else
+          size_per_col = 1
+        end
+        if col.is_a?(DateTime) then
+          col = format_datetime(col)
+        end
+        used_cols += size_per_col
+        alignment = if size_per_col > 1 then :center else :left end
+        value = if header then title_text(col) else regular_text(col) end
+        row << {:value => value, :alignment => alignment, :colspan => size_per_col}
+      end
+      row
+    end
+
+    def row_title txt
+      table << :separator
+      table << [{:value => header_text(txt), :alignment => :center, :colspan => @col_size}]
+      table << :separator
+    end
+
+  end
+
+end

data/lib/collins_shell/util/asset_stache.rb

@@ -0,0 +1,32 @@
+require 'mustache'
+
+module CollinsShell; module Util
+
+  class AssetStache < Mustache
+    attr_accessor :asset
+
+    def initialize asset
+      @asset = asset
+    end
+
+    def respond_to? meth
+      result = asset.send(meth.to_sym)
+      if result.nil? then
+        super
+      else
+        result
+      end
+    end
+
+    def method_missing meth, *args, &block
+      result = asset.send(meth.to_sym)
+      if result.nil? then
+        super
+      else
+        result
+      end
+    end
+
+  end
+
+end; end

data/lib/collins_shell/util/log_printer.rb

@@ -0,0 +1,187 @@
+require 'terminal-table'
+require 'collins_shell/util/printer_util'
+
+module CollinsShell
+
+  class LogPrinter
+
+    include CollinsShell::PrinterUtil
+
+    attr_reader :asset_tag, :logs, :options, :table, :table_width
+
+    def initialize asset_or_tag, logs
+      @asset_tag = Collins::Util.get_asset_or_tag(asset_or_tag).tag
+      if logs.is_a?(Hash) then
+        @logs = logs.delete(:logs) || []
+        @options = logs
+      else
+        @logs = logs
+        @options = {}
+      end
+      @table_width = 0
+      @table = Terminal::Table.new(:title => "Logs for #{asset_tag}")
+    end
+
+    def render _logs = []
+      setup_table
+      setup_header
+      need_separator, formatted_logs = format_logs _logs
+      add_logs_to_table need_separator, formatted_logs
+      render!
+    end
+    alias :to_s :render
+
+    protected
+    # Add the specified logs to the table instance, using a separator if required
+    def add_logs_to_table need_separator, logs
+      last_log_idx = logs.length - 1
+      logs.each_with_index do |row, index|
+        table << row
+        # Don't print a separator if we don't have a multi-row message
+        if index != last_log_idx && need_separator then
+          table << :separator
+        end
+      end
+    end
+
+    # Format logs appropriately for table layout
+    def format_logs _logs
+      have_multi_row = streaming? # either false (default), or true based on streaming
+      logs_to_render = if not _logs.empty? then _logs else logs end
+      logs_formatted = logs_to_render.map do |log|
+        entry = format_log_entry log
+        have_multi_row = true unless entry.find_index{|e| e.to_s.include?("\n")}.nil?
+        entry
+      end
+      [have_multi_row, logs_formatted]
+    end
+
+    # We force column values to pad so terminal-table doesn't try and be smart
+    def format_column value, width, alignment
+      value_s = value.to_s.strip
+      if value_s.size > width then
+        alignment = :left # force to left is we wrap
+        value_s = wrap_text(value_s, width).strip
+      end
+      case alignment
+      when :left
+        value_s.ljust(width)
+      when :right
+        value_s.rjust(width)
+      else
+        value_s.center(width)
+      end
+    end
+
+    def format_log_entry log
+      res = []
+      if streaming? then
+        res = [
+          format_column(format_datetime(log.CREATED), created_col_width, :center),
+          format_column(log.TYPE, severity_col_width, :center),
+          format_column(log.SOURCE, source_col_width, :center),
+          format_column(log.FORMAT, format_col_width, :center),
+          format_column(log.MESSAGE, message_col_width, :left)
+        ]
+        res.unshift(format_column(log.ASSET_TAG, tag_col_width, :left)) if requires_tag?
+      else
+        res = [
+          format_datetime(log.CREATED), log.TYPE, log.SOURCE, log.FORMAT, wrap_text(log.MESSAGE.strip).strip
+        ]
+        res.unshift(log.ASSET_TAG) if requires_tag?
+      end
+      res
+    end
+
+    # Grab the rendered table and reset the table instance
+    def render!
+      if displayed? then
+        buffer = table.rows.map do |row|
+          row.render + "\n" + Terminal::Table::Separator.new(table).render
+        end.join("\n")
+      else
+        buffer = table.render
+      end
+      set_displayed
+      @table = Terminal::Table.new
+      buffer
+    end
+
+    # If needed setup table headings
+    def setup_header
+      if options.fetch(:header, true) and not displayed? then
+        if streaming? then
+          headings = [
+            format_column("Created", created_col_width, :center),
+            format_column("Severity", severity_col_width, :center),
+            format_column("Source", source_col_width, :center),
+            format_column("Format", format_col_width, :center),
+            format_column("Message", message_col_width, :center)
+          ]
+          headings.unshift(format_column("Asset", tag_col_width, :center)) if requires_tag?
+        else
+          headings = [
+            "Created", "Severity", "Source", "Format", "Message"
+          ]
+          headings.unshift("Asset") if requires_tag?
+        end
+        table.headings = headings
+      end
+    end
+
+    # Setup table width according to options
+    def setup_table
+      # Only setup table style once. Either dynamic or based on width of 
+      if streaming? and not displayed? then
+        # If logs will be streaming, use the maximum width for the table
+        term_width = dynamic_terminal_width
+        @table_width = term_width
+        table.style = {:width => table_width}
+      elsif streaming? then
+        table.style = {:width => table_width}
+      end
+    end
+
+    def streaming?
+      options.fetch(:streaming, false)
+    end
+
+    def displayed?
+      @already_displayed
+    end
+    def set_displayed
+      @already_displayed = true
+    end
+
+    # Require a tag if mode is all
+    def requires_tag?
+      @requires_tag ||= (options.fetch(:all_tag, nil).to_s.downcase == asset_tag.to_s.downcase)
+    end
+
+    def created_col_width
+      19 # this is the formatted datetime
+    end
+    def severity_col_width
+      13 # width of INFORMATIONAL
+    end
+    def source_col_width
+      8 # width of INTERNAL
+    end
+    def format_col_width
+      16 # width of application/json
+    end
+    def tag_col_width
+      requires_tag? ? 24 : 0
+    end
+
+    # This needs to take into account all the styling and such to avoid terminal table throwing an
+    # exception
+    def message_col_width
+      cells = requires_tag? ? 6 : 5
+      dyn_width = (table.cell_spacing * cells) + table.style.border_y.length
+      table_width - created_col_width - severity_col_width - source_col_width - format_col_width - tag_col_width - dyn_width
+    end
+
+  end # class LogPrinter
+
+end # module CollinsShell