inventory-server 0.0.1

data/lib/inventory/server.rb

@@ -0,0 +1,30 @@
+require 'middleware'
+require "inventory/server/version"
+require "inventory/server/loader"
+require "inventory/server/config"
+require "inventory/server/logger"
+
+module Inventory
+  module Server
+    class Server
+      attr_reader :config, :middlewares
+
+      def initialize(cli_config)
+        config = Config.generate(cli_config)
+        @config = config
+
+        InventoryLogger.setup(config[:logger])
+        InventoryLogger.logger.level = config[:log_level]
+
+        # Dynamically load plugins from plugins_path
+        plugin_names = config[:plugins].split(',')
+        @middlewares = Middleware::Builder.new do
+          plugins = Loader.new(config).load_plugins(*plugin_names)
+          plugins.each {|klass|
+            use klass, config
+          }
+        end
+      end
+    end
+  end
+end

data/lib/inventory/server/cli.rb

@@ -0,0 +1,59 @@
+require 'optparse'
+require "inventory/server/version"
+
+module Inventory
+  module Server
+
+    class CLI
+      
+      attr_reader :options
+
+      def initialize()
+        @options = {}
+      end
+
+      def parse!(args)
+        OptionParser.new do|opts|
+          opts.banner = "Usage: server [options]"
+          opts.separator ""
+          opts.separator "Specific options:"
+
+          opts.on("--host HOST", String, "IP or hostname to listen on") do |h|
+            @options[:host] = h
+          end
+
+          opts.on("--smtp_port PORT", Integer, "SMTP port to listen on") do |p|
+            @options[:smtp_port] = p
+          end
+
+          opts.on("-es", "--es_host URL", String, "ElasticSerach HTTP URL") do |url|
+            @options[:es_host] = url
+          end
+
+          opts.on("-o", "--output OUTPUT", String, "Log destination stdout/stderr/file") do |o|
+            @options[:logger] = o
+          end
+
+          opts.on("-l", "--level LEVEL", ['DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL'], "log level that will be printed DEBUG/INFO/WARN/ERROR/FATAL") do |l|
+            @options[:log_level] = l
+          end
+
+          opts.on("-d", "--[no-]debug", "how more details, need log_level on DEBUG") do |d|
+            @options[:debug] = d
+          end
+
+          opts.on_tail("-h", "--help", "Show this message") do
+            puts opts
+            exit
+          end
+
+          opts.on_tail("--version", "Show version") do
+            puts VERSION
+            exit
+          end
+        end.parse! args
+        @options
+      end
+    end
+  end
+end

data/lib/inventory/server/config.rb

@@ -0,0 +1,80 @@
+require 'app_configuration'
+require 'fileutils'
+require "inventory/server/logger"
+
+module Inventory
+  module Server
+
+    module Config
+      DEFAULTS = {
+        :host => '127.0.0.1',
+        :smtp_port => 2525,
+        :max_connections => 4,
+        :debug => false,
+        :es_host => 'http://localhost:9200',
+        :es_index_prefix => 'inventory_',
+        :failed_facts_dir => '/var/log/inventory/failures',
+        :logger => 'stdout',
+        :log_level => 'INFO',
+        :type_key => 'type',
+        :type_default => 'facts',
+        :version_key => 'version',
+        :version_default => '1-0-0',
+        :json_schema_dir => '/etc/inventory/json_schema',
+        :plugins_path => '',
+        :plugins => 'log_failures_on_disk,facts_parser,json_schema_validator,index',
+      }
+
+      def self.generate(cli_config)
+
+        global = AppConfiguration.new('inventory.yml') do
+          base_global_path '/etc'
+          use_env_variables true
+          prefix 'inventory' # ENV prefix: INVENTORY_XXXXX
+        end
+
+        config = {}
+
+        DEFAULTS.each{|sym, default_value|
+
+          val =  cli_config[sym] || global[sym.to_s] || default_value
+          result = val
+
+          # cast config values (ENV values are strings only)
+          if default_value.is_a? Integer
+            result = val.to_i
+          elsif !!default_value == default_value
+            # Boolean
+            if val == true || val =~ /^(true|t|yes|y|1)$/i
+              result = true
+            elsif val == false || val.blank? || val =~ /^(false|f|no|n|0)$/i
+              result = false
+            end
+          # Logging
+          elsif val == 'stdout'
+            result = $stdout
+          elsif val == 'stderr'
+            result = $stderr
+          # Logging Level
+          elsif val == 'INFO'
+            result = Logger::INFO
+          elsif val == 'DEBUG'
+            result = Logger::DEBUG
+          elsif val == 'WARN'
+            result = Logger::WARN
+          elsif val == 'ERROR'
+            result = Logger::ERROR
+          elsif val == 'FATAL'
+            result = Logger::FATAL
+          end
+          config[sym] = result
+        }
+
+        FileUtils.mkdir_p config[:failed_facts_dir]
+
+        config
+      end
+    end
+  end
+end
+

data/lib/inventory/server/email_parser.rb

@@ -0,0 +1,28 @@
+require "mail"
+require 'inventory/server/inventory_error'
+require "inventory/server/logger"
+
+module Inventory
+  module Server
+    class EmailParser
+      def self.parse(message)
+        InventoryLogger.logger.info "Email parser"
+
+        # Parse the email
+        email = Mail.read_from_string(message)
+
+        # Use email subject as an ID
+        email_subject = email.subject
+        raise InventoryError.new "email subject is missing" if email_subject.nil? || email_subject.empty?
+        id = email_subject
+
+        # Decode the email body
+        email_body = email.body.decoded
+        raise InventoryError.new "email body is missing" if email_body.nil? || email_body.empty?
+        body = email_body
+
+        return id, body
+      end
+    end
+  end
+end

data/lib/inventory/server/http_server.rb

@@ -0,0 +1,49 @@
+require 'sinatra'
+require 'json'
+require 'inventory/server/inventory_error'
+require "inventory/server/logger"
+
+module Inventory
+  module Server
+    class HTTPServer < Sinatra::Base
+
+      configure do
+        logger = Object.new.tap do |proxy|
+          def proxy.<<(message)
+            InventoryLogger.logger.info message
+          end
+          def proxy.write(message)
+            InventoryLogger.logger.info message
+          end
+          def proxy.flush; end
+        end
+
+        use Rack::CommonLogger, logger
+
+        before {
+          env["rack.errors"] = logger
+        }
+
+        Rack::Utils.key_space_limit = 262144 
+
+        HTTPServer.set :raise_errors, false
+        HTTPServer.set :dump_errors, false
+      end
+
+      post "/api/v1/facts/:id" do
+        content_type :json
+        id= params[:id]
+        env[:id] = id
+        InventoryLogger.logger.context_id = id
+
+        request.body.rewind
+        settings.middlewares.call(:id => id, :body => request.body.read, :config => settings.config)
+        {:id => id, :ok => true, :status => 200}.to_json
+      end
+
+      error 400..500 do
+        {:id => env[:id], :ok => false, :status => status, :message => env['sinatra.error']}.to_json
+      end
+    end
+  end
+end

data/lib/inventory/server/inventory_error.rb

@@ -0,0 +1,9 @@
+module Inventory
+  module Server
+
+    # The exception from which all other exceptions in this library derive.
+    class InventoryError < StandardError
+    end
+
+  end
+end

data/lib/inventory/server/loader.rb

@@ -0,0 +1,60 @@
+require 'inventory/server/inventory_error'
+require 'inventory/server/logger'
+
+PLUGINS_DIR = Pathname.new(File.join File.dirname(__FILE__), '..', '..', '..', 'plugins').cleanpath
+
+module Inventory
+  module Server
+    class Loader
+      def initialize(config)
+        @plugins_path = [PLUGINS_DIR] + config[:plugins_path].split(',')
+        @plugins_path.each { |path|
+          raise InventoryError.new "plugins_path #{path} not found" unless File.directory? path
+        }
+        @loaded = []
+      end
+
+      # search for plugins in the plugins_path and return a hash of plugin_filename:plugin_klass
+      def load_plugins(*plugins)
+        plugin_klasses = []
+        plugins.each {|plugin|
+          p = nil
+          @plugins_path.each {|plugin_path|
+            filepath = File.join plugin_path, "#{plugin}.rb"
+            next unless File.file? filepath
+            load_file filepath
+            klass_name = classify(plugin)
+            p = Object.const_get("Inventory").const_get("Server").const_get(klass_name)
+          }
+          raise InventoryError.new "Plugin #{plugin} not found" if !p
+          plugin_klasses << p
+        }
+        return plugin_klasses
+      end
+
+      # Load a ruby file if not already loaded
+      def load_file(file)
+        return if @loaded.include? file
+
+        begin
+          @loaded << file
+          kernel_load(file)
+        rescue => e
+          @loaded.delete(file)
+          InventoryLogger.logger.error("Fail to load #{file}: #{e}")
+        end
+      end
+
+      # Usefull for tests
+      def kernel_load(file)
+        InventoryLogger.logger.info "Load #{file}"
+        require file
+      end
+
+      # transform a snake case string into a upper camel case string
+      def classify(str)
+        str.split('_').collect!{ |w| w.capitalize }.join
+      end
+    end
+  end
+end

data/lib/inventory/server/logger.rb

@@ -0,0 +1,16 @@
+require 'filum'
+
+module Inventory
+  module Server
+    module InventoryLogger
+
+    def self.setup(*args)
+      Filum.setup(*args)
+    end
+
+    def self.logger
+      Filum.logger
+    end
+    end
+  end
+end

data/lib/inventory/server/smtp_server.rb

@@ -0,0 +1,36 @@
+require "rubygems"
+require "midi-smtp-server"
+require "inventory/server/email_parser"
+require 'inventory/server/inventory_error'
+require "inventory/server/logger"
+
+module Inventory
+  module Server
+
+    # Create an SMTP Server
+    class SMTPServer < MidiSmtpServer
+
+      def initialize(config, middlewares)
+        @config = config
+        @middlewares = middlewares
+        @audit = @config[:debug]
+        super(config[:smtp_port], config[:host], config[:max_connections])
+      end
+
+      def on_message_data_event(ctx)
+        begin 
+          # execute middlewares
+          id, body = EmailParser.parse(ctx[:message])
+          InventoryLogger.logger.context_id = id
+          @middlewares.call(:id => id, :body => body)
+        rescue => e
+          # dot not raise the error to avoid the SMTP server relay to defer malformed emails
+        end
+      end
+
+      def log(msg)
+        InventoryLogger.logger.debug msg
+      end
+    end
+  end
+end

data/lib/inventory/server/version.rb

@@ -0,0 +1,5 @@
+module Inventory
+  module Server
+    VERSION = "0.0.1"
+  end
+end

data/plugins/facts_parser.rb

@@ -0,0 +1,95 @@
+# encoding: utf-8
+require 'json'
+require 'yaml'
+require "base64"
+require 'libxml_to_hash'
+
+require 'ensure/encoding'
+require 'inventory/server/inventory_error'
+require "inventory/server/logger"
+
+module Inventory
+  module Server
+    class FactsParser
+      def initialize(app, config)
+        @app = app
+        @config = config
+      end
+
+      def call(env)
+        InventoryLogger.logger.info "Facts parser"
+        body = env[:body]
+        raise InventoryError.new "body missing" if body.nil? || body.empty?
+
+        format = guess_format body
+        raise InventoryError.new "bad format" if !format
+
+        env[:facts] = parse(format, body)
+        @app.call(env)
+      end
+
+      # guess about the format of `str`
+      def guess_format(str)
+        case str
+        when /\A\s*[\[\{]/ then :json
+        when /\A\s*</ then :xml
+        when /\A---\s/ then :yaml
+        end
+      end
+
+
+      # Parse str into a hash, the format will ne guessed
+      def parse(format, str)
+        case format
+        when :xml
+          # XML validation
+
+          hash = nil
+          begin
+            hash = Hash.from_libxml! str
+            xml = decode_base64(hash)
+            keys = xml.keys
+            if keys.length == 1
+              xml = xml[keys[0]]
+            end
+            raise "Expect < found #{xml.text} " if xml.is_a?(LibXmlNode) and  xml.text != ""
+            return xml
+          rescue => e
+            raise $!, "Invalid XML #{$!}", $!.backtrace
+          end
+        when :json
+          JSON.parse str
+        when :yaml
+          YAML.load str
+        end
+      end
+
+      # decode base64 if present in this deep structure
+      def decode_base64(something)
+        if something.is_a?(Hash)
+          return nil if something.empty?
+          something.each {|key, value|
+            something[key] = decode_base64(value)
+          }
+        elsif something.is_a?(Array)
+          return nil if something.empty?
+          something = something.map {|value|
+            decode_base64(value)
+          }
+        elsif something.is_a?(String) and something.include? "__base64__"
+          something.slice!("__base64__")
+          fix_bad_encoding Base64.decode64(something);
+        else
+          something
+        end
+      end
+
+      def fix_bad_encoding(str)
+        str.ensure_encoding('UTF-8',
+          :external_encoding  => [Encoding::UTF_8, Encoding::ISO_8859_1],
+          :invalid_characters => :transcode
+        )
+      end
+    end
+  end
+end