build_status_server 0.8 → 0.9

data/lib/build_status_server/server.rb

@@ -1,9 +1,6 @@
-# TODO
-# move all configuration stuff to Config
-# and just call config[:blaj] instead of if blah
 module BuildStatusServer
   class Server
-    attr_reader :config, :store
+    attr_reader :config, :store, :udp_server
 
     def initialize(options = {})
       @config = Config.new
@@ -11,30 +8,11 @@ module BuildStatusServer
     end
 
     def listen
-      sock = UDPSocket.new
-      udp_server = config.udp_server
-
-      begin
-        sock.bind(udp_server["address"], udp_server["port"])
-      rescue Errno::EADDRINUSE
-        STDERR.puts <<-EOT
-There appears that another instance is running, or another process
-is listening at the same port (#{udp_server["address"]}:#{udp_server["port"]}
-
-        EOT
-        exit
-      end
-
-      puts "Listening on UDP #{udp_server["address"]}:#{udp_server["port"]}" if config.verbose
+      setup_udp_server
 
       begin
         while true
-          data, addr = sock.recvfrom(2048)
-
-          if process_job(data)
-            status = process_all_statuses
-            notify(status)
-          end
+          process_loop
         end
       rescue Interrupt
         puts "Good bye."
@@ -45,6 +23,39 @@ is listening at the same port (#{udp_server["address"]}:#{udp_server["port"]}
 
     private
 
+    def process_loop
+      data, addr = udp_server.recvfrom(2048)
+
+      if process_job(data)
+        status = process_all_statuses
+        notify(status)
+      end
+    end
+
+    def setup_udp_server
+      address, port = config.udp_server["address"], config.udp_server["port"]
+      @udp_server = UDPSocket.new
+
+      begin
+        udp_server.bind(address, port)
+      rescue Errno::EADDRINUSE
+        STDERR.puts <<-EOT
+There appears that another instance is running, or another process
+is listening on the same port (#{address}:#{port})
+
+        EOT
+        exit
+      rescue Errno::EADDRNOTAVAIL
+        STDERR.puts <<-EOT
+The address configured is not available (#{address})
+
+        EOT
+        exit
+      end
+
+      STDOUT.puts "Listening on UDP #{address}:#{port}" if config.verbose
+    end
+
     def load_store
       @store = begin
                  YAML.load_file(config.store_file)
@@ -75,7 +86,8 @@ is listening at the same port (#{udp_server["address"]}:#{udp_server["port"]}
       status = job["build"]["status"]
 
       if phase == "FINISHED"
-        STDOUT.puts "Got #{status} for #{build_name} on #{Time.now} [#{job.inspect}]" if config.verbose
+        # Got SUCCESS for topic_action_master on Tue May 01 12:02:31 -0400 2012 []
+        STDOUT.puts "Got #{status} for #{build_name} on #{Time.now} [#{job_internals(job)}]" if config.verbose
         case status
         when "SUCCESS", "FAILURE"
           load_store
@@ -84,12 +96,18 @@ is listening at the same port (#{udp_server["address"]}:#{udp_server["port"]}
           return true
         end
       else
-        STDOUT.puts "Started for #{build_name} on #{Time.now} [#{job.inspect}]" if config.verbose
+        # Started for topic_action_master on Tue May 01 12:00:30 -0400 2012 [{"name"=>"topic_action_master", "url"=>"job/topic_action_master/", "build"=>{"number"=>98, "url"=>"job/topic_action_master/98/", "phase"= >"STARTED", "full_url"=>"http://ci.berman.challengepost.com/job/topic_action_master/98/"}}]
+        # Started for topic_action_master on Tue May 01 12:02:31 -0400 2012 [{"name"=>"topic_action_master", "url"=>"job/topic_action_master/", "build"=>{"number"=>98, "url"=>"job/topic_action_master/98/", "status" =>"SUCCESS", "phase"=>"COMPLETED", "full_url"=>"http://ci.berman.challengepost.com/job/topic_action_master/98/"}}]
+        STDOUT.puts "Started for #{build_name} on #{Time.now} [#{job_internals(job)}]" if config.verbose
       end
 
       return false
     end
 
+    def job_internals(job)
+      "build=>#{job["build"]["number"]}, status=>#{job["build"]["status"]}"
+    end
+
     def should_process_build(build_name)
       # If mask exists, then ...
       ! (
@@ -103,7 +121,7 @@ is listening at the same port (#{udp_server["address"]}:#{udp_server["port"]}
     def process_all_statuses
       pass = true
 
-      @store.values.each do |val|
+      store.values.each do |val|
         pass &&= (val == "pass" || val == "SUCCESS")
       end
 
@@ -112,10 +130,12 @@ is listening at the same port (#{udp_server["address"]}:#{udp_server["port"]}
 
     def notify(status)
       tcp_client = config.tcp_client
+      tcp_client["attempts"] ||= 2
 
       attempts = 0
       light  = status ? tcp_client["pass"] : tcp_client["fail"]
 
+      client = nil
       begin
         timeout(5) do
           attempts += 1
@@ -123,39 +143,18 @@ is listening at the same port (#{udp_server["address"]}:#{udp_server["port"]}
           client.print "GET #{light} HTTP/1.0\n\n"
           answer = client.gets(nil)
           STDOUT.puts answer if config.verbose
-          client.close
         end
       rescue Timeout::Error => ex
         STDERR.puts "Error: #{ex} while trying to send #{light}"
-        retry unless attempts > 2
+        retry unless attempts > tcp_client["attempts"]
       rescue Errno::ECONNREFUSED, Errno::EHOSTUNREACH => ex
         STDERR.puts "Error: #{ex} while trying to send #{light}"
         STDERR.puts "Will wait for 2 seconds and try again..."
         sleep 2
-        retry unless attempts > 2
+        retry unless attempts > tcp_client["attempts"]
+      ensure
+        client.close if client
       end
     end
   end
 end
-
-__END__
-
-Example payload:
-{
-  "name":"test",
-  "url":"job/test/",
-  "build":{
-    "full_url":"http://cronus.local:3001/job/test/20/",
-    "number":20,
-    "phase":"FINISHED",
-    "status":"SUCCESS",
-    "url":"job/test/20/"
-  }
-}
-
-We're getting this error once in a while:
-/usr/local/lib/ruby/1.8/timeout.rb:64:in `notify': execution expired (Timeout::Error)
-        from /home/jcmuller/build_notifier/lib/server.rb:102:in `notify'
-        from /home/jcmuller/build_notifier/lib/server.rb:33:in `listen'
-        from bin/server:5
-

data/lib/build_status_server/version.html

@@ -0,0 +1,32 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <meta http-equiv="content-type" content="text/html;charset=utf-8">
+  <title>version.rb</title>
+  <link rel="stylesheet" href="http://jashkenas.github.com/docco/resources/docco.css">
+</head>
+<body>
+<div id='container'>
+  <div id="background"></div>
+  <div id="jump_to">
+    Jump To &hellip;
+    <div id="jump_wrapper">
+      <div id="jump_page">
+          <a class="source" href="../build_status_server.html">build_status_server.rb</a>
+          <a class="source" href="config.html">config.rb</a>
+          <a class="source" href="server.html">server.rb</a>
+          <a class="source" href="version.html">version.rb</a>
+      </div>
+    </div>
+  </div>
+  <table cellspacing=0 cellpadding=0>
+  <thead>
+    <tr>
+      <th class=docs><h1>version.rb</h1></th>
+      <th class=code></th>
+    </tr>
+  </thead>
+  <tbody>
+  </table>
+</div>
+</body>

data/lib/build_status_server/version.rb

@@ -1,3 +1,3 @@
 module BuildStatusServer
-  VERSION = "0.8"
+  VERSION = "0.9"
 end

data/spec/lib/build_status_server/config_spec.rb

@@ -1,6 +1,6 @@
-require 'spec_helper'
-require 'build_status_server'
-require 'tempfile'
+require "spec_helper"
+require "build_status_server"
+require "tempfile"
 
 describe BuildStatusServer::Config do
   let(:config) { BuildStatusServer::Config.new }
@@ -15,7 +15,7 @@ describe BuildStatusServer::Config do
     it "should set the config values from yaml file" do
       config.should_receive(:load_config_file).and_return(YAML.load(config.send(:get_example_config)))
       config.load
-      config.udp_server.should == {'address' => '127.0.0.1', 'port' => 1234}
+      config.udp_server.should == {"address" => "127.0.0.1", "port" => 1234}
       config.verbose.should == false
     end
   end
@@ -24,7 +24,7 @@ describe BuildStatusServer::Config do
     it "should load the yaml file passed in as a file argument" do
       file_name = nil
 
-      Tempfile.open('config') do |f|
+      Tempfile.open(["config", ".yml"]) do |f|
         f.puts "---"
         f.puts "key: value"
         f.puts "key2: value2"
@@ -39,7 +39,7 @@ describe BuildStatusServer::Config do
 
     it "should try to load paths from the locations to try" do
       file_name = nil
-      Tempfile.open("config") do |f|
+      Tempfile.open(["config", ".yml"]) do |f|
         f.puts "---"
         f.puts "key: value"
         f.puts "key2: value2"
@@ -60,7 +60,7 @@ describe BuildStatusServer::Config do
 
     it "should throw an exception if the config file isn't a hash" do
       file_name = nil
-      Tempfile.open(file_name) do |f|
+      Tempfile.open(["base", ".yml"]) do |f|
         f.puts "YADDA YADDA"
         file_name = f.path
       end

data/spec/lib/build_status_server/server_spec.rb

@@ -5,12 +5,101 @@ describe BuildStatusServer::Server do
   let(:server) { BuildStatusServer::Server.new }
 
   before do
-    STDERR.should_receive :puts
+    STDERR.should_receive(:puts)
   end
 
   describe "#listen"
 
   context "private methods" do
+
+    describe "#setup_udp_server" do
+      it "reads the udp_server options from configuration file" do
+        server.config.stub!(:udp_server).and_return({"address" => "address", "port" => "port"})
+        socket = mock(:udp_socket)
+        socket.should_receive(:bind).with("address", "port")
+        UDPSocket.should_receive(:new).and_return(socket)
+
+        server.send(:setup_udp_server)
+      end
+
+      it "instantiates a UDPSocket object and binds it to address and port" do
+        server.config.stub!(:udp_server).and_return({"address" => "127.0.0.1", "port" => "9999"})
+
+        server.send(:setup_udp_server)
+
+        client = UDPSocket.new
+        client.connect("127.0.0.1", 9999)
+        client.send "hello, world!", 0
+        msg = server.udp_server.recvfrom(13)
+
+        msg[0].should == "hello, world!"
+        ["AF_INET", "127.0.0.1"].each do |e|
+          msg[1].should include e
+        end
+      end
+
+      it "should show message and exit when connecting to address not available" do
+        server.config.stub!(:udp_server).and_return({"address" => "192.192.192.192", "port" => "9999"})
+
+        STDERR.should_receive(:puts).with("The address configured is not available (192.192.192.192)\n\n")
+        server.should_receive(:exit)
+
+        server.send(:setup_udp_server)
+      end
+
+      it "it recovers from an address in use exception" do
+        server.config.stub!(:udp_server).and_return({"address" => "127.0.0.1", "port" => "9999"})
+
+        socket = mock(:udp_socket)
+        socket.should_receive(:bind).and_raise(Errno::EADDRINUSE)
+        UDPSocket.should_receive(:new).and_return(socket)
+
+        STDERR.should_receive(:puts).with("There appears that another instance is running, or another process\nis listening on the same port (127.0.0.1:9999)\n\n")
+        server.should_receive(:exit)
+        server.send(:setup_udp_server)
+      end
+
+      it "if verbose is enabled, show message" do
+        server.config.stub!(:udp_server).and_return({"address" => "address", "port" => "port"})
+        socket = mock(:udp_socket)
+        socket.should_receive(:bind).with("address", "port")
+        UDPSocket.should_receive(:new).and_return(socket)
+
+        server.config.stub!(:verbose).and_return(true)
+        STDOUT.should_receive(:puts).with("Listening on UDP address:port")
+
+        server.send(:setup_udp_server)
+      end
+    end
+
+    describe "#process_loop" do
+      it "should process all statuses and notify when process job returns true" do
+        socket = mock(:udp_socket)
+        socket.stub!(:recvfrom).and_return("data", "addr")
+
+        server.should_receive(:udp_server).and_return(socket)
+        server.should_receive(:process_job).with("data").and_return(true)
+
+        server.should_receive(:process_all_statuses).and_return("status")
+        server.should_receive(:notify).with("status")
+
+        server.send(:process_loop)
+      end
+
+      it "should not process all statuses or notify when process job returns false" do
+        socket = mock(:udp_socket)
+        socket.stub!(:recvfrom).and_return("data", "addr")
+
+        server.should_receive(:udp_server).and_return(socket)
+        server.should_receive(:process_job).with("data").and_return(false)
+
+        server.should_not_receive(:process_all_statuses)
+        server.should_not_receive(:notify)
+
+        server.send(:process_loop)
+      end
+    end
+
     describe "#load_store" do
       before do
         server.config.stub!(:store_file).and_return("/tmp/build")
@@ -38,19 +127,12 @@ describe BuildStatusServer::Server do
       end
     end
 
-    describe "#notify"
-    describe "#process_all_statuses"
-    describe "#process_job"
-
     describe "#should_process_build" do
       context "when mask exists" do
-        before do
-          server.stub!(:mask).and_return(%r{.*(?:master).*})
-        end
 
         context "when policy is include" do
           before do
-            server.stub!(:mask_policy).and_return("include")
+            server.config.stub!(:mask).and_return({"policy" => "include", "regex" => %r{.*(?:master).*}})
           end
 
           it "ignores builds if mask doesn't match build name" do
@@ -64,7 +146,7 @@ describe BuildStatusServer::Server do
 
         context "when policy is exclude" do
           before do
-            server.config.stub!(:mask).and_return({"policy" => "exclude", "regex" => /.*(?:master).*/})
+            server.config.stub!(:mask).and_return({"policy" => "exclude", "regex" => %r{.*(?:master).*}})
           end
 
           it "ignores builds if mask matches build name" do
@@ -105,7 +187,7 @@ describe BuildStatusServer::Server do
         end
       end
 
-      context "when mask doesn't" do
+      context "when mask regex doesn't" do
         before do
           server.config.stub!(:mask).and_return({"policy" => "include", "regex" => nil})
         end
@@ -115,6 +197,201 @@ describe BuildStatusServer::Server do
         end
       end
     end
+
+    describe "#process_job" do
+      it "returns false if should_process_build returns false" do
+        server.should_receive(:should_process_build).and_return(false)
+        server.send(:process_job).should be_false
+      end
+
+      it "returns false and says so on stderr if payload doesn't have a hash for build" do
+        server.should_receive(:should_process_build).and_return(true)
+        JSON.should_receive(:parse).and_return({"build" => "Not a hash!"})
+        STDERR.should_receive(:puts).with("Pinged with an invalid payload")
+        server.send(:process_job).should be_false
+      end
+
+      it "returns false and says that the we got the job started when phase is FINISHED but status isn't success nor failure" do
+        server.config.should_receive(:verbose).and_return(true)
+        server.should_receive(:should_process_build).and_return(true)
+        JSON.should_receive(:parse).with("{}").and_return({
+          "name" => "name",
+          "build" => { "phase" => "FINISHED", "status" => "some status", "number" => "number" }
+        })
+        Time.should_receive(:now).and_return("this is the time")
+        STDOUT.should_receive(:puts).with('Got some status for name on this is the time [build=>number, status=>some status]')
+        server.send(:process_job).should be_false
+      end
+
+      it "returns false and says that the job started when the phase isn't finished" do
+        server.config.should_receive(:verbose).and_return(true)
+        server.should_receive(:should_process_build).and_return(true)
+        JSON.should_receive(:parse).with("{}").and_return({
+          "name" => "name",
+          "build" => { "phase" => "STARTED", "status" => "some status", "number" => "number" }
+        })
+        Time.should_receive(:now).and_return("this is the time")
+        STDOUT.should_receive(:puts).with("Started for name on this is the time [build=>number, status=>some status]")
+        server.send(:process_job).should be_false
+      end
+
+      context "phase is FINISHED and status is either SUCCESS or FAILURE" do
+        before do
+          server.config.should_receive(:verbose).and_return(true)
+          server.should_receive(:should_process_build).and_return(true)
+          Time.should_receive(:now).and_return("this is the time")
+          YAML.should_receive(:load_file).and_return({})
+          File.should_receive(:open)
+        end
+
+        it "should return true and write yaml file when phase is FINISHED and status is SUCCESS" do
+          JSON.should_receive(:parse).with("{}").and_return({
+            "name" => "name",
+            "build" => { "phase" => "FINISHED", "status" => "SUCCESS", "number" => "number" }
+          })
+          STDOUT.should_receive(:puts).with("Got SUCCESS for name on this is the time [build=>number, status=>SUCCESS]")
+
+          server.send(:process_job).should be_true
+        end
+
+        it "should return true and write yaml file when phase is FINISHED and status is FAILURE" do
+          JSON.should_receive(:parse).with("{}").and_return({
+            "name" => "name",
+            "build" => { "phase" => "FINISHED", "status" => "FAILURE", "number" => "number" }
+          })
+          STDOUT.should_receive(:puts).with("Got FAILURE for name on this is the time [build=>number, status=>FAILURE]")
+
+          server.send(:process_job).should be_true
+        end
+      end
+    end
+
+    describe "#notify" do
+      let(:client) { mock(:client) }
+
+      context "no exceptions" do
+        before do
+          options = {
+            "pass" => "pass",
+            "fail" => "fail",
+            "host" => "host",
+            "port" => "port"
+          }
+          config = mock(:config)
+          config.should_receive(:tcp_client).and_return(options)
+          config.should_receive(:verbose).and_return(true)
+
+          server.should_receive(:config).twice.and_return(config)
+
+          STDOUT.should_receive(:puts).with("answer")
+
+          client.should_receive(:gets).and_return("answer")
+          client.should_receive(:close)
+
+          TCPSocket.should_receive(:new).with("host", "port").and_return(client)
+        end
+
+        it "should send passing packet to tcp socket when status is true" do
+          client.should_receive(:print).with("GET pass HTTP/1.0\n\n")
+          server.send(:notify, true)
+        end
+
+        it "should send failing packet to tcp socket when status is false" do
+          client.should_receive(:print).with("GET fail HTTP/1.0\n\n")
+          server.send(:notify, false)
+        end
+      end
+
+      context "exceptions" do
+        before do
+          options = {
+            "fail" => "fail",
+            "host" => "host",
+            "port" => "port",
+            "attempts" => 2
+          }
+          config = mock(:config)
+          config.should_receive(:tcp_client).and_return(options)
+          config.should_receive(:verbose).and_return(false)
+
+          server.should_receive(:config).twice.and_return(config)
+          client.should_receive(:close)
+
+          client.should_receive(:gets).and_return("answer")
+        end
+
+        it "should time out and retry 2 times" do
+          TCPSocket.should_receive(:new).exactly(3).with("host", "port").and_return(client)
+          STDERR.should_receive(:puts).exactly(2).with("Error: Timeout::Error while trying to send fail")
+          client.should_receive(:print).exactly(2).with("GET fail HTTP/1.0\n\n").and_raise(Timeout::Error)
+          client.should_receive(:print).with("GET fail HTTP/1.0\n\n")
+
+          server.send(:notify, false)
+        end
+
+        it "should not connect and retry 2 times" do
+          STDERR.should_receive(:puts).with("Error: Connection refused while trying to send fail")
+          STDERR.should_receive(:puts).with("Error: No route to host while trying to send fail")
+          STDERR.should_receive(:puts).exactly(2).with("Will wait for 2 seconds and try again...")
+
+          TCPSocket.should_receive(:new).with("host", "port").and_raise(Errno::ECONNREFUSED)
+          TCPSocket.should_receive(:new).with("host", "port").and_raise(Errno::EHOSTUNREACH)
+          TCPSocket.should_receive(:new).with("host", "port").and_return(client)
+
+          server.should_receive(:sleep).twice.with(2)
+
+          client.should_receive(:print).with("GET fail HTTP/1.0\n\n")
+
+          server.send(:notify, false)
+        end
+      end
+
+      it "should gracefully recover if config doesn't have attempts configured" do
+        options = {
+          "fail" => "fail",
+          "host" => "host",
+          "port" => "port"
+        }
+
+        config = mock(:config)
+        config.should_receive(:tcp_client).and_return(options)
+        config.should_receive(:verbose).and_return(false)
+
+        server.should_receive(:config).twice.and_return(config)
+        client.should_receive(:close)
+
+        client.should_receive(:gets).and_return("answer")
+        TCPSocket.should_receive(:new).exactly(3).with("host", "port").and_return(client)
+        STDERR.should_receive(:puts).exactly(2).with("Error: Timeout::Error while trying to send fail")
+        client.should_receive(:print).exactly(2).with("GET fail HTTP/1.0\n\n").and_raise(Timeout::Error)
+        client.should_receive(:print).with("GET fail HTTP/1.0\n\n")
+
+        server.send(:notify, false)
+      end
+    end
+
+    describe "#process_all_statuses" do
+      it "should return true if all values are SUCCESS" do
+        server.should_receive(:store).and_return(mock(:blah, :values => %w(SUCCESS SUCCESS SUCCESS)))
+        server.send(:process_all_statuses).should be_true
+      end
+
+      it "should return true if all values are pass" do
+        server.should_receive(:store).and_return(mock(:blah, :values => %w(pass pass pass)))
+        server.send(:process_all_statuses).should be_true
+      end
+
+      it "should return true if some values are pass and some are SUCCESS" do
+        server.should_receive(:store).and_return(mock(:blah, :values => %w(SUCCESS pass SUCCESS)))
+        server.send(:process_all_statuses).should be_true
+      end
+
+      it "should return false if at least one value isn't pass or SUCCESS" do
+        server.should_receive(:store).and_return(mock(:blah, :values => %w(SUCCESS blah SUCCESS)))
+        server.send(:process_all_statuses).should be_false
+      end
+    end
+
   end
 end