falcore 0.1.0

data/spec/functional/dumpers/statsd_spec.rb

@@ -0,0 +1,44 @@
+require 'spec_helper'
+
+module Falcore
+  describe Dumper::Statsd, :integration do
+    let(:config) do
+      Config.parse <<-EOH.gsub(/^ {8}/, '')
+        [jenkins]
+          endpoint = http://master.jenkins.example.com
+
+        [statsd]
+          host = #{RSpec::Statsd.host}
+          port = #{RSpec::Statsd.port}
+      EOH
+    end
+
+    let(:aggregator) { Aggregator.new(config) }
+    let(:master) { aggregator.run }
+
+    let(:statsd) { RSpec::Statsd.query("gauges *") }
+
+    subject { Dumper::Statsd.new(config, master) }
+
+    it 'validates config.statsd.host is present' do
+      config.statsd.host = nil
+
+      expect {
+        subject.run
+      }.to raise_error(RuntimeError, "Expected 'Statsd host' to be set!")
+    end
+
+    it 'validates config.statsd.port is present' do
+      config.statsd.port = nil
+
+      expect {
+        subject.run
+      }.to raise_error(RuntimeError, "Expected 'Statsd port' to be set!")
+    end
+
+    it 'adds the offline status' do
+      subject.run
+      expect(statsd).to include("'jenkins.master-jenkins-example-com.offline': 0")
+    end
+  end
+end

data/spec/functional/fetcher_spec.rb

@@ -0,0 +1,39 @@
+require 'spec_helper'
+
+module Falcore
+  describe Fetcher, :integration do
+    describe '.get' do
+      context 'when given something that is not a URL' do
+        it 'raises a RuntimeError' do
+          expect {
+            Fetcher.get('/path/to/file')
+          }.to raise_error(RuntimeError)
+        end
+      end
+
+      context 'when given something that is a 404' do
+        it 'raises a RuntimeError' do
+          expect {
+            Fetcher.get('http://jenkins.local/foo/bar')
+          }.to raise_error(RuntimeError)
+        end
+      end
+
+      context 'when given something that would raise a SocketError' do
+        it 'raises a RuntimeError' do
+          expect {
+            Fetcher.get('http://jenkins.local:5000/foo/bar')
+          }.to raise_error(RuntimeError)
+        end
+      end
+
+      context 'when given invalid JSON' do
+        it 'raises RuntimeError' do
+          expect {
+            Fetcher.get('http://jenkins.local/bad_json')
+          }.to raise_error(RuntimeError)
+        end
+      end
+    end
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,34 @@
+require 'bundler/setup'
+require 'rspec'
+require 'webmock/rspec'
+
+# Require our library
+require 'falcore'
+
+Dir[File.expand_path('../support/**/*.rb', __FILE__)].each { |f| require f }
+
+RSpec.configure do |config|
+  # Custom helper modules and extensions
+
+  # Prohibit using the should syntax
+  config.expect_with :rspec do |spec|
+    spec.syntax = :expect
+  end
+
+  # Allow tests to isolate a specific test using +focus: true+. If nothing
+  # is focused, then all tests are executed.
+  config.filter_run(focus: true)
+  config.run_all_when_everything_filtered = true
+  config.treat_symbols_as_metadata_keys_with_true_values = true
+
+  # Start our fake Jenkins endpoint when integrating
+  config.before(:each, :integration) do
+    stub_request(:any, /.+/).to_rack(RSpec::JenkinsServer)
+  end
+
+  # Run specs in random order to surface order dependencies. If you find an
+  # order dependency and want to debug it, you can fix the order by providing
+  # the seed, which is printed after each run.
+  #     --seed 1234
+  config.order = 'random'
+end

data/spec/support/server.rb

@@ -0,0 +1,14 @@
+require 'sinatra/base'
+
+module RSpec
+  class JenkinsServer < Sinatra::Base
+    get('/bad_json') do
+      'This is not JSON, bro...'
+    end
+
+    get('/computer/api/json') do
+      content_type 'application/json'
+      File.read(File.expand_path('../../fixtures/computer.json', __FILE__))
+    end
+  end
+end

data/spec/support/statsd.rb

@@ -0,0 +1,129 @@
+require 'socket'
+require 'timeout'
+
+module RSpec
+  class Statsd
+    class << self
+      #
+      # @private
+      #
+      # Delegate everything to the instance
+      #
+      def method_missing(m, *args, &block)
+        if instance.respond_to?(m)
+          instance.public_send(m, *args, &block)
+        else
+          super
+        end
+      end
+    end
+
+    require 'singleton'
+    include Singleton
+
+    attr_reader :pid
+
+    def initialize
+      clone! unless File.exist?(cache_dir)
+      configure!
+      start!
+    end
+
+    def start!
+      unless @pid
+        @pid = Process.spawn("node #{cache_dir}/stats.js #{config}", out: '/dev/null')
+        sleep(0.5)
+
+        at_exit do
+          if @pid
+            Process.kill('INT', @pid)
+            Process.waitpid2(@pid)
+          end
+        end
+      end
+
+      @pid
+    end
+
+    #
+    # Query Statsd for some information and then read the response. This is
+    # incredibly brittle and should be the first place you look when debugging
+    # tests.
+    #
+    # @param [String] message
+    #   the message to send
+    #
+    # @return [String]
+    #   the response
+    #
+    def query(message)
+      unless @connection
+        @connection = TCPSocket.new(host, admin_port)
+      end
+
+      @connection.send("#{message}\\000", 0)
+
+      # This is a really super hack way to make sure the socket actually returns
+      # some information.
+      response = []
+      begin
+        Timeout.timeout(0.1) do
+          while line = @connection.gets
+            response << line.strip
+          end
+        end
+      rescue Timeout::Error
+      end
+
+      response.join("\n")
+    end
+
+    def host
+      @host ||= '127.0.0.1'
+    end
+
+    def port
+      @port ||= random_open_port
+    end
+
+    def admin_port
+      @admin_port ||= random_open_port
+    end
+
+    private
+
+    def random_open_port
+      server = TCPServer.new('127.0.0.1', 0)
+      port = server.addr[1]
+      server.close
+
+      port
+    end
+
+    def clone!
+      %x|git clone https://github.com/etsy/statsd.git #{cache_dir} > /dev/null 2>&1|
+    end
+
+    def configure!
+      File.open(config, 'w') do |f|
+        f.write <<-EOH.gsub(/^ {10}/, '')
+          {
+            address: '#{host}',
+            port:    #{port},
+
+            mgmt_address: '#{host}',
+            mgmt_port: #{admin_port}
+          }
+        EOH
+      end
+    end
+
+    def config
+      @config ||= File.join(cache_dir, 'config.js')
+    end
+
+    def cache_dir
+      @cache_dir ||= File.expand_path('../../../tmp/statsd', __FILE__)
+    end
+  end
+end

data/spec/unit/aggregator_spec.rb

@@ -0,0 +1,33 @@
+require 'spec_helper'
+
+module Falcore
+  describe Aggregator do
+    let(:endpoint) { 'http://jenkins.local' }
+    let(:config)   { Config.new(endpoint: endpoint) }
+    let(:computer) { JSON.parse(File.read(File.expand_path('../../fixtures/computer.json', __FILE__))) }
+
+    before do
+      Fetcher.stub(:get).and_return(computer)
+    end
+
+    subject { Aggregator.new(config) }
+
+    describe '#run' do
+      let(:master) { subject.run }
+
+      it 'returns a master jenkins node' do
+        expect(master).to be_a(Node::Master)
+      end
+
+      it 'adds the slaves to the master' do
+        expect(master.slaves.size).to eq(3)
+      end
+
+      it 'correctly builds each slave object' do
+        expect(master.slaves[0].display_name).to eq('slave1.jenkins.example.com')
+        expect(master.slaves[1].display_name).to eq('slave2.jenkins.example.com')
+        expect(master.slaves[2].display_name).to eq('slave3.jenkins.example.com')
+      end
+    end
+  end
+end

data/spec/unit/config_spec.rb

@@ -0,0 +1,55 @@
+require 'spec_helper'
+
+module Falcore
+  describe Config do
+    describe '.from_file' do
+      context 'when the file does not exist' do
+        before { File.stub(:read).and_raise(Errno::ENOENT) }
+
+        it 'raises an exception' do
+          expect { Config.from_file('/foo/bar') }.to raise_error(RuntimeError)
+        end
+      end
+
+      context 'when the file exists' do
+        let(:path)   { '/config/file' }
+        let(:config) { Config.from_file(path) }
+        let(:contents) do
+          <<-EOH.gsub(/^ {12}/, '')
+            [jenkins]
+              endpoint = http://localhost
+
+            [statsd]
+              host = http://my.statsd.server
+              port = 8125
+
+            # This section is commented out for testing purposes
+            # [nrpe]
+            #   out = STDOUT
+          EOH
+        end
+
+        before { File.stub(:read).with(path).and_return(contents) }
+
+        it 'returns a config object' do
+          expect(config).to be_a(Config)
+        end
+
+        it 'has the properly nested keys' do
+          expect(config.jenkins.endpoint).to eq('http://localhost')
+          expect(config.statsd.host).to eq('http://my.statsd.server')
+          expect(config.statsd.port).to eq(8125)
+        end
+
+        it 'returns a NullObject for ultimate awesomeness' do
+          expect(config.foo).to be_nil
+          expect(config.foo.bar.zip.zap.billy.bob).to be_nil
+        end
+
+        it 'ignores commented lines' do
+          expect(config).to_not have_key('nrpe')
+        end
+      end
+    end
+  end
+end

data/spec/unit/nodes/base_spec.rb

@@ -0,0 +1,329 @@
+require 'spec_helper'
+
+module Falcore
+  describe Node::Base do
+    subject do
+      Node::Base.new(
+        'displayName' => 'jenkins.example.com',
+        'idle'         => true,
+      )
+    end
+
+    describe '#initialize' do
+      let(:data) { { 'this' => 'that' } }
+
+      subject { Node::Base.new(data) }
+
+      it 'saves the data to @data' do
+        expect(subject.instance_variable_get(:@data)).to eq(data)
+      end
+
+      it 'dups the data' do
+        expect(data).to receive(:dup).once
+        subject
+      end
+    end
+
+    its(:id) { should eq('jenkins.jenkins-example-com') }
+    its(:display_name) { should eq('jenkins.example.com') }
+
+    describe '#idle?' do
+      context 'when @data.idle is true' do
+        subject { Node::Base.new('idle' => true) }
+        its(:idle?) { should be_true }
+      end
+
+      context 'when @data.idle is false' do
+        subject { Node::Base.new('idle' => false) }
+        its(:idle?) { should be_false }
+      end
+
+      context 'when @data.idle is nil' do
+        subject { Node::Base.new('idle' => nil) }
+        its(:idle?) { should be_false }
+      end
+    end
+
+    describe '#executors' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:executors) { should eq(0) }
+      end
+
+      context 'when the value is a string' do
+        subject { Node::Base.new('numExecutors' => '5') }
+        its(:executors) { should eq(5) }
+      end
+
+      context 'when the value is an integer' do
+        subject { Node::Base.new('numExecutors' => 10) }
+        its(:executors) { should eq(10) }
+      end
+    end
+
+    describe '#offline?' do
+      context 'when @data.offline is true' do
+        subject { Node::Base.new('offline' => true) }
+        its(:offline?) { should be_true }
+      end
+
+      context 'when @data.offline is false' do
+        subject { Node::Base.new('offline' => false) }
+        its(:offline?) { should be_false }
+      end
+
+      context 'when @data.offline is nil' do
+        subject { Node::Base.new('offline' => nil) }
+        its(:offline?) { should be_false }
+      end
+    end
+
+    describe '#temporarily_offline?' do
+      context 'when @data.temporarily_offline is true' do
+        subject { Node::Base.new('temporarilyOffline' => true) }
+        its(:temporarily_offline?) { should be_true }
+      end
+
+      context 'when @data.temporarily_offline is false' do
+        subject { Node::Base.new('temporarilyOffline' => false) }
+        its(:temporarily_offline?) { should be_false }
+      end
+
+      context 'when @data.temporarily_offline is nil' do
+        subject { Node::Base.new('temporarilyOffline' => nil) }
+        its(:temporarily_offline?) { should be_false }
+      end
+    end
+
+    describe '#response_time' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:response_time) { should eq(0.0) }
+      end
+
+      context 'when the value is a string' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.ResponseTimeMonitor' => {
+                'average' => '0.332'
+              }
+            }
+          )
+        end
+        its(:response_time) { should eq(0.332) }
+      end
+
+      context 'when the value is an integer' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.ResponseTimeMonitor' => {
+                'average' => 0.194
+              }
+            }
+          )
+        end
+        its(:response_time) { should eq(0.194) }
+      end
+    end
+
+    describe '#temporary_space' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:temporary_space) { should eq(0) }
+      end
+
+      context 'when the value is a string' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.TemporarySpaceMonitor' => {
+                'size' => '16421466112'
+              }
+            }
+          )
+        end
+        its(:temporary_space) { should eq(16421466112) }
+      end
+
+      context 'when the value is an integer' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.TemporarySpaceMonitor' => {
+                'size' => 4421461112
+              }
+            }
+          )
+        end
+        its(:temporary_space) { should eq(4421461112) }
+      end
+    end
+
+    describe '#disk_space' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:disk_space) { should eq(0) }
+      end
+
+      context 'when the value is a string' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.DiskSpaceMonitor' => {
+                'size' => '26424266182'
+              }
+            }
+          )
+        end
+        its(:disk_space) { should eq(26424266182) }
+      end
+
+      context 'when the value is an integer' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.DiskSpaceMonitor' => {
+                'size' => 1490284902
+              }
+            }
+          )
+        end
+        its(:disk_space) { should eq(1490284902) }
+      end
+    end
+
+    describe '#free_memory' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:free_memory) { should eq(0) }
+      end
+
+      context 'when the value is a string' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'availablePhysicalMemory' => '3719038410'
+              }
+            }
+          )
+        end
+        its(:free_memory) { should eq(3719038410) }
+      end
+
+      context 'when the value is an integer' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'availablePhysicalMemory' => 193042
+              }
+            }
+          )
+        end
+        its(:free_memory) { should eq(193042) }
+      end
+    end
+
+    describe '#total_memory' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:total_memory) { should eq(0) }
+      end
+
+      context 'when the value is a string' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'totalPhysicalMemory' => '28904283'
+              }
+            }
+          )
+        end
+        its(:total_memory) { should eq(28904283) }
+      end
+
+      context 'when the value is an integer' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'totalPhysicalMemory' => 89048092
+              }
+            }
+          )
+        end
+        its(:total_memory) { should eq(89048092) }
+      end
+    end
+
+    describe '#free_swap' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:free_swap) { should eq(0) }
+      end
+
+      context 'when the value is a string' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'availableSwapSpace' => '319048091'
+              }
+            }
+          )
+        end
+        its(:free_swap) { should eq(319048091) }
+      end
+
+      context 'when the value is an integer' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'availableSwapSpace' => 83903890
+              }
+            }
+          )
+        end
+        its(:free_swap) { should eq(83903890) }
+      end
+    end
+
+    describe '#total_swap' do
+      context 'when the value is nil' do
+        subject { Node::Base.new }
+        its(:total_swap) { should eq(0) }
+      end
+
+      context 'when the value is a string' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'totalSwapSpace' => '319894031'
+              }
+            }
+          )
+        end
+        its(:total_swap) { should eq(319894031) }
+      end
+
+      context 'when the value is an integer' do
+        subject do
+          Node::Base.new(
+            'monitorData' => {
+              'hudson.node_monitors.SwapSpaceMonitor' => {
+                'totalSwapSpace' => 8390183190
+              }
+            }
+          )
+        end
+        its(:total_swap) { should eq(8390183190) }
+      end
+    end
+  end
+end