janky 0.9.0 → 0.9.9

data/lib/janky/builder/http.rb

@@ -8,6 +8,10 @@ module Janky
 
       def run(params, create_url)
         http     = Net::HTTP.new(create_url.host, create_url.port)
+        if create_url.scheme == "https"
+          http.use_ssl = true
+        end
+
         request  = Net::HTTP::Post.new(create_url.path)
         if @username && @password
           request.basic_auth(@username, @password)
@@ -24,6 +28,10 @@ module Janky
 
       def output(url)
         http     = Net::HTTP.new(url.host, url.port)
+        if url.scheme == "https"
+          http.use_ssl = true
+        end
+
         request  = Net::HTTP::Get.new(url.path)
         if @username && @password
           request.basic_auth(@username, @password)

data/lib/janky/builder/receiver.rb

@@ -10,7 +10,7 @@ module Janky
         elsif payload.completed?
           Build.complete(payload.id, payload.green?)
         else
-          return Rack::Response.new("Invalid", 402).finish
+          return Rack::Response.new("Bad Request", 400).finish
         end
 
         Rack::Response.new("OK", 201).finish

data/lib/janky/{campfire.rb → chat_service.rb}

@@ -1,39 +1,48 @@
 module Janky
-  # Sends messages to Campfire and accesses available rooms.
-  module Campfire
-    # Setup the Campfire client with the given credentials.
+  module ChatService
+    Room = Struct.new(:id, :name)
+
+    # Setup the adapter used to notify chat rooms of build status.
     #
-    # account - the Campfire account name as a String.
-    # token   - the Campfire API token as a String.
-    # default - the name of the default Campfire room as a String.
+    # name     - Service name as a string.
+    # settings - Service-specific setting hash.
+    # default  - Name of the default chat room as a String.
     #
     # Returns nothing.
-    def self.setup(account, token, default)
-      ::Broach.settings = {
-        "account" => account,
-        "token"   => token,
-        "use_ssl" => true
-      }
+    def self.setup(name, settings, default)
+      klass = adapters[name]
+
+      if !klass
+        raise Error, "Unknown chat service: #{name.inspect}. Available " \
+          "services are #{adapters.keys.join(", ")}"
+      end
 
-      self.default_room_name = default
+      @adapter = klass.new(settings)
+      @default_room_name = default
     end
 
     class << self
-      attr_accessor :default_room_name
+      attr_accessor :adapter, :default_room_name
+    end
+
+    # Registry of available chat implementations.
+    def self.adapters
+      @adapters ||= {}
     end
 
     def self.default_room_id
       room_id(default_room_name)
     end
 
-    # Send a message to a Campfire room.
+    # Send a message to a Chat room.
     #
     # message - The String message.
     # room_id - The Integer room ID.
+    # options - Optional hash passed to the chat adapter.
     #
     # Returns nothing.
-    def self.speak(message, room_id)
-      adapter.speak(room_name(room_id), message)
+    def self.speak(message, room_id, options = {})
+      adapter.speak(message, room_id, options)
     end
 
     # Get the ID of a room.
@@ -67,9 +76,9 @@ module Janky
 
     # Memoized list of available rooms.
     #
-    # Returns an Array of Broach::Room objects.
+    # Returns an Array of Room objects.
     def self.rooms
-      @rooms ||= adapter.rooms
+      adapter.rooms
     end
 
     # Enable mocking. Once enabled, messages are discarded.
@@ -87,41 +96,5 @@ module Janky
     def self.rooms=(value)
       adapter.rooms = value
     end
-
-    def self.adapter
-      @adapter ||= Broach.new
-    end
-
-    class Broach
-      def speak(room_name, message)
-        ::Broach.speak(room_name, message)
-      end
-
-      def rooms
-        ::Broach.rooms
-      end
-    end
-
-    class Mock
-      def initialize
-        @rooms = {}
-      end
-
-      attr_writer :rooms
-
-      def speak(room_name, message)
-        if !@rooms.values.include?(room_name)
-          raise Error, "Unknown room #{room_name.inspect}"
-        end
-      end
-
-      def rooms
-        acc = []
-        @rooms.each do |id, name|
-          acc << ::Broach::Room.new("id" => id, "name" => name)
-        end
-        acc
-      end
-    end
   end
 end

data/lib/janky/chat_service/campfire.rb

@@ -0,0 +1,33 @@
+module Janky
+  module ChatService
+    class Campfire
+      def initialize(settings)
+        account = settings["JANKY_CHAT_CAMPFIRE_ACCOUNT"]
+        if account.nil? || account.empty?
+          raise Error, "JANKY_CHAT_CAMPFIRE_ACCOUNT setting is required"
+        end
+
+        token = settings["JANKY_CHAT_CAMPFIRE_TOKEN"]
+        if token.nil? || token.empty?
+          raise Error, "JANKY_CHAT_CAMPFIRE_TOKEN setting is required"
+        end
+
+        Broach.settings = {
+          "account" => account,
+          "token"   => token,
+          "use_ssl" => true,
+        }
+      end
+
+      def speak(message, room_id, opts={})
+        Broach.speak(ChatService.room_name(room_id), message)
+      end
+
+      def rooms
+        @rooms ||= Broach.rooms.map do |room|
+          Room.new(room.id, room.name)
+        end
+      end
+    end
+  end
+end

data/lib/janky/chat_service/hipchat.rb

@@ -0,0 +1,29 @@
+require "hipchat"
+
+module Janky
+  module ChatService
+    class HipChat
+      def initialize(settings)
+        token = settings["JANKY_CHAT_HIPCHAT_TOKEN"]
+        if token.nil? || token.empty?
+          raise Error, "JANKY_CHAT_HIPCHAT_TOKEN setting is required"
+        end
+
+        @client = ::HipChat::Client.new(token)
+        @from = settings["JANKY_CHAT_HIPCHAT_FROM"] || "CI"
+      end
+
+      def speak(message, room_id, options = {:color => "yellow"})
+        @client[room_id].send(@from, message, options)
+      end
+
+      def rooms
+        @rooms ||= @client.rooms.map do |room|
+          Room.new(room.room_id, room.name)
+        end
+      end
+    end
+  end
+
+  register_chat_service "hipchat", ChatService::HipChat
+end

data/lib/janky/chat_service/mock.rb

@@ -0,0 +1,26 @@
+module Janky
+  module ChatService
+    # Mock chat implementation used in testing environments.
+    class Mock
+      def initialize
+        @rooms = {}
+      end
+
+      attr_writer :rooms
+
+      def speak(room_name, message)
+        if !@rooms.values.include?(room_name)
+          raise Error, "Unknown room #{room_name.inspect}"
+        end
+      end
+
+      def rooms
+        acc = []
+        @rooms.each do |id, name|
+          acc << Room.new(id, name)
+        end
+        acc
+      end
+    end
+  end
+end

data/lib/janky/database/migrate/1312115512_init.rb

@@ -3,7 +3,7 @@ class Init < ActiveRecord::Migration
     create_table :repositories, :force => true do |t|
       t.string :name, :null => false
       t.string :uri,  :null => false
-      t.integer :room_id, :default => 376289, :null => false # Builds room
+      t.integer :room_id, :null => false
       t.timestamps
     end
     add_index :repositories, :name, :unique => true

data/lib/janky/exception.rb

@@ -48,6 +48,29 @@ module Janky
       end
     end
 
+    class Logger
+      def initialize(stream)
+        @stream = stream
+        @context = {}
+      end
+
+      def reset!
+        @context = {}
+      end
+
+      def report(e, context={})
+        @stream.puts "ERROR: #{e.class} - #{e.message}\n"
+        @context.each do |k, v|
+          @stream.puts "%12s %4s\n" % [k, v]
+        end
+        @stream.puts "\n#{e.backtrace.join("\n")}"
+      end
+
+      def push(context)
+        @context.update(context)
+      end
+    end
+
     class Mock
       def self.push(context)
       end

data/lib/janky/github.rb

@@ -1,36 +1,43 @@
 module Janky
   module GitHub
-    def self.setup(user, password, secret, url)
-      @user     = user
+    # Setup the GitHub API client and Post-Receive hook endpoint.
+    #
+    # user     - API user as a String.
+    # password - API password as a String.
+    # secret   - Secret used to sign hook requests from GitHub.
+    # hook_url - String URL that handles Post-Receive requests.
+    # api_url  - GitHub API URL as a String. Requires a trailing slash.
+    # git_host - Hostname where git repos are hosted. e.g. "github.com"
+    #
+    # Returns nothing.
+    def self.setup(user, password, secret, hook_url, api_url, git_host)
+      @user = user
       @password = password
-      @secret   = secret
-      @url      = url
+      @secret = secret
+      @hook_url = hook_url
+      @api_url = api_url
+      @git_host = git_host
     end
 
     class << self
-      attr_reader :secret
-    end
-
-    def self.enable_mock!
-      @api = Mock.new(@user, @password)
-    end
-
-    def self.repo_make_private(nwo)
-      api.make_private(nwo)
-    end
-
-    def self.repo_make_public(nwo)
-      api.make_public(nwo)
-    end
-
-    def self.repo_make_unauthorized(nwo)
-      api.make_unauthorized(nwo)
+      attr_reader :secret, :git_host
     end
 
+    # Rack app that handles Post-Receive hook requests from GitHub.
+    #
+    # Returns a GitHub::Receiver.
     def self.receiver
       @receiver ||= Receiver.new(@secret)
     end
 
+    # Fetch repository details.
+    # http://developer.github.com/v3/repos/#get
+    #
+    # nwo - qualified "owner/repo" name.
+    #
+    # Returns the Hash representation of the repo, nil when it doesn't exists
+    #   or access was denied.
+    # Raises an Error for any unexpected response.
     def self.repo_get(nwo)
       response = api.repo_get(nwo)
 
@@ -45,8 +52,15 @@ module Janky
       end
     end
 
+    # Create a Post-Receive hook for the given repository.
+    # http://developer.github.com/v3/repos/hooks/#create-a-hook
+    #
+    # nwo - qualified "owner/repo" name.
+    #
+    # Returns the newly created hook URL as String when successful.
+    # Raises an Error for any other response.
     def self.hook_create(nwo)
-      response = api.create(nwo, @secret, @url)
+      response = api.create(nwo, @secret, @hook_url)
 
       if response.code == "201"
         Yajl.load(response.body)["url"]
@@ -56,12 +70,57 @@ module Janky
       end
     end
 
+    # Check existance of a hook.
+    # http://developer.github.com/v3/repos/hooks/#get-single-hook
+    #
+    # url - Hook URL as a String.
     def self.hook_exists?(url)
       api.get(url).code == "200"
     end
 
+    # Default API implementation that goes over the wire (HTTP).
+    #
+    # Returns nothing.
     def self.api
-      @api ||= API.new(@user, @password)
+      @api ||= API.new(@api_url, @user, @password)
+    end
+
+    # Turn on mock mode, meaning no request goes over the wire. Useful in
+    # testing environments.
+    #
+    # Returns nothing.
+    def self.enable_mock!
+      @api = Mock.new(@user, @password)
+    end
+
+    # Make any subsequent response for the given repository look like as if
+    # it was a private repo.
+    #
+    # nwo - qualified "owner/repo" name.
+    #
+    # Returns nothing.
+    def self.repo_make_private(nwo)
+      api.make_private(nwo)
+    end
+
+    # Make any subsequent request to the given repository succeed. Only
+    # available in mock mode.
+    #
+    # nwo - qualified "owner/repo" name.
+    #
+    # Returns nothing.
+    def self.repo_make_public(nwo)
+      api.make_public(nwo)
+    end
+
+    # Make any subsequent request for the given repository fail with an
+    # unauthorized response. Only available when mocked.
+    #
+    # nwo - qualified "owner/repo" name.
+    #
+    # Returns nothing.
+    def self.repo_make_unauthorized(nwo)
+      api.make_unauthorized(nwo)
     end
   end
 end

data/lib/janky/github/api.rb

@@ -1,13 +1,14 @@
 module Janky
   module GitHub
     class API
-      def initialize(user, password)
-        @user     = user
+      def initialize(url, user, password)
+        @url = url
+        @user = user
         @password = password
       end
 
       def create(nwo, secret, url)
-        request = Net::HTTP::Post.new("/repos/#{nwo}/hooks")
+        request = Net::HTTP::Post.new(build_path("repos/#{nwo}/hooks"))
         payload = build_payload(url, secret)
         request.body = Yajl.dump(payload)
         request.basic_auth(@user, @password)
@@ -16,15 +17,15 @@ module Janky
       end
 
       def trigger(hook_url)
-        path    = URI(hook_url).path
-        request = Net::HTTP::Post.new("#{path}/test")
+        path    = build_path(URI(hook_url).path + "/test")
+        request = Net::HTTP::Post.new(path)
         request.basic_auth(@user, @password)
 
         http.request(request)
       end
 
       def get(hook_url)
-        path    = URI(hook_url).path
+        path    = build_path(URI(hook_url).path)
         request = Net::HTTP::Get.new(path)
         request.basic_auth(@user, @password)
 
@@ -32,13 +33,21 @@ module Janky
       end
 
       def repo_get(nwo)
-        path    = "/repos/#{nwo}"
+        path    = build_path("repos/#{nwo}")
         request = Net::HTTP::Get.new(path)
         request.basic_auth(@user, @password)
 
         http.request(request)
       end
 
+      def build_path(path)
+        if path[0] == ?/
+          URI.join(@url, path[1..-1]).path
+        else
+          URI.join(@url, path).path
+        end
+      end
+
       def build_payload(url, secret)
         { "name"   => "web",
           "active" => true,
@@ -55,7 +64,7 @@ module Janky
       end
 
       def http!
-        uri  = URI("https://api.github.com")
+        uri  = URI(@url)
         http = Net::HTTP.new(uri.host, uri.port)
 
         http.use_ssl     = true