motoko 1.0.0

data/exe/inventory

@@ -0,0 +1,46 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+# Or use Puppet's Ruby: #!/opt/puppetlabs/puppet/bin/ruby
+#
+# Call-seq: ./inventory.rb -F form_factor=Server -v
+
+require 'motoko'
+require 'mcollective'
+
+include MCollective::RPC # rubocop:disable Style/MixinUsage
+
+formatter = Motoko::Formatter.new
+
+options = rpcoptions do |parser, local_options|
+  parser.banner = "usage: #{File.basename(__FILE__)} [options]"
+
+  Motoko::OptionParser.add_inventory_options(parser, formatter)
+
+  parser.on('--[no-]stats', 'Display statistics') do |v|
+    local_options[:stats] = v
+  end
+
+  Motoko::OptionParser.add_shortcut_options(parser, formatter, local_options)
+end
+
+options[:stats] = true if options[:stats].nil?
+
+util = rpcclient('rpcutil', options: options)
+util.progress = false
+
+(options[:with_class] || []).compact.each do |klass|
+  util.class_filter(klass)
+end
+
+(options[:with_fact] || []).compact.each do |fact|
+  util.fact_filter(fact)
+end
+
+util.inventory do |_, resp|
+  formatter.nodes << Motoko::Node::Choria.new(resp)
+end
+
+puts formatter.to_s
+
+printrpcstats if options[:stats]

data/exe/pdb-inventory

@@ -0,0 +1,58 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require 'mcollective'
+require 'motoko'
+require 'optparse'
+
+filters = []
+
+oparser = Motoko::OptionParser.new
+
+options = {}
+
+oparser.parse do |parser|
+  parser.separator ''
+  parser.separator 'Host Filters'
+
+  parser.on('-C', '--wc', '--with-class CLASS', 'Match hosts with a certain config management class') do |with_class|
+    filters << Motoko::Utils::PuppetDB.class_filter(with_class)
+  end
+
+  parser.on('-F', '--wf', '--with-fact fact=val', 'Match hosts with a certain fact') do |with_fact|
+    filters << Motoko::Utils::PuppetDB.fact_filter(with_fact)
+  end
+
+  parser.on('-I', '--wi', '--with-identity IDENT', 'Match hosts with a certain configured identity') do |with_ident|
+    filters << Motoko::Utils::PuppetDB.identity_filter(with_ident)
+  end
+
+  Motoko::OptionParser.add_shortcut_options(parser, oparser.formatter, options)
+end
+
+(options[:with_class] || []).compact.each do |klass|
+  filters << Motoko::Utils::PuppetDB.class_filter(klass)
+end
+
+(options[:with_fact] || []).compact.each do |fact|
+  filters << Motoko::Utils::PuppetDB.fact_filter(fact)
+end
+
+config = MCollective::Config.instance
+config.loadconfig(MCollective::Util.config_file_for_user)
+
+client = MCollective::Util::Choria.new
+
+response = client.pql_query("facts[certname, name, value] { #{filters.map { |f| "(#{f})" }.join(' and ')} }")
+
+nodes = Hash.new { |hash, value| hash[value] = {} }
+
+response.each do |fact|
+  nodes[fact['certname']][fact['name']] = fact['value']
+end
+
+nodes.each do |sender, facts|
+  oparser.formatter.nodes << Motoko::Node.new(sender, facts)
+end
+
+puts oparser.formatter.to_s

data/lib/motoko.rb

@@ -0,0 +1,28 @@
+# frozen_string_literal: true
+
+require 'motoko/config'
+require 'motoko/formatter'
+require 'motoko/formatters/base_formatter'
+require 'motoko/formatters/boolean'
+require 'motoko/formatters/datetime'
+require 'motoko/formatters/datetime_ago'
+require 'motoko/formatters/ellipsis'
+require 'motoko/formatters/timestamp'
+require 'motoko/formatters/timestamp_ago'
+require 'motoko/node'
+require 'motoko/option_parser'
+require 'motoko/resolvers/base_resolver'
+require 'motoko/resolvers/cpu'
+require 'motoko/resolvers/fact'
+require 'motoko/resolvers/identity'
+require 'motoko/resolvers/os'
+require 'motoko/resolvers/reboot_required'
+require 'motoko/utils/puppet_db'
+require 'motoko/utils/snake_to_camel'
+require 'motoko/utils/time_ago'
+require 'motoko/version'
+
+module Motoko
+  class Error < StandardError; end
+  # Your code goes here...
+end

data/lib/motoko/config.rb

@@ -0,0 +1,78 @@
+# frozen_string_literal: true
+
+require 'yaml'
+
+module Motoko
+  class Config
+    attr_accessor :columns, :sort_by, :columns_spec, :shortcuts
+
+    def initialize
+      @columns = %w[host customer role]
+      @sort_by = %w[customer host]
+      @shortcuts = Hash.new { {} }
+      @columns_spec = Hash.new { {} }.merge(default_columns_spec)
+
+      load_system_config
+      load_user_config
+    end
+
+    def load_system_config
+      [
+        '/usr/local/etc/motoko',
+        '/etc/motoko',
+      ].each do |d|
+        if File.directory?(d)
+          load_config(d)
+          break
+        end
+      end
+    end
+
+    def load_user_config
+      d = File.expand_path('~/.config/motoko')
+      load_config(d) if File.directory?(d)
+    end
+
+    def load_config(directory)
+      load_classes(directory)
+
+      filename = File.join(directory, 'config.yaml')
+
+      return unless File.readable?(filename)
+
+      config = YAML.safe_load(File.read(filename))
+
+      @columns = config.delete('columns') if config.key?('columns')
+      @sort_by = config.delete('sort_by') if config.key?('sort_by')
+
+      @shortcuts.merge!(config.delete('shortcuts')) if config.key?('shortcuts')
+      @columns_spec.merge!(config.delete('columns_spec')) if config.key?('columns_spec')
+    end
+
+    def load_classes(directory)
+      Dir["#{directory}/formatters/*.rb", "#{directory}/resolvers/*.rb"].sort.each do |file|
+        require file
+      end
+    end
+
+    def default_columns_spec
+      YAML.safe_load(<<~COLUMNS_SPEC)
+        ---
+        host:
+          resolver: identity
+        customer:
+          formatter: ellipsis
+          max_length: 20
+        cpu:
+          resolver: cpu
+        os:
+          resolver: os
+          human_name: Operating System
+        reboot_required:
+          resolver: reboot_required
+          formatter: boolean
+          human_name: R
+      COLUMNS_SPEC
+    end
+  end
+end

data/lib/motoko/formatter.rb

@@ -0,0 +1,82 @@
+# frozen_string_literal: true
+
+require 'skittlize'
+require 'terminal-table'
+
+require 'motoko/utils/snake_to_camel'
+
+module Motoko
+  class Formatter
+    attr_reader :options, :columns_spec, :shortcuts
+    attr_accessor :columns, :nodes, :mono, :wide, :count, :sort_by
+
+    include Motoko::Utils::SnakeToCamel
+
+    def initialize
+      config = Config.new
+      @nodes = []
+      @columns = config.columns
+      @mono = false
+      @wide = false
+      @count = false
+      @sort_by = config.sort_by
+      @columns_spec = config.columns_spec
+      @shortcuts = config.shortcuts
+    end
+
+    def to_s
+      return '' if nodes.empty?
+
+      @rows = nil
+      @column_resolvers = nil
+
+      columns.uniq!
+
+      table = ::Terminal::Table.new headings: headings, rows: data
+      column_resolvers.each_with_index do |column, idx|
+        table.align_column(idx, column.align) if column.align
+      end
+      table.to_s
+    end
+
+    def column_resolvers
+      @column_resolvers ||= columns.map do |column|
+        klass = columns_spec[column].delete('resolver') || 'Fact'
+
+        Object.const_get("Motoko::Resolvers::#{snake_to_camel_case(klass)}").new(column, columns_spec[column])
+      end
+    end
+
+    def data
+      return @data if @data
+
+      @data = sorted_nodes.map! do |node|
+        column_resolvers.map do |column|
+          column.value(node)
+        end
+      end
+
+      @data.skittlize!(split: "\n", join: ', ') unless mono
+
+      @data
+    end
+
+    def headings
+      column_resolvers.each_with_index.map do |column, idx|
+        name = column.human_name
+        if count
+          different_values = data.map { |line| line[idx] }.uniq.compact.count
+          name += " (#{different_values})" if different_values > 1
+        end
+        {
+          value: mono ? name : "\e[1m#{name}\e[0m",
+          alignment: :center,
+        }
+      end
+    end
+
+    def sorted_nodes
+      nodes.sort_by { |a| sort_by.map { |c| a.fact(c) || '' } + [a.identity] }
+    end
+  end
+end

data/lib/motoko/formatters/base_formatter.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Motoko
+  module Formatters
+    class BaseFormatter
+      def initialize(options = {}) end
+
+      def format(value)
+        case value
+        when Array
+          value.join("\n")
+        when Hash
+          value.keys.join("\n")
+        else
+          value.to_s
+        end
+      end
+    end
+  end
+end

data/lib/motoko/formatters/boolean.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Motoko
+  module Formatters
+    class Boolean < BaseFormatter
+      def format(value)
+        value ? '√' : nil
+      end
+    end
+  end
+end

data/lib/motoko/formatters/datetime.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Motoko
+  module Formatters
+    class Datetime < BaseFormatter
+      def format(value)
+        DateTime.parse(value).to_time.getlocal.to_s
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+  end
+end

data/lib/motoko/formatters/datetime_ago.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'motoko/utils/time_ago'
+
+require 'date'
+
+module Motoko
+  module Formatters
+    class DatetimeAgo < BaseFormatter
+      include Motoko::Utils::TimeAgo
+
+      def format(value)
+        return nil unless value
+
+        seconds_to_human(Time.now - DateTime.parse(value).to_time)
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/motoko/formatters/ellipsis.rb

@@ -0,0 +1,22 @@
+# frozen_string_literal: true
+
+module Motoko
+  module Formatters
+    class Ellipsis < BaseFormatter
+      attr_accessor :max_length
+
+      def initialize(options = {})
+        super
+        @max_length = options.delete('max_length') || 20
+      end
+
+      def format(value)
+        return nil unless value
+
+        res = value.dup
+        res[(max_length - 1)..-1] = '…' if res.length > max_length
+        res
+      end
+    end
+  end
+end

data/lib/motoko/formatters/timestamp.rb

@@ -0,0 +1,15 @@
+# frozen_string_literal: true
+
+require 'date'
+
+module Motoko
+  module Formatters
+    class Timestamp < BaseFormatter
+      def format(value)
+        Time.at(Integer(value)).getlocal.to_s
+      rescue ArgumentError, TypeError
+        nil
+      end
+    end
+  end
+end

data/lib/motoko/formatters/timestamp_ago.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'motoko/utils/time_ago'
+
+require 'date'
+
+module Motoko
+  module Formatters
+    class TimestampAgo < BaseFormatter
+      include Motoko::Utils::TimeAgo
+
+      def format(value)
+        return nil unless value
+
+        seconds_to_human(Time.now - Time.at(Integer(value)))
+      rescue ArgumentError
+        nil
+      end
+    end
+  end
+end

data/lib/motoko/node.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+module Motoko
+  class Node
+    attr_reader :identity
+
+    def initialize(identity, facts)
+      @identity = identity
+      @facts    = facts
+    end
+
+    def fact(name)
+      result = @facts
+      components = name.to_s.split('.')
+      while (component = components.shift)
+        case result
+        when Hash
+          result = result[component]
+        when Array
+          result = result[Integer(component)]
+        when NilClass
+          return nil
+        end
+      end
+      result
+    end
+
+    class Choria < Motoko::Node
+      def initialize(node)
+        super(node[:sender], node[:data][:facts])
+      end
+    end
+  end
+end