litmus_paper 1.1.1 → 1.2.0

data/Dockerfile

@@ -0,0 +1,20 @@
+FROM debian:stretch
+EXPOSE 9293/TCP
+EXPOSE 9294/TCP
+WORKDIR /home/litmus_paper
+RUN apt-get update && apt-get install -y ruby ruby-dev git curl rsyslog build-essential
+RUN gem install --no-ri --no-rdoc bundler \
+  && gem install sinatra --no-ri --no-rdoc --version "~> 1.3.2" \
+  && gem install remote_syslog_logger --no-ri --no-rdoc --version "~> 1.0.3" \
+  && gem install unicorn --no-ri --no-rdoc --version "~> 4.6.2" \
+  && gem install colorize --no-ri --no-rdoc \
+  && gem install rspec --no-ri --no-rdoc --version "~> 2.9.0" \
+  && gem install rack-test --no-ri --no-rdoc --version "~> 0.6.1" \
+  && gem install rake --no-ri --no-rdoc --version "~> 0.9.2.2" \
+  && gem install rake_commit --no-ri --no-rdoc --version "~> 0.13"
+ADD . /home/litmus_paper
+RUN ln -sf /home/litmus_paper/docker/litmus.conf /etc/litmus.conf \
+  && ln -sf /home/litmus_paper/docker/litmus_unicorn.rb /etc/litmus_unicorn.rb
+RUN gem build litmus_paper.gemspec && gem install litmus_paper*.gem
+
+CMD ["bin/litmus", "-p", "9293", "-c", "/etc/litmus_unicorn.rb"]

data/README.md

@@ -1,6 +1,6 @@
 # LitmusPaper
 
-Backend health tester for HA Services, or as an agent-check for HAProxy
+LitmusPaper is a backend health tester for Highly Available (HA) services.
 
 [![Build Status](https://secure.travis-ci.org/braintree/litmus_paper.png)](http://travis-ci.org/braintree/litmus_paper)
 
@@ -18,10 +18,251 @@ Or install it yourself as:
 
     $ gem install litmus_paper
 
+## Overview
+
+Litmus Paper reports health for each service on a node (like a server, vm, or container) on a 0-100 scale. Health is computed by aggregating the values returned from running various subchecks. Health information can be queried through a REST API for consumption by other services (like load balancers or monitoring systems), or queried on the command line.
+
+There are two classes of subchecks: Dependencies and Metrics. Dependencies report either 0 or 100 health, and aggregate such that if any dependency is not 100 the whole service is down. Metrics report health on a scale from 0-100 and aggregate as averages based on their weight.
+
+You can also force a service to report a health value on a host.
+Forcing a service up makes it report a health of 100, regardless of the measured health.
+Forcing a service down makes it report a health of 0.
+Forcing a service's health to a value between 0 and 100 places a ceiling on its health. The service will report the lower of the measured health or the forced health value.
+
+Force downs take precedence, followed by force ups, and finally force healths. If you specify both a force up and a force down, the service will report 0 health. If you specify a force up and a force health, the force health will be ignored and the service will report 100 health.
+
+Using litmus-agent-check, Litmus can also output health information in haproxy agent check format.
+
 ## Usage
 
-Use the sample config to run it under unicorn. Or execute litmus-agent-check to
-use it as an agent-check for HAProxy.
+### Running Litmus Paper
+
+Start the process under unicorn with `/usr/bin/litmus --unicorn-config <path_to_unicorn_conf>`. In the unicorn config file, set the number of worker processes, the pid, and the working directory. See the [unicorn documentation](https://bogomips.org/unicorn/Unicorn/Configurator.html) for the config format. There are a few command line options:
+
+```
+Usage: litmus [options]
+
+    -b, --binding=ip                 Binds Litmus to the specified ip.
+                                     Default: 0.0.0.0
+    -d, --daemon                     Make server run as a Daemon.
+    -p, --port=port                  Listen Port
+    -c, --unicorn-config=config      Unicorn Config
+
+    -h, --help                       Show this help message.
+```
+
+For HAProxy agent checks, run `/usr/bin/litmus-agent-check`. See the "HAProxy Agent Check Configuration" section below for a full list of options.
+
+### Global configuration
+
+This can be either yaml or ruby.
+
+Examples:
+
+```
+# /etc/litmus.conf
+
+include_files "litmus.d/*.conf"
+
+port 80
+
+data_directory "/litmus"
+```
+
+```yaml
+# /etc/litmus.conf.yaml
+---
+include-files: 'litmus.d/*.yaml'
+port: 80
+data_directory: '/litmus'
+```
+
+Available fields:
+- include_files: Tells Litmus to load health check configurations from a path.
+- port: Port Litmus unicorn server will listen on, defaults to 9292.
+- data_directory: Where to store force down, up, and health files. Defaults to "/etc/litmus".
+- cache_location: Where to store cached health information, defaults to "/run/shm".
+- cache_ttl: Time to live in seconds for cached health check values, defaults to -1.
+
+### Service health check configuration
+
+To add services and health checks, Litmus Paper loads YAML configurations or ruby code. The examples below show both styles.
+
+Suppose you're writing a health check for a web application. You might start with a simple check to report if the server is responding at all:
+
+```yaml
+# /etc/litmus.d/myapp.yaml
+---
+services:
+  myapp:
+    dependencies:
+      - type: http
+        uri: 'https://localhost/heartbeat'
+        method: 'GET'
+        ca_file: '/etc/ssl/certs/ca-certificates.crt'
+```
+
+```ruby
+# /etc/litmus.d/myapp.conf
+service "myapp" do |s|
+  s.depends Dependency::HTTP, "https://localhost/heartbeat", :method => "GET", :ca_file => "/etc/ssl/certs/ca-certificates.crt"
+end
+```
+
+Maybe you also want to balance traffic based on CPU load:
+
+```yaml
+# /etc/litmus.d/myapp.yaml
+---
+services:
+  myapp:
+    dependencies:
+      - type: http
+        uri: 'https://localhost/heartbeat'
+        method: 'GET'
+        ca_file: '/etc/ssl/certs/ca-certificates.crt'
+    checks:
+      - type: cpu_load
+        weight: 100
+```
+
+```ruby
+# /etc/litmus.d/myapp.conf
+service "myapp" do |s|
+  s.depends Dependency::HTTP, "https://localhost/heartbeat", :method => "GET", :ca_file => "/etc/ssl/certs/ca-certificates.crt"
+  s.measure_health Metric::CPULoad, :weight => 100
+end
+```
+
+Once you've finished adding checks, restart litmus paper to pick up the new service.
+
+Here are all the types of checks currently implemented:
+
+- `http` (`Dependency::HTTP`): Checks HTTP 200 response from a URI.
+  * uri
+  * method (defaults to get)
+  * ca_file (defaults to nil)
+  * timeout (defaults to 2s)
+
+- `tcp` (`Dependency::TCP`): Checks successful completion of a TCP handshake with an address.
+  * ip
+  * port
+  * input_data (defaults to nil)
+  * expected_output (defaults to nil)
+  * timeout (defaults to 2s)
+
+- `file_contents` (`Dependency::FileContents`): Checks whether the contents of a file match a string or regex.
+  * path
+  * regex
+  * timeout (defaults to 5s)
+
+- `script` (`Dependency::Script`): Checks whether a command exits with 0 (success) or not (failure).
+  * command
+  * timeout (defaults to 5s)
+
+- `constant_metric` (`Metric::ConstantMetric`): A dummy metric that always reports a constant.
+  * weight (0-100)
+
+- `cpu_load` (`Metric::CPULoad`): Normalizes CPU load to a value between 1-100 and inverts it, so higher numbers mean less load and lower numbers mean more. Final health is weighted against other checks by `:weight`. The lower bound of 1 ensures that nodes will not leave the cluster solely based on CPU load. An example of how allowing 0 can cause problems: If one node has 4 CPUs and a load of 4 with CPU usage weighted at 100, it will report its health as 0, and all traffic will be shifted towards other nodes. These nodes in turn hit 100% CPU usage and report 0 health, causing a cascade of exiting nodes that shuts down the service.
+  * weight (1-100)
+
+- `internet_health` (`Metric::InternetHealth`): Checks connectivity across a set of hosts and computes a weight based on how many are reachable. Helpful if you want to check outbound connectivity through multiple ISPs.
+  * weight (0-100)
+  * hosts
+  * timeout (defaults to 5s)
+
+- `script` (`Metric::Script`): Runs a script to obtain a health from 0-100. This is helpful for customized metrics.
+  * command
+  * weight (0-100)
+  * timeout (defaults to 5s)
+
+- `big_brother_service` (`Metric::BigBrotherService`): Used in conjunction with [Big Brother](https://github.com/braintree/big_brother), reports health based on the overall health of another load balanced service.
+  * service
+
+### HAProxy agent check configuration
+
+Litmus paper can also report health checks in HAProxy agent check format. The agent check functionality takes the health data from a service health check, and exposes it on a different port in the format HAProxy expects.
+
+There are no additional configuration files for the agent check, since all options are specified on the command line. Services are configured as normal litmus services as described above.
+
+```
+Usage: litmus-agent-check [options]
+    -s, --service SERVICE:PORT,...   agent-check service to port mappings
+    -c, --config CONFIG              Path to litmus paper config file
+    -p, --pid-file PID_FILE          Where to write the pid
+    -w, --workers WORKERS            Number of worker processes
+    -D, --daemonize                  Daemonize the process
+    -h, --help                       Help text
+```
+
+The service:port argument means that the server will expose the data from the litmus check for `service` on `port` in HAProxy agent check format. For example, if you wanted to serve status information about `myapp` on port `8080`, and already had a service config for it, you'd pass `-s myapp:8080`.
+
+On the HAProxy server, add `agent-check agent-port 8080 agent-inter <seconds>s` to the config line for each server listed for that backend. This tells HAProxy to query port 8080 on the backend every `<seconds>` seconds for health information. See the [HAProxy agent check documentation](https://cbonte.github.io/haproxy-dconv/1.8/configuration.html#5.2-agent-check) for more details.
+
+### REST API
+
+The REST API is the main way other services should interact with Litmus. For routes that take parameters, pass them as form parameters in the request body.
+
+- /
+  * GET: Returns table with status of each service.
+
+		Litmus Paper 1.1.1
+
+		 Service    │ Reported │ Measured │ Health
+		 Name       │ Health   │ Health   │ Forced?
+		────────────┴──────────┴──────────┴─────────
+		 myapp            0        100      Yes, Reason: testing
+		 myotherapp      72         72      No
+
+- /down
+  * POST: Creates a global force down. Parameters: reason => reason for the force down.
+  * DELETE: Deletes global force down, if one is in place. Any service-specific force downs remain in effect.
+
+- /up
+  * POST: Creates a global force up. Parameters: reason => reason for the force up.
+  * DELETE: Deletes global force up, if one is in place. Any service-specific force ups remain in effect.
+
+- /health
+  * POST: Creates a global force health. Parameters: reason => reason for the force health, health => health to force to.
+  * DELETE: Deletes global force health, if one is in place. Any service-specific force healths remain in effect.
+
+- /`<service>`/status
+  * GET: Returns a detailed status output for `<service>`, including all the subchecks. This output easier to parse than the output from GET /. Also sets X-Health and X-Health-Forced headers in the response.
+
+    ```
+    Health: 82
+    Measured Health: 82
+    Dependency::HTTP(http://localhost/heartbeat): OK
+    Metric::CPULoad(100): 82
+    ```
+
+- /`<service>`/down
+  * POST: Creates a force down just for `<service>`. Parameters: reason => reason for the force down.
+  * DELETE: Deletes force down for `<service>`, if one is in place. Global force downs remain in effect.
+
+- /`<service>`/up
+  * POST: Creates a force up just for `<service>`. Parameters: reason => reason for the force up.
+  * DELETE: Deletes force up for `<service>`, if one is in place. Global force ups remain in effect.
+
+- /`<service>`/health
+  * POST: Creates a force health just for `<service>`. Parameters: reason => reason for the force health, health => health to force to.
+  * DELETE: Deletes force health for `<service>`, if one is in place. Global force healths remain in effect.
+
+### Litmusctl
+
+There is also a CLI included called `litmusctl`.
+
+This has the same functionality as the rest API:
+- `litmusctl list` = `GET /`
+- `litmusctl status <service>` = `GET /<service>/status`
+- `litmusctl force (down|up|health) [health] [-r REASON]` = `POST /(down|up|health)`
+- `litmusctl force (down|up|health) [health] <service> [-r REASON]` = `POST /<service>/(down|up|health)`
+- `litmusctl force (down|up|health) -d` = `DELETE /(down|up|health)`
+- `litmusctl force (down|up|health) <service> -d` = `DELETE /<service>/(down|up|health)`
+
+## Tests
+
+Run tests using `rake`. The default task runs all the tests.
 
 ## Releasing
 
@@ -34,3 +275,38 @@ use it as an agent-check for HAProxy.
 3. Commit your changes (`git commit -am 'Added some feature'`)
 4. Push to the branch (`git push origin my-new-feature`)
 5. Create new Pull Request
+
+## Docker
+
+We've provided a simple docker image that can be used to try out litmus_paper, run tests, or to assist in feature development.
+
+To run it, from the top of your copy of the litmus_paper repository:
+
+```
+docker build -t litmus_paper .
+# Run litmus_paper
+docker run -d -p 9293:9293 litmus_paper
+```
+
+Then, you can `curl localhost:9293` from your host machine to interact with the REST API.
+
+To run interactively and attach to the container:
+
+```
+docker run -it litmus_paper /bin/bash
+# bin/litmus -p 9293 -d
+# curl localhost:9293
+```
+
+To run litmus-agent-check on port 9294:
+
+```
+# Run litmus paper with litmus-agent-check using 10 workers
+docker run -d -p 9294:9294 litmus_paper bin/litmus-agent-check -s test:9294 -c /etc/litmus.conf -w 10
+```
+
+## TODO
+
+1. Accept configuration in either YAML or ruby format.
+2. Improve concurrency model, with a health-check process and a responder process.
+3. Improve concurrency of agent-check daemon.

data/docker/litmus.conf

@@ -0,0 +1,7 @@
+port 9292
+data_directory '/tmp/litmus_paper'
+cache_location '/tmp/litmus_paper_cache'
+cache_ttl -1
+service :test do |s|
+  s.measure_health Metric::CPULoad, :weight => 100
+end

data/docker/litmus_unicorn.rb

@@ -0,0 +1,11 @@
+# vim: set ft=ruby
+require 'remote_syslog_logger'
+
+APP_ROOT = '/var/lib/gems/2.3.0/gems/litmus_paper-1.1.1'
+
+worker_processes 5
+working_directory APP_ROOT
+
+logger(RemoteSyslogLogger.new('127.0.0.1', 514, :program => 'litmus_paper', :facility => 'daemon'))
+
+pid "/tmp/unicorn.pid"

data/lib/litmus_paper/agent_check_handler.rb

@@ -1,8 +1,21 @@
 module LitmusPaper
   class AgentCheckHandler
     def self.handle(service)
+      @cache ||= LitmusPaper::Cache.new(
+        LitmusPaper.cache_location,
+        "litmus_agent_cache",
+        LitmusPaper.cache_ttl
+      )
       output = []
-      health = LitmusPaper.check_service(service)
+
+      health = @cache.get(service)
+      if !health
+        @cache.set(
+          service,
+          health = LitmusPaper.check_service(service)
+        )
+      end
+
       if health.nil?
         output << "failed#NOT_FOUND"
       else

data/lib/litmus_paper/cache.rb

@@ -1,3 +1,5 @@
+require 'fileutils'
+require 'tempfile'
 require 'yaml'
 
 module LitmusPaper
@@ -11,12 +13,24 @@ module LitmusPaper
 
     def set(key, value)
       return unless @ttl > 0
-      File.open(File.join(@path, key), "a") do |f|
-        f.flock(File::LOCK_EX)
-        f.rewind
-        f.write("#{Time.now.to_f + @ttl} #{YAML::dump(value)}")
-        f.flush
-        f.truncate(f.pos)
+      filename = File.join(@path, key)
+      if File.exist?(filename)
+        File.open(filename, "r+") do |f|
+          f.flock(File::LOCK_EX)
+          f.rewind
+          f.write(_entry(@ttl, value))
+          f.flush
+          f.truncate(f.pos)
+        end
+      else
+        temp = Tempfile.new("#{key}_init", @path)
+        begin
+          temp.write(_entry(@ttl, value))
+          temp.flush
+        ensure
+          temp.close
+        end
+        FileUtils.mv(temp.path, filename)
       end
     end
 
@@ -29,5 +43,9 @@ module LitmusPaper
         expires_at.to_f < Time.now.to_f ? nil : YAML::load(value)
       end
     end
+
+    def _entry(ttl, value)
+      "#{Time.now.to_f + ttl} #{YAML::dump(value)}"
+    end
   end
 end

data/lib/litmus_paper/configuration_file.rb

@@ -1,3 +1,5 @@
+require 'yaml'
+
 module LitmusPaper
   class ConfigurationFile
     def initialize(config_file_path)
@@ -12,7 +14,11 @@ module LitmusPaper
     def evaluate(file = @config_file_path)
       LitmusPaper.logger.info "Loading file #{file}"
       config_contents = File.read(file)
-      instance_eval(config_contents)
+      if file =~ /\.(yaml|yml)/
+        load_yaml(config_contents)
+      else
+        instance_eval(config_contents)
+      end
       LitmusPaper::Configuration.new(
         @port,
         @data_directory,
@@ -45,6 +51,64 @@ module LitmusPaper
       @services[name.to_s] = service
     end
 
+    def yaml_service(value)
+      value.each do |name, config|
+        config = Util.symbolize_keys(config)
+        dependencies = parse_yaml_dependencies(config.fetch(:dependencies, []))
+        checks = parse_yaml_checks(config.fetch(:checks, []))
+        service = Service.new(name.to_s, dependencies, checks)
+        @services[name.to_s] = service
+      end
+    end
+
+    def parse_yaml_checks(config)
+      config.map do |check|
+        check_config = Util.symbolize_keys(check)
+        case check[:type].to_sym
+          when :big_brother_service
+            Metric::BigBrotherService.new(check_config.delete(:service))
+          when :cpu_load
+            Metric::CPULoad.new(check_config.delete(:weight))
+          when :constant_metric
+            Metric::ConstantMetric.new(check_config.delete(:weight))
+          when :internet_health
+            weight = check_config.delete(:weight)
+            hosts = check_config.delete(:hosts)
+            Metric::InternetHealth.new(weight, hosts, check_config)
+          when :script
+            command = check_config.delete(:command)
+            weight = check_config.delete(:weight)
+            Metric::Script.new(command, weight, check_config)
+        end
+      end
+    end
+
+    def parse_yaml_dependencies(config)
+      config.map do |dep|
+        dep_config = Util.symbolize_keys(dep)
+        case dep[:type].to_sym
+          when :file_contents
+            path = dep_config.delete(:path)
+            regex = dep_config.delete(:regex)
+            Dependency::FileContents.new(path, regex, dep_config)
+          when :haproxy_backends
+            domain_socket = dep_config.delete(:domain_socket)
+            cluster = dep_config.delete(:cluster)
+            Dependency::HaproxyBackends.new(domain_socket, cluster, dep_config)
+          when :http
+            uri = dep_config.delete(:uri)
+            Dependency::HTTP.new(uri, dep_config)
+          when "script"
+            command = dep_config.delete(:command)
+            Dependency::Script.new(command, options)
+          when "tcp"
+            ip = dep_config.delete(:ip)
+            port = dep_config.delete(:port)
+            Dependency::TCP.new(ip, port, dep_config)
+        end
+      end
+    end
+
     def cache_location(location)
       @cache_location = location
     end
@@ -52,5 +116,18 @@ module LitmusPaper
     def cache_ttl(ttl)
       @cache_ttl = ttl
     end
+
+    def load_yaml(contents)
+      config = Util.symbolize_keys(YAML.load(contents))
+
+      config.each do |key, value|
+        case key
+        when :include_files, :data_directory, :cache_location, :cache_ttl, :port
+          send(key, value)
+        when :services
+          yaml_service(value)
+        end
+      end
+    end
   end
 end

data/lib/litmus_paper/util.rb

@@ -0,0 +1,12 @@
+module LitmusPaper
+  class Util
+    def self.symbolize_keys(hash)
+      hash.keys.each do |k|
+        new_key = (k.to_sym rescue k.to_s.to_sym)
+        hash[new_key] = hash.delete(k)
+      end
+
+      hash
+    end
+  end
+end

data/lib/litmus_paper/version.rb

@@ -1,3 +1,3 @@
 module LitmusPaper
-  VERSION = "1.1.1"
+  VERSION = "1.2.0"
 end

data/lib/litmus_paper.rb

@@ -31,6 +31,7 @@ require 'litmus_paper/metric/internet_health'
 require 'litmus_paper/metric/script'
 require 'litmus_paper/service'
 require 'litmus_paper/status_file'
+require 'litmus_paper/util'
 require 'litmus_paper/version'
 
 module LitmusPaper

data/spec/litmus_paper/agent_check_handler_spec.rb

@@ -2,6 +2,10 @@ require 'spec_helper'
 require 'litmus_paper/agent_check_handler'
 
 describe LitmusPaper::AgentCheckHandler do
+  def app
+    LitmusPaper::App
+  end
+
   before :each do
     LitmusPaper.configure(TEST_CONFIG)
   end
@@ -73,5 +77,39 @@ describe LitmusPaper::AgentCheckHandler do
       LitmusPaper::StatusFile.global_up_file.create("Up for testing")
       LitmusPaper::AgentCheckHandler.handle("test").should == "ready\tup\t100%"
     end
+
+    it "retrieves a cached value during the cache_ttl" do
+      begin
+        cache = LitmusPaper::AgentCheckHandler.instance_variable_get(:@cache)
+        cache.instance_variable_set(:@ttl, 0.25)
+        LitmusPaper::AgentCheckHandler.instance_variable_set(:@cache, cache)
+
+        test_service = LitmusPaper::Service.new(
+          'test',
+          [AlwaysAvailableDependency.new],
+          [LitmusPaper::Metric::ConstantMetric.new(100)]
+        )
+        LitmusPaper.services['test'] = test_service
+
+        post "/test/health", :reason => "health for testing", :health => 88
+        last_response.status.should == 201
+
+        LitmusPaper::AgentCheckHandler.handle('test').should == "ready\tup\t88%"
+
+        delete "/test/health"
+        last_response.status.should == 200
+
+        LitmusPaper::AgentCheckHandler.handle('test').should == "ready\tup\t88%"
+
+        sleep 0.25
+
+        LitmusPaper::AgentCheckHandler.handle('test').should_not == "ready\tup\t88%"
+      ensure
+        FileUtils.rm_rf(LitmusPaper.cache_location)
+        cache = LitmusPaper::AgentCheckHandler.instance_variable_get(:@cache)
+        cache.instance_variable_set(:@ttl, -1)
+        LitmusPaper::AgentCheckHandler.instance_variable_set(:@cache, cache)
+      end
+    end
   end
 end

data/spec/litmus_paper/cache_spec.rb

@@ -70,5 +70,13 @@ describe LitmusPaper::Cache do
       sleep ttl
       cache.get(key).should be_nil
     end
+
+    it "works when setting multiple entries" do
+      key = "key"
+      cache = LitmusPaper::Cache.new(@location, @namespace, 1)
+      cache.set(key, "some value")
+      cache.set(key, "other value")
+      cache.get(key).should == "other value"
+    end
   end
 end

data/spec/litmus_paper/configuration_file_spec.rb

@@ -8,29 +8,59 @@ describe LitmusPaper::ConfigurationFile do
       config.services.has_key?('test').should == true
     end
 
+    it "configures a service via yaml" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_YAML_CONFIG)
+      config = config_file.evaluate
+      config.services.has_key?('test').should == true
+    end
+
     it "configures the port to listen on" do
       config_file = LitmusPaper::ConfigurationFile.new(TEST_CONFIG)
       config = config_file.evaluate
       config.port.should == 9293
     end
 
+    it "configures the port to listen on via yaml" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_YAML_CONFIG)
+      config = config_file.evaluate
+      config.port.should == 9293
+    end
+
     it "configures the data directory" do
       config_file = LitmusPaper::ConfigurationFile.new(TEST_CONFIG)
       config = config_file.evaluate
       config.data_directory.should == "/tmp/litmus_paper"
     end
 
+    it "configures the data directory via yaml" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_YAML_CONFIG)
+      config = config_file.evaluate
+      config.data_directory.should == "/tmp/litmus_paper"
+    end
+
     it "configures the cache_location" do
       config_file = LitmusPaper::ConfigurationFile.new(TEST_CONFIG)
       config = config_file.evaluate
       config.cache_location.should == "/tmp/litmus_paper_cache"
     end
 
+    it "configures the cache_location via yaml" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_YAML_CONFIG)
+      config = config_file.evaluate
+      config.cache_location.should == "/tmp/litmus_paper_cache"
+    end
+
     it "configures the cache_ttl" do
       config_file = LitmusPaper::ConfigurationFile.new(TEST_CONFIG)
       config = config_file.evaluate
       config.cache_ttl.should == -1
     end
+
+    it "configures the cache_ttl via yaml" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_YAML_CONFIG)
+      config = config_file.evaluate
+      config.cache_ttl.should == -1
+    end
   end
 
   describe "include_files" do
@@ -40,6 +70,19 @@ describe LitmusPaper::ConfigurationFile do
       config.services.has_key?('test').should == true
     end
 
+    it "configures a dir glob of services in yaml" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_YAML_D_CONFIG)
+      config = config_file.evaluate
+      config.services.has_key?('test').should == true
+    end
+
+    it "configures a dir glob of mixed services" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_MIXED_D_CONFIG)
+      config = config_file.evaluate
+      config.services.has_key?('test').should == true
+      config.services.has_key?('passing_test').should == true
+    end
+
     it "defaults configuration options" do
       config_file = LitmusPaper::ConfigurationFile.new(TEST_D_CONFIG)
       config = config_file.evaluate
@@ -47,5 +90,21 @@ describe LitmusPaper::ConfigurationFile do
       config.port.should == 9292
       config.data_directory.should == "/etc/litmus"
     end
+
+    it "defaults configuration options in yaml" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_YAML_D_CONFIG)
+      config = config_file.evaluate
+      config.services.has_key?('test').should == true
+      config.port.should == 9292
+      config.data_directory.should == "/etc/litmus"
+    end
+
+    it "defaults configuration options in mixed dir" do
+      config_file = LitmusPaper::ConfigurationFile.new(TEST_MIXED_D_CONFIG)
+      config = config_file.evaluate
+      config.services.has_key?('test').should == true
+      config.port.should == 9292
+      config.data_directory.should == "/etc/litmus"
+    end
   end
 end

data/spec/spec_helper.rb

@@ -8,9 +8,12 @@ require 'tempfile'
 
 TEST_CONFIG_DIR = "/tmp/litmus_paper"
 TEST_CONFIG = File.expand_path('support/test.config', File.dirname(__FILE__))
+TEST_YAML_CONFIG = File.expand_path('support/test.config.yaml', File.dirname(__FILE__))
 TEST_RELOAD_CONFIG = File.expand_path('support/test.reload.config', File.dirname(__FILE__))
 TEST_UNICORN_CONFIG = File.expand_path('support/test.unicorn.config', File.dirname(__FILE__))
 TEST_D_CONFIG = File.expand_path('support/test.d.config', File.dirname(__FILE__))
+TEST_YAML_D_CONFIG = File.expand_path('support/test.d.config.yaml', File.dirname(__FILE__))
+TEST_MIXED_D_CONFIG = File.expand_path('support/test.d.config.mixed', File.dirname(__FILE__))
 TEST_CA_CERT = File.expand_path('ssl/server.crt', File.dirname(__FILE__))
 
 Dir.glob("#{File.expand_path('support', File.dirname(__FILE__))}/**/*.rb").each { |f| require f }

data/spec/support/config.d.mixed/passing_test.config

@@ -0,0 +1,5 @@
+# vim: ft=ruby
+
+service :passing_test do |s|
+  s.measure_health Metric::CPULoad, :weight => 50
+end

data/spec/support/config.d.mixed/test.config.yaml

@@ -0,0 +1,9 @@
+# vim: ft=ruby
+services:
+  test:
+    dependencies:
+      - type: http
+        uri: 'http://localhost/heartbeat'
+    checks:
+      - type: cpu_load
+        weight: 50

data/spec/support/config.d.yaml/passing_test.config.yaml

@@ -0,0 +1,6 @@
+# vim: ft=ruby
+services:
+  passing_test:
+    checks:
+      - type: cpu_load
+        weight: 50

data/spec/support/config.d.yaml/test.config.yaml

@@ -0,0 +1,9 @@
+# vim: ft=ruby
+services:
+  test:
+    dependencies:
+      - type: http
+        uri: 'http://localhost/heartbeat'
+    checks:
+      - type: cpu_load
+        weight: 50

data/spec/support/test.config.yaml

@@ -0,0 +1,20 @@
+# vim: set ft=ruby
+port: 9293
+data_directory: "/tmp/litmus_paper"
+cache_location: "/tmp/litmus_paper_cache"
+cache_ttl: -1
+services:
+  test:
+    dependencies:
+      - type: http
+        uri: 'http://localhost/heartbeat'
+    checks:
+      - type: cpu_load
+        weight: 50
+  passing_test:
+    dependencies:
+      - type: script
+        command: '/bin/true'
+    checks:
+      - type: cpu_load
+        weight: 50

data/spec/support/test.d.config.mixed

@@ -0,0 +1,2 @@
+# vim: ft=ruby
+include_files 'config.d.mixed/*.config*'

data/spec/support/test.d.config.yaml

@@ -0,0 +1,2 @@
+# vim: ft=ruby
+include_files: 'config.d.yaml/*.config.yaml'

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: litmus_paper
 version: !ruby/object:Gem::Version
-  version: 1.1.1
+  version: 1.2.0
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2018-01-25 00:00:00.000000000 Z
+date: 2018-04-24 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: sinatra
@@ -153,6 +153,7 @@ files:
 - .rake_commit
 - .ruby-version
 - .travis.yml
+- Dockerfile
 - Gemfile
 - LICENSE
 - README.md
@@ -161,6 +162,8 @@ files:
 - bin/litmus-agent-check
 - bin/litmusctl
 - config.ru
+- docker/litmus.conf
+- docker/litmus_unicorn.rb
 - lib/litmus_paper.rb
 - lib/litmus_paper/agent_check_handler.rb
 - lib/litmus_paper/agent_check_server.rb
@@ -190,6 +193,7 @@ files:
 - lib/litmus_paper/service.rb
 - lib/litmus_paper/status_file.rb
 - lib/litmus_paper/terminal_output.rb
+- lib/litmus_paper/util.rb
 - lib/litmus_paper/version.rb
 - litmus-agent-check.init.sh
 - litmus_paper.gemspec
@@ -219,6 +223,11 @@ files:
 - spec/ssl/server.crt
 - spec/ssl/server.key
 - spec/support/always_available_dependency.rb
+- spec/support/config.d.mixed/.passing_test.config.swp
+- spec/support/config.d.mixed/passing_test.config
+- spec/support/config.d.mixed/test.config.yaml
+- spec/support/config.d.yaml/passing_test.config.yaml
+- spec/support/config.d.yaml/test.config.yaml
 - spec/support/config.d/passing_test.config
 - spec/support/config.d/test.config
 - spec/support/haproxy_test_socket
@@ -227,7 +236,10 @@ files:
 - spec/support/never_available_dependency.rb
 - spec/support/stdout_logger.rb
 - spec/support/test.config
+- spec/support/test.config.yaml
 - spec/support/test.d.config
+- spec/support/test.d.config.mixed
+- spec/support/test.d.config.yaml
 - spec/support/test.reload.config
 - spec/support/test.unicorn.config
 homepage: https://github.com/braintree/litmus_paper
@@ -250,7 +262,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
       version: '0'
 requirements: []
 rubyforge_project: 
-rubygems_version: 1.8.24
+rubygems_version: 1.8.23
 signing_key: 
 specification_version: 3
 summary: Backend health tester for HA Services, partner project of big_brother
@@ -280,6 +292,11 @@ test_files:
 - spec/ssl/server.crt
 - spec/ssl/server.key
 - spec/support/always_available_dependency.rb
+- spec/support/config.d.mixed/.passing_test.config.swp
+- spec/support/config.d.mixed/passing_test.config
+- spec/support/config.d.mixed/test.config.yaml
+- spec/support/config.d.yaml/passing_test.config.yaml
+- spec/support/config.d.yaml/test.config.yaml
 - spec/support/config.d/passing_test.config
 - spec/support/config.d/test.config
 - spec/support/haproxy_test_socket
@@ -288,6 +305,9 @@ test_files:
 - spec/support/never_available_dependency.rb
 - spec/support/stdout_logger.rb
 - spec/support/test.config
+- spec/support/test.config.yaml
 - spec/support/test.d.config
+- spec/support/test.d.config.mixed
+- spec/support/test.d.config.yaml
 - spec/support/test.reload.config
 - spec/support/test.unicorn.config