sensu-settings 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: b95af032c4b3a94e59a491db3c04ba24eb8379b0
+  data.tar.gz: 2e86d492aa3f2f2e8cfb55e078e351a4812a3df6
+SHA512:
+  metadata.gz: 54a52ab2912061d6eca52dc9f4dbfc84c0532cf9b4593275e653272fdaeb62e2989db94783a120eeb1b08c2630cd8567f261b6dec506c55636a4cffb932a5c72
+  data.tar.gz: b4410e0f99ce6cba6d820ef90e7503147a794001c20fcd476f8ef94cc04169b38bf9e19aa3af504d8dbc0a527d14bcdf70310e191c590cfd552e9303f26ff5b2

data/.gitignore

@@ -0,0 +1,22 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp
+*.bundle
+*.so
+*.o
+*.a
+mkmf.log

data/.travis.yml

@@ -0,0 +1,14 @@
+language: ruby
+rvm:
+  - 1.8.7
+  - 1.9.2
+  - 1.9.3
+  - 2.0.0
+  - 2.1.0
+  - jruby
+notifications:
+  irc:
+    - "irc.freenode.net#sensu"
+addons:
+  code_climate:
+    repo_token: 824f4a75343a9300704f23e93eaaecb25d998e408f2c9b96cd44f55983d95483

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in sensu-settings.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,20 @@
+Copyright (c) 2014 Heavy Water Operations, LLC.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,28 @@
+# Sensu::Settings
+
+[![Build Status](https://travis-ci.org/sensu/sensu-settings.svg?branch=master)](https://travis-ci.org/sensu/sensu-settings)
+
+[![Code Climate](https://codeclimate.com/github/sensu/sensu-settings.png)](https://codeclimate.com/github/sensu/sensu-settings)
+[![Code Climate Coverage](https://codeclimate.com/github/sensu/sensu-settings/coverage.png)](https://codeclimate.com/github/sensu/sensu-settings)
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'sensu-settings'
+
+And then execute:
+
+    $ bundle
+
+## Usage
+
+Documentation can be found [here](http://rubydoc.info/github/sensu/sensu-settings/Sensu/Settings).
+
+## Contributing
+
+1. [Fork it](https://github.com/sensu/sensu-settings/fork)
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create a new Pull Request

data/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/lib/sensu/settings.rb

@@ -0,0 +1,15 @@
+require "sensu/settings/loader"
+
+module Sensu
+  module Settings
+    # Load Sensu settings.
+    #
+    # @param options [Hash]
+    # @return [Loader] a loaded instance of Loader.
+    def self.load(options={})
+      loader = Loader.new
+      loader.load(options)
+      loader
+    end
+  end
+end

data/lib/sensu/settings/constants.rb

@@ -0,0 +1,5 @@
+module Sensu
+  module Settings
+    CATEGORIES = [:checks, :filters, :mutators, :handlers]
+  end
+end

data/lib/sensu/settings/loader.rb

@@ -0,0 +1,255 @@
+gem "multi_json", "1.10.0"
+
+require "sensu/settings/validator"
+require "multi_json"
+
+module Sensu
+  module Settings
+    class Loader
+      # @!attribute [r] warnings
+      #   @return [Array] loader warnings.
+      attr_reader :warnings
+
+      # @!attribute [r] loaded_files
+      #   @return [Array] loaded config files.
+      attr_reader :loaded_files
+
+      def initialize
+        @warnings = []
+        @settings = Hash[CATEGORIES.map {|category| [category, {}]}]
+        @indifferent_access = false
+        @loaded_files = []
+        self.class.create_category_methods
+      end
+
+      # Create setting category accessors and methods to test the
+      # existence of definitions. Called in initialize().
+      def self.create_category_methods
+        CATEGORIES.each do |category|
+          define_method(category) do
+            setting_category(category)
+          end
+          method_name = category.to_s.chop + "_exists?"
+          define_method(method_name.to_sym) do |name|
+            definition_exists?(category, name)
+          end
+        end
+      end
+
+      # Access settings as an indifferent hash.
+      #
+      # @return [Hash] settings.
+      def to_hash
+        unless @indifferent_access
+          indifferent_access!
+        end
+        @settings
+      end
+
+      # Retrieve the value object corresponding to a key, acting like
+      # a Hash object.
+      #
+      # @param key [String, Symbol]
+      # @return [Object] value for key.
+      def [](key)
+        to_hash[key]
+      end
+
+      # Load settings from the environment.
+      # Loads: RABBITMQ_URL, REDIS_URL, REDISTOGO_URL, API_PORT, PORT
+      def load_env
+        if ENV["RABBITMQ_URL"]
+          @settings[:rabbitmq] = ENV["RABBITMQ_URL"]
+          warning(@settings[:rabbitmq], "using rabbitmq url environment variable")
+        end
+        ENV["REDIS_URL"] ||= ENV["REDISTOGO_URL"]
+        if ENV["REDIS_URL"]
+          @settings[:redis] = ENV["REDIS_URL"]
+          warning(@settings[:redis], "using redis url environment variable")
+        end
+        ENV["API_PORT"] ||= ENV["PORT"]
+        if ENV["API_PORT"]
+          @settings[:api] ||= {}
+          @settings[:api][:port] = ENV["API_PORT"].to_i
+          warning(@settings[:api], "using api port environment variable")
+        end
+        @indifferent_access = false
+      end
+
+      # Load settings from a JSON file.
+      #
+      # @param [String] file path.
+      def load_file(file)
+        if File.file?(file) && File.readable?(file)
+          begin
+            warning(file, "loading config file")
+            contents = IO.read(file)
+            config = MultiJson.load(contents, :symbolize_keys => true)
+            merged = deep_merge(@settings, config)
+            unless @loaded_files.empty?
+              changes = deep_diff(@settings, merged)
+              warning(changes, "config file applied changes")
+            end
+            @settings = merged
+            @indifferent_access = false
+            @loaded_files << file
+          rescue MultiJson::ParseError => error
+            warning(file, "config file must be valid json")
+            warning(file, "ignoring config file")
+          end
+        else
+          warning(file, "config file does not exist or is not readable")
+          warning(file, "ignoring config file")
+        end
+      end
+
+      # Load settings from files in a directory. Files may be in
+      # nested directories.
+      #
+      # @param [String] directory path.
+      def load_directory(directory)
+        warning(directory, "loading config files from directory")
+        path = directory.gsub(/\\(?=\S)/, "/")
+        Dir.glob(File.join(path, "**/*.json")).each do |file|
+          load_file(file)
+        end
+      end
+
+      # Set Sensu settings related environment variables. This method
+      # currently sets SENSU_CONFIG_FILES, a colon delimited list of
+      # loaded config files.
+      def set_env
+        ENV["SENSU_CONFIG_FILES"] = @loaded_files.join(":")
+      end
+
+      # Load settings from the environment and the paths provided, set
+      # appropriate environment variables.
+      #
+      # @param [Hash] options
+      # @option options [String] :config_file to load.
+      # @option options [String] :config_dir to load.
+      # @return [Hash] loaded settings.
+      def load(options={})
+        load_env
+        if options[:config_file]
+          load_file(options[:config_file])
+        end
+        if options[:config_dir]
+          load_directory(options[:config_dir])
+        end
+        set_env
+        to_hash
+      end
+
+      # Validate the loaded settings.
+      #
+      # @return [Array] validation failures.
+      def validate!
+        service = ::File.basename($0).split("-").last
+        validator = Validator.new
+        validator.run(@settings, service)
+      end
+
+      private
+
+      # Retrieve setting category definitions.
+      #
+      # @param [Symbol] category to retrive.
+      # @return [Array<Hash>] category definitions.
+      def setting_category(category)
+        @settings[category].map do |name, details|
+          details.merge(:name => name.to_s)
+        end
+      end
+
+      # Check to see if a definition exists in a category.
+      #
+      # @param [Symbol] category to inspect for the definition.
+      # @param [String] name of definition.
+      # @return [TrueClass, FalseClass]
+      def definition_exists?(category, name)
+        @settings[category].has_key?(name.to_sym)
+      end
+
+      # Creates an indifferent hash.
+      #
+      # @return [Hash] indifferent hash.
+      def indifferent_hash
+        Hash.new do |hash, key|
+          if key.is_a?(String)
+            hash[key.to_sym]
+          end
+        end
+      end
+
+      # Create a copy of a hash with indifferent access.
+      #
+      # @param hash [Hash] hash to make indifferent.
+      # @return [Hash] indifferent version of hash.
+      def with_indifferent_access(hash)
+        hash = indifferent_hash.merge(hash)
+        hash.each do |key, value|
+          if value.is_a?(Hash)
+            hash[key] = with_indifferent_access(value)
+          end
+        end
+      end
+
+      # Update settings to have indifferent access.
+      def indifferent_access!
+        @settings = with_indifferent_access(@settings)
+        @indifferent_access = true
+      end
+
+      # Deep merge two hashes.
+      #
+      # @param [Hash] hash_one to serve as base.
+      # @param [Hash] hash_two to merge in.
+      def deep_merge(hash_one, hash_two)
+        merged = hash_one.dup
+        hash_two.each do |key, value|
+          merged[key] = case
+          when hash_one[key].is_a?(Hash) && value.is_a?(Hash)
+            deep_merge(hash_one[key], value)
+          when hash_one[key].is_a?(Array) && value.is_a?(Array)
+            hash_one[key].concat(value).uniq
+          else
+            value
+          end
+        end
+        merged
+      end
+
+      # Compare two hashes.
+      #
+      # @param [Hash] hash_one to compare.
+      # @param [Hash] hash_two to compare.
+      # @return [Hash] comparison diff hash.
+      def deep_diff(hash_one, hash_two)
+        keys = hash_one.keys.concat(hash_two.keys).uniq
+        keys.inject(Hash.new) do |diff, key|
+          unless hash_one[key] == hash_two[key]
+            if hash_one[key].is_a?(Hash) && hash_two[key].is_a?(Hash)
+              diff[key] = deep_diff(hash_one[key], hash_two[key])
+            else
+              diff[key] = [hash_one[key], hash_two[key]]
+            end
+          end
+          diff
+        end
+      end
+
+      # Record a warning for an object.
+      #
+      # @param object [Object] under suspicion.
+      # @param message [String] warning message.
+      # @return [Array] current warnings.
+      def warning(object, message)
+        @warnings << {
+          :object => object,
+          :message => message
+        }
+      end
+    end
+  end
+end

data/lib/sensu/settings/rules.rb

@@ -0,0 +1,154 @@
+module Sensu
+  module Settings
+    module Rules
+      # Check that a value is a hash.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_hash(value)
+        value.is_a?(Hash)
+      end
+      alias_method :is_a_hash?, :must_be_a_hash
+
+      # Check that a value is a hash, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_hash_if_set(value)
+        value.nil? ? true : must_be_a_hash(value)
+      end
+
+      # Check that a value is an array.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_array(value)
+        value.is_a?(Array)
+      end
+      alias_method :is_an_array?, :must_be_an_array
+
+      # Check that a value is an array, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_array_if_set(value)
+        value.nil? ? true : must_be_an_array(value)
+      end
+
+      # Check that a value is a string.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_string(value)
+        value.is_a?(String)
+      end
+
+      # Check that a value is a string, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_string_if_set(value)
+        value.nil? ? true : must_be_a_string(value)
+      end
+
+      # Check that a value is an integer.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_integer(value)
+        value.is_a?(Integer)
+      end
+
+      # Check that a value is an integer, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_an_integer_if_set(value)
+        value.nil? ? true : must_be_an_integer(value)
+      end
+
+      # Check that a value is numeric.
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_numeric(value)
+        value.is_a?(Numeric)
+      end
+
+      # Check that a value is numeric, if set (not nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_a_numeric_if_set(value)
+        value.nil? ? true : must_be_a_numeric(value)
+      end
+
+      # Check that a value matches a regular expression.
+      #
+      # @param regex [Regexp] pattern to compare with value.
+      # @param value [Object] to check if matches pattern.
+      # @return [TrueClass, FalseClass]
+      def must_match_regex(regex, value)
+        value =~ regex
+      end
+
+      # Check if a value is boolean, if set (no nil).
+      #
+      # @param value [Object] to check.
+      # @return [TrueClass, FalseClass]
+      def must_be_boolean_if_set(value)
+        value.nil? ? true : (!!value == value)
+      end
+
+      # Check that value items are all strings and not empty.
+      #
+      # @param value [Array] with items to check.
+      # @return [TrueClass, FalseClass]
+      def items_must_be_strings(value)
+        value.all? do |item|
+          item.is_a?(String) && !item.empty?
+        end
+      end
+
+      # Check if either of the values are set (not nil).
+      #
+      # @param values [Array<Object>] to check if not nil.
+      # @return [TrueClass, FalseClass]
+      def either_are_set?(*values)
+        values.any? do |value|
+          !value.nil?
+        end
+      end
+
+      # Check if values are valid times (can be parsed).
+      #
+      # @param values [Array<Object>] to check if valid time.
+      # @return [TrueClass, FalseClass]
+      def must_be_time(*values)
+        values.all? do |value|
+          Time.parse(value) rescue false
+        end
+      end
+
+      # Check if values are allowed.
+      #
+      # @param allowed [Array<Object>] allowed values.
+      # @param values [Array<Object>] to check if allowed.
+      # @return [TrueClass, FalseClass]
+      def must_be_either(allowed, *values)
+        values.flatten.all? do |value|
+          allowed.include?(value)
+        end
+      end
+
+      # Check if values are allowed, if set (not nil).
+      #
+      # @param allowed [Array<Object>] allowed values.
+      # @param values [Array<Object>] to check if allowed.
+      # @return [TrueClass, FalseClass]
+      def must_be_either_if_set(allowed, *values)
+        values[0].nil? ? true : must_be_either(allowed, values)
+      end
+    end
+  end
+end