janky 0.9.0

data/lib/janky/builder.rb

@@ -0,0 +1,108 @@
+module Janky
+  # Triggers Jenkins builds and handles callbacks.
+  #
+  # The HTTP requests flow goes like this:
+  #
+  # 1. Send a Build request to the Jenkins server over HTTP. The resulting
+  #    build URL is stored in Build#url.
+  #
+  # 2. Once Jenkins picks up the build and starts running it, it sends a callback
+  #    handled by the `receiver` Rack app, which transitions the build into a
+  #    building state.
+  #
+  # 3. Finally, Jenkins sends another callback with the build result and the
+  #    build is transitioned to a completed and green/red state.
+  #
+  # The Mock adapter provides methods to simulate that flow without having to
+  # go over the wire.
+  module Builder
+    # Set the callback URL of builder clients. Must be called before
+    # registering any client.
+    #
+    # callback_url - The absolute callback URL as a String.
+    #
+    # Returns nothing.
+    def self.setup(callback_url)
+      @callback_url = callback_url
+    end
+
+    # Public: Define the rule for picking a builder.
+    #
+    # block - Required block that will be given a Repository object when
+    #         picking a builder. Must return a Client object.
+    #
+    # Returns nothing.
+    def self.choose(&block)
+      @chooser = block
+    end
+
+    # Pick the appropriate builder for a repo based on the rule set by the
+    # choose method. Uses the default builder when no rule is defined.
+    #
+    # repo - a Repository object.
+    #
+    # Returns a Client object.
+    def self.pick_for(repo)
+      if block = @chooser
+        block.call(repo)
+      else
+        self[:default]
+      end
+    end
+
+    # Register a new build host.
+    #
+    # url - The String URL of the Jenkins server.
+    #
+    # Returns the new Client instance.
+    def self.[]=(builder, url)
+      builders[builder] = Client.new(url, @callback_url)
+    end
+
+    # Get the Client for a registered build host.
+    #
+    # builder - the String name of the build host.
+    #
+    # Returns the Client instance.
+    def self.[](builder)
+      builders[builder] ||
+        raise(Error, "Unknown builder: #{builder.inspect}")
+    end
+
+    # Registered build hosts.
+    #
+    # Returns an Array of Client.
+    def self.builders
+      @builders ||= {}
+    end
+
+    # Rack app handling HTTP callbacks coming from the Jenkins server.
+    def self.receiver
+      @receiver ||= Janky::Builder::Receiver
+    end
+
+    def self.enable_mock!
+      builders.values.each { |b| b.enable_mock! }
+    end
+
+    def self.green!
+      builders.values.each { |b| b.green! }
+    end
+
+    def self.red!
+      builders.values.each { |b| b.red! }
+    end
+
+    def self.reset!
+      builders.values.each { |b| b.reset! }
+    end
+
+    def self.start!
+      builders.values.each { |b| b.start! }
+    end
+
+    def self.complete!
+      builders.values.each { |b| b.complete! }
+    end
+  end
+end

data/lib/janky/builder/client.rb

@@ -0,0 +1,82 @@
+module Janky
+  module Builder
+    class Client
+      def initialize(url, callback_url)
+        @url          = URI(url)
+        @callback_url = URI(callback_url)
+      end
+
+      # The String absolute URL of the Jenkins server.
+      attr_reader :url
+
+      # The String absoulte URL callback of this Janky host.
+      attr_reader :callback_url
+
+      # Trigger a Jenkins build for the given Build.
+      #
+      # build - a Build object.
+      #
+      # Returns the Jenkins build URL.
+      def run(build)
+        Runner.new(@url, build, adapter).run
+      end
+
+      # Retrieve the output of the given Build.
+      #
+      # build - a Build object. Must have an url attribute.
+      #
+      # Returns the String build output.
+      def output(build)
+        Runner.new(@url, build, adapter).output
+      end
+
+      # Setup a job on the Jenkins server.
+      #
+      # name          - The desired job name as a String.
+      # repo_uri      - The repository git URI as a String.
+      # template_path - The Pathname to the XML config template.
+      #
+      # Returns nothing.
+      def setup(name, repo_uri, template_path)
+        job_creator.run(name, repo_uri, template_path)
+      end
+
+      # The adapter used to trigger builds. Defaults to HTTP, which hits the
+      # Jenkins server configured by `setup`.
+      def adapter
+        @adapter ||= HTTP.new(url.user, url.password)
+      end
+
+      def job_creator
+        @job_creator ||= JobCreator.new(url, @callback_url)
+      end
+
+      # Enable the mock adapter and make subsequent builds green.
+      def green!
+        @adapter = Mock.new(true, Janky.app)
+        job_creator.enable_mock!
+      end
+
+      # Alias green! as enable_mock!
+      alias_method :enable_mock!, :green!
+
+      # Alias green! as reset!
+      alias_method :reset!, :green!
+
+      # Enable the mock adapter and make subsequent builds red.
+      def red!
+        @adapter = Mock.new(false, Janky.app)
+      end
+
+      # Simulate the first callback. Only available when mocked.
+      def start!
+        @adapter.start
+      end
+
+      # Simulate the last callback. Only available when mocked.
+      def complete!
+        @adapter.complete
+      end
+    end
+  end
+end

data/lib/janky/builder/http.rb

@@ -0,0 +1,43 @@
+module Janky
+  module Builder
+    class HTTP
+      def initialize(username, password)
+        @username = username
+        @password = password
+      end
+
+      def run(params, create_url)
+        http     = Net::HTTP.new(create_url.host, create_url.port)
+        request  = Net::HTTP::Post.new(create_url.path)
+        if @username && @password
+          request.basic_auth(@username, @password)
+        end
+        request.form_data = {"json" => params}
+
+        response = http.request(request)
+
+        unless response.code == "302"
+          Exception.push_http_response(response)
+          raise Error, "Failed to create build"
+        end
+      end
+
+      def output(url)
+        http     = Net::HTTP.new(url.host, url.port)
+        request  = Net::HTTP::Get.new(url.path)
+        if @username && @password
+          request.basic_auth(@username, @password)
+        end
+
+        response = http.request(request)
+
+        unless response.code == "200"
+          Exception.push_http_response(response)
+          raise Error, "Failed to get build output"
+        end
+
+        response.body
+      end
+    end
+  end
+end

data/lib/janky/builder/mock.rb

@@ -0,0 +1,45 @@
+module Janky
+  module Builder
+    class Mock
+      def initialize(green, app)
+        @green    = green
+        @app      = app
+        @builds   = []
+      end
+
+      def run(params, create_url)
+        params   = Yajl.load(params)["parameter"]
+        param    = params.detect{ |p| p["name"] == "JANKY_ID" }
+        build_id = param["value"]
+        url      = create_url.to_s.gsub("build", build_id.to_s)
+
+        @builds << [build_id, "#{url}/", @green]
+      end
+
+      def output(build)
+        "....FFFUUUUUUU"
+      end
+
+      def start
+        @builds.each do |id, url, _|
+          payload = Payload.start(id, url)
+          request(payload)
+        end
+      end
+
+      def complete
+        @builds.each do |id, _, green|
+          payload = Payload.complete(id, green)
+          request(payload)
+        end
+        @builds.clear
+      end
+
+      def request(payload)
+        Rack::MockRequest.new(@app).post("/_builder",
+          :input => payload.to_json
+        )
+      end
+    end
+  end
+end

data/lib/janky/builder/payload.rb

@@ -0,0 +1,63 @@
+module Janky
+  module Builder
+    class Payload
+      def self.parse(json)
+        parsed = Yajl.load(json)
+        build  = parsed["build"]
+
+        new(
+          build["phase"],
+          build["parameters"]["JANKY_ID"],
+          build["full_url"],
+          build["status"]
+        )
+      end
+
+      def self.start(id, url)
+        new("STARTED", id, url, nil)
+      end
+
+      def self.complete(id, green)
+        status = (green ? "SUCCESS" : "FAILED")
+        new("FINISHED", id, nil, status)
+      end
+
+      def initialize(phase, id, url, status)
+        @phase      = phase
+        @id         = id
+        @url        = url
+        @status     = status
+      end
+
+      attr_reader :id, :url
+
+      def started?
+        @phase == "STARTED"
+      end
+
+      def completed?
+        @phase == "FINISHED"
+      end
+
+      def green?
+        if completed?
+          @status == "SUCCESS"
+        else
+          false
+        end
+      end
+
+      def to_json
+        { :build => {
+            :phase    => @phase,
+            :status   => @status,
+            :full_url => @url,
+            :parameters => {
+              "JANKY_ID" => @id
+            }
+          }
+        }.to_json
+      end
+    end
+  end
+end

data/lib/janky/builder/receiver.rb

@@ -0,0 +1,20 @@
+module Janky
+  module Builder
+    class Receiver
+      def self.call(env)
+        request = Rack::Request.new(env)
+        payload = Payload.parse(request.body)
+
+        if payload.started?
+          Build.start(payload.id, payload.url)
+        elsif payload.completed?
+          Build.complete(payload.id, payload.green?)
+        else
+          return Rack::Response.new("Invalid", 402).finish
+        end
+
+        Rack::Response.new("OK", 201).finish
+      end
+    end
+  end
+end

data/lib/janky/builder/runner.rb

@@ -0,0 +1,47 @@
+module Janky
+  module Builder
+    class Runner
+      def initialize(base_url, build, adapter)
+        @base_url = base_url
+        @build    = build
+        @adapter  = adapter
+      end
+
+      def run
+        context_push
+        @adapter.run(json_params, create_url)
+      end
+
+      def output
+        context_push
+        @adapter.output(output_url)
+      end
+
+      def json_params
+        Yajl.dump(:parameter => [
+          { :name => "JANKY_SHA1", :value => @build.sha1 },
+          { :name => "JANKY_ID",   :value => @build.id }
+        ])
+      end
+
+      def output_url
+        URI(@build.url + "consoleText")
+      end
+
+      def create_url
+        URI("#{@base_url}job/#{@build.repo_job_name}/build")
+      end
+
+      def context_push
+        Exception.push(
+          :base_url   => @base_url.inspect,
+          :build      => @build.inspect,
+          :adapter    => @adapter.inspect,
+          :params     => json_params.inspect,
+          :create_url => create_url.inspect
+        )
+      end
+    end
+  end
+end
+

data/lib/janky/campfire.rb

@@ -0,0 +1,127 @@
+module Janky
+  # Sends messages to Campfire and accesses available rooms.
+  module Campfire
+    # Setup the Campfire client with the given credentials.
+    #
+    # 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.
+    #
+    # Returns nothing.
+    def self.setup(account, token, default)
+      ::Broach.settings = {
+        "account" => account,
+        "token"   => token,
+        "use_ssl" => true
+      }
+
+      self.default_room_name = default
+    end
+
+    class << self
+      attr_accessor :default_room_name
+    end
+
+    def self.default_room_id
+      room_id(default_room_name)
+    end
+
+    # Send a message to a Campfire room.
+    #
+    # message - The String message.
+    # room_id - The Integer room ID.
+    #
+    # Returns nothing.
+    def self.speak(message, room_id)
+      adapter.speak(room_name(room_id), message)
+    end
+
+    # Get the ID of a room.
+    #
+    # slug - the String name of the room.
+    #
+    # Returns the room ID or nil for unknown rooms.
+    def self.room_id(name)
+      if room = rooms.detect { |room| room.name == name }
+        room.id
+      end
+    end
+
+    # Get the name of a room given its ID.
+    #
+    # id - the Fixnum room ID.
+    #
+    # Returns the name as a String or nil when not found.
+    def self.room_name(id)
+      if room = rooms.detect { |room| room.id.to_s == id.to_s }
+        room.name
+      end
+    end
+
+    # Get a list of all rooms names.
+    #
+    # Returns an Array of room name as Strings.
+    def self.room_names
+      rooms.map { |room| room.name }.sort
+    end
+
+    # Memoized list of available rooms.
+    #
+    # Returns an Array of Broach::Room objects.
+    def self.rooms
+      @rooms ||= adapter.rooms
+    end
+
+    # Enable mocking. Once enabled, messages are discarded.
+    #
+    # Returns nothing.
+    def self.enable_mock!
+      @adapter = Mock.new
+    end
+
+    # Configure available rooms. Only available in mock mode.
+    #
+    # value - Hash of room map (Fixnum ID => String name)
+    #
+    # Returns nothing.
+    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