sensu-settings 0.0.1

data/lib/sensu/settings/validators/mutator.rb

@@ -0,0 +1,18 @@
+module Sensu
+  module Settings
+    module Validators
+      module Mutator
+        # Validate a Sensu mutator definition.
+        # Validates: command, timeout
+        #
+        # @param mutator [Hash] sensu mutator definition.
+        def validate_mutator(mutator)
+          must_be_a_string(mutator[:command]) ||
+            invalid(mutator, "mutator command must be a string")
+          must_be_a_numeric_if_set(mutator[:timeout]) ||
+            invalid(mutator, "mutator timeout must be numeric")
+        end
+      end
+    end
+  end
+end

data/lib/sensu/settings/validators/subdue.rb

@@ -0,0 +1,68 @@
+module Sensu
+  module Settings
+    module Validators
+      module Subdue
+        # Validate subdue time.
+        # Validates: begin, end
+        #
+        # @param scope [String] definition scope to report under.
+        # @param definition [Hash] sensu definition.
+        # @param object [Hash] to have begin and end validated.
+        def validate_subdue_time(scope, definition, object)
+          if is_a_hash?(object)
+            if either_are_set?(object[:begin], object[:end])
+              must_be_time(object[:begin], object[:end]) ||
+                invalid(definition, "#{scope} begin and end times must be valid")
+            end
+          else
+            invalid(definition, "#{scope} must be a hash")
+          end
+        end
+
+        # Validate subdue days.
+        # Validates: days
+        #
+        # @param definition [Hash] sensu definition.
+        def validate_subdue_days(definition)
+          subdue = definition[:subdue]
+          must_be_an_array_if_set(subdue[:days]) ||
+            invalid(definition, "subdue days must be an array")
+          if is_an_array?(subdue[:days])
+            days = %w[sunday monday tuesday wednesday thursday friday saturday]
+            must_be_either(days, subdue[:days]) ||
+              invalid(definition, "subdue days must be valid days of the week")
+          end
+        end
+
+        # Validate subdue exceptions.
+        # Validates: exceptions (begin, end)
+        #
+        # @param definition [Hash] sensu definition.
+        def validate_subdue_exceptions(definition)
+          subdue = definition[:subdue]
+          must_be_an_array_if_set(subdue[:exceptions]) ||
+            invalid(definition, "subdue exceptions must be an array")
+          if is_an_array?(subdue[:exceptions])
+            subdue[:exceptions].each do |exception|
+              validate_subdue_time("subdue exceptions", definition, exception)
+            end
+          end
+        end
+
+        # Validate Sensu subdue, for either a check or handler definition.
+        #
+        # @param definition [Hash] sensu definition.
+        def validate_subdue(definition)
+          subdue = definition[:subdue]
+          validate_subdue_time("subdue", definition, subdue)
+          if is_a_hash?(subdue)
+            must_be_either_if_set(%w[handler publisher], subdue[:at]) ||
+              invalid(definition, "subdue at must be either handler or publisher")
+            validate_subdue_days(definition)
+            validate_subdue_exceptions(definition)
+          end
+        end
+      end
+    end
+  end
+end

data/lib/sensu/settings/validators/transport.rb

@@ -0,0 +1,20 @@
+module Sensu
+  module Settings
+    module Validators
+      module Transport
+        # Validate a Sensu transport definition.
+        # Validates: name
+        #
+        # @param transport [Hash] sensu transport definition.
+        def validate_transport(transport)
+          must_be_a_hash_if_set(transport) ||
+            invalid(transport, "transport must be a hash")
+          if is_a_hash?(transport)
+            must_be_a_string_if_set(transport[:name]) ||
+              invalid(transport, "transport name must be a string")
+          end
+        end
+      end
+    end
+  end
+end

data/sensu-settings.gemspec

@@ -0,0 +1,24 @@
+# coding: utf-8
+
+Gem::Specification.new do |spec|
+  spec.name          = "sensu-settings"
+  spec.version       = "0.0.1"
+  spec.authors       = ["Sean Porter"]
+  spec.email         = ["portertech@gmail.com"]
+  spec.summary       = "The Sensu settings library, loader and validator"
+  spec.description   = "The Sensu settings library, loader and validator"
+  spec.homepage      = "https://github.com/sensu/sensu-settings"
+  spec.license       = "MIT"
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ["lib"]
+
+  spec.add_dependency "multi_json", "1.10.0"
+
+  spec.add_development_dependency "bundler", "~> 1.6"
+  spec.add_development_dependency "rake"
+  spec.add_development_dependency "rspec"
+  spec.add_development_dependency "codeclimate-test-reporter"
+end

data/spec/assets/conf.d/merger.json

@@ -0,0 +1,11 @@
+{
+  "checks": {
+    "merger": {
+      "command": "echo -n merger",
+      "subscribers": [
+        "bar"
+      ],
+     "interval": 60
+    }
+  }
+}

data/spec/assets/conf.d/nested/file.json

@@ -0,0 +1,11 @@
+{
+  "checks": {
+    "nested": {
+      "command": "true",
+      "subscribers": [
+        "test"
+      ],
+      "interval": 30
+    }
+  }
+}

data/spec/assets/config.json

@@ -0,0 +1,126 @@
+{
+  "api": {
+    "host": "localhost",
+    "port": 4567,
+    "user": "foo",
+    "password": "bar"
+  },
+  "filters": {
+    "production": {
+      "attributes": {
+        "client": {
+          "environment": "production"
+        }
+      }
+    },
+    "development": {
+      "negate": true,
+      "attributes": {
+        "client": {
+          "environment": "production"
+        }
+      }
+    }
+  },
+  "mutators": {
+    "noop": {
+      "command": "cat"
+    }
+  },
+  "handlers": {
+    "default": {
+      "type": "set",
+      "handlers": [
+        "debug"
+      ]
+    },
+    "file": {
+      "type": "pipe",
+      "command": "cat > /tmp/sensu_event"
+    },
+    "filtered": {
+      "type": "pipe",
+      "command": "cat > /tmp/sensu_event",
+      "filter": "development"
+    },
+    "severities": {
+      "type": "pipe",
+      "command": "cat > /tmp/sensu_event",
+      "severities": [
+        "critical",
+        "unknown"
+      ]
+    },
+    "flapping": {
+      "type": "pipe",
+      "command": "cat > /tmp/sensu_event",
+      "handle_flapping": true
+    },
+    "tcp": {
+      "type": "tcp",
+      "socket": {
+        "host": "localhost",
+        "port": 1234
+      }
+    },
+    "udp": {
+      "type": "udp",
+      "socket": {
+        "host": "localhost",
+        "port": 1234
+      }
+    },
+    "transport": {
+      "type": "transport",
+      "pipe": {
+        "type": "direct",
+        "name": "events"
+      }
+    }
+  },
+  "checks": {
+    "tokens": {
+      "command": "echo -n :::name::: :::nested.attribute::: && exit 2",
+      "subscribers": [
+        "test"
+      ],
+      "interval": 1
+    },
+    "standalone": {
+      "command": "echo -n foobar && exit 1",
+      "standalone": true,
+      "interval": 1
+    },
+    "merger": {
+      "command": "this will be overwritten",
+      "subscribers": [
+        "foo"
+      ]
+    },
+    "unpublished": {
+      "command": "/bin/true",
+      "publish": false,
+      "subscribers":[
+        "test"
+      ]
+    }
+  },
+  "client": {
+    "name": "i-424242",
+    "address": "127.0.0.1",
+    "subscriptions": [
+      "test"
+    ],
+    "nested": {
+      "attribute": true
+    },
+    "service": {
+      "password": "secret"
+    },
+    "keepalive": {
+      "thresholds": {
+        "warning": 10
+      }
+    }
+  }
+}

data/spec/assets/invalid.json

@@ -0,0 +1,2 @@
+{
+  "invalid": "json"

data/spec/helpers.rb

@@ -0,0 +1,8 @@
+require "rspec"
+
+unless RUBY_VERSION < "1.9" || RUBY_PLATFORM =~ /java/
+  require "codeclimate-test-reporter"
+  CodeClimate::TestReporter.start
+end
+
+module Helpers; end

data/spec/loader_spec.rb

@@ -0,0 +1,171 @@
+require File.join(File.dirname(__FILE__), "helpers")
+require "sensu/settings/loader"
+
+describe "Sensu::Settings::Loader" do
+  include Helpers
+
+  before do
+    @loader = Sensu::Settings::Loader.new
+    @assets_dir = File.join(File.dirname(__FILE__), "assets")
+    @config_file = File.join(@assets_dir, "config.json")
+    @config_dir = File.join(@assets_dir, "conf.d")
+  end
+
+  it "can provide a loader API" do
+    @loader.should respond_to(:load, :validate!)
+  end
+
+  it "can provide indifferent access to settings" do
+    @loader[:checks].should be_kind_of(Hash)
+    @loader["checks"].should be_kind_of(Hash)
+  end
+
+  it "can validate loaded settings" do
+    failures = @loader.validate!
+    failures.size.should eq(0)
+  end
+
+  it "can load RabbitMQ settings from the environment" do
+    ENV["RABBITMQ_URL"] = "amqp://guest:guest@localhost:5672/"
+    @loader.load_env
+    @loader.warnings.size.should eq(1)
+    ENV["RABBITMQ_URL"] = nil
+  end
+
+  it "can load Redis settings from the environment" do
+    ENV["REDIS_URL"] = "redis://username:password@localhost:6789"
+    @loader.load_env
+    @loader.warnings.size.should eq(1)
+    ENV["REDIS_URL"] = nil
+  end
+
+  it "can load Sensu API settings from the environment" do
+    ENV["API_PORT"] = "4567"
+    @loader.load_env
+    @loader.warnings.size.should eq(1)
+    ENV["API_PORT"] = nil
+  end
+
+  it "can load Redis and Sensu API settings from the environment using alternative variables" do
+    ENV["REDISTOGO_URL"] = "redis://username:password@localhost:6789"
+    ENV["PORT"] = "4567"
+    @loader.load_env
+    @loader.warnings.size.should eq(2)
+    ENV["REDISTOGO_URL"] = nil
+    ENV["PORT"] = nil
+  end
+
+  it "can load settings from a file" do
+    @loader.load_file(@config_file)
+    @loader.warnings.size.should eq(1)
+    warning = @loader.warnings.first
+    warning[:object].should eq(File.expand_path(@config_file))
+    warning[:message].should eq("loading config file")
+    @loader[:api][:port].should eq(4567)
+    @loader["api"]["port"].should eq(4567)
+  end
+
+  it "can load settings from a file and validate them" do
+    @loader.load_file(@config_file)
+    failures = @loader.validate!
+    reasons = failures.map do |failure|
+      failure[:message]
+    end
+    reasons.should include("check interval must be an integer")
+  end
+
+  it "can attempt to load settings from a nonexistent file" do
+    @loader.load_file("/tmp/bananaphone")
+    warnings = @loader.warnings
+    warnings.size.should eq(2)
+    messages = warnings.map do |warning|
+      warning[:message]
+    end
+    messages.should include("config file does not exist or is not readable")
+    messages.should include("ignoring config file")
+  end
+
+  it "can attempt to load settings from a file with invalid JSON" do
+    @loader.load_file(File.join(@assets_dir, "invalid.json"))
+    warnings = @loader.warnings
+    warnings.size.should eq(3)
+    messages = warnings.map do |warning|
+      warning[:message]
+    end
+    messages.should include("loading config file")
+    messages.should include("config file must be valid json")
+    messages.should include("ignoring config file")
+  end
+
+  it "can load settings from files in a directory" do
+    @loader.load_directory(@config_dir)
+    warnings = @loader.warnings
+    warnings.size.should eq(4)
+    messages = warnings.map do |warning|
+      warning[:message]
+    end
+    messages.should include("loading config files from directory")
+    messages.should include("loading config file")
+    messages.should include("config file applied changes")
+    @loader[:checks][:nested][:command].should eq("true")
+  end
+
+  it "can attempt to load settings from files in a nonexistent directory" do
+    @loader.load_directory("/tmp/rottentomatos")
+    @loader.warnings.size.should eq(1)
+    warning = @loader.warnings.first
+    warning[:message].should eq("loading config files from directory")
+  end
+
+  it "can load settings from the environment, a file, and a directory" do
+    ENV["RABBITMQ_URL"] = "amqp://guest:guest@localhost:5672/"
+    settings = @loader.load(:config_file => @config_file, :config_dir => @config_dir)
+    settings[:rabbitmq].should eq(ENV["RABBITMQ_URL"])
+    settings[:api][:port].should eq(4567)
+    settings[:checks][:merger][:command].should eq("echo -n merger")
+    settings[:checks][:merger][:subscribers].should eq(["foo", "bar"])
+    settings[:checks][:nested][:command].should eq("true")
+    ENV["SENSU_CONFIG_FILES"].split(":").should eq(@loader.loaded_files)
+    ENV["RABBITMQ_URL"] = nil
+  end
+
+  it "can load settings and determine if certain definitions exist" do
+    @loader.load(:config_file => @config_file, :config_dir => @config_dir)
+    @loader.check_exists?("nonexistent").should be_false
+    @loader.check_exists?("tokens").should be_true
+    @loader.filter_exists?("nonexistent").should be_false
+    @loader.filter_exists?("development").should be_true
+    @loader.mutator_exists?("nonexistent").should be_false
+    @loader.mutator_exists?("noop").should be_true
+    @loader.handler_exists?("nonexistent").should be_false
+    @loader.handler_exists?("default").should be_true
+  end
+
+  it "can load settings and provide setting category accessors" do
+    @loader.load(:config_file => @config_file, :config_dir => @config_dir)
+    @loader.checks.should be_kind_of(Array)
+    @loader.checks.should_not be_empty
+    check = @loader.checks.detect do |check|
+      check[:name] == "tokens"
+    end
+    check[:interval].should eq(1)
+    @loader.filters.should be_kind_of(Array)
+    @loader.filters.should_not be_empty
+    filter = @loader.filters.detect do |filter|
+      filter[:name] == "development"
+    end
+    filter[:negate].should be_true
+    @loader.mutators.should be_kind_of(Array)
+    @loader.mutators.should_not be_empty
+    mutator = @loader.mutators.detect do |mutator|
+      mutator[:name] == "noop"
+    end
+    mutator[:command].should eq("cat")
+    @loader.handlers.should be_kind_of(Array)
+    @loader.handlers.should_not be_empty
+    handler = @loader.handlers.detect do |handler|
+      handler[:name] == "default"
+    end
+    handler[:type].should eq("set")
+  end
+end