janky 0.9.0

data/lib/janky/github/mock.rb

@@ -0,0 +1,47 @@
+module Janky
+  module GitHub
+    class Mock
+      Response = Struct.new(:code, :body)
+
+      def initialize(user, password)
+        @repos = {}
+      end
+
+      def make_private(nwo)
+        @repos[nwo] = :private
+      end
+
+      def make_public(nwo)
+        @repos[nwo] = :public
+      end
+
+      def make_unauthorized(nwo)
+        @repos[nwo] = :unauthorized
+      end
+
+      def create(nwo, secret, url)
+        data = {"url" => "https://api.github.com/hooks/#{Time.now.to_f}"}
+        Response.new("201", Yajl.dump(data))
+      end
+
+      def get(url)
+        Response.new("200")
+      end
+
+      def repo_get(nwo)
+        repo = {
+          "name"    => nwo.split("/").last,
+          "private" => (@repos[nwo] == :private),
+          "git_url" => "git://github.com/#{nwo}",
+          "ssh_url" => "git@github.com:#{nwo}"
+        }
+
+        if @repos[nwo] == :unauthorized
+          Response.new("404", Yajl.dump({}))
+        else
+          Response.new("200", Yajl.dump(repo))
+        end
+      end
+    end
+  end
+end

data/lib/janky/github/payload.rb

@@ -0,0 +1,34 @@
+module Janky
+  module GitHub
+    class Payload
+      def self.parse(json)
+        parsed = PayloadParser.new(json)
+        new(parsed.uri, parsed.branch, parsed.head, parsed.commits, parsed.compare)
+      end
+
+      def initialize(uri, branch, head, commits, compare)
+        @uri     = uri
+        @branch  = branch
+        @head    = head
+        @commits = commits
+        @compare = compare
+      end
+
+      attr_reader :uri, :branch, :head, :commits, :compare
+
+      def head_commit
+        @commits.detect do |commit|
+          commit.sha1 == @head
+        end
+      end
+
+      def to_json
+        { :after   => @head,
+          :ref     => "refs/heads/#{@branch}",
+          :uri     => @uri,
+          :commits => @commits,
+          :compare => @compare }.to_json
+      end
+    end
+  end
+end

data/lib/janky/github/payload_parser.rb

@@ -0,0 +1,57 @@
+module Janky
+  module GitHub
+    class PayloadParser
+      def initialize(json)
+        @payload = Yajl.load(json)
+      end
+
+      def head
+        @payload["after"]
+      end
+
+      def compare
+        @payload["compare"]
+      end
+
+      def commits
+        @payload["commits"].map do |commit|
+          GitHub::Commit.new(
+            commit["id"],
+            commit["url"],
+            commit["message"],
+            normalize_author(commit["author"]),
+            commit["timestamp"]
+          )
+        end
+      end
+
+      def normalize_author(author)
+        if email = author["email"]
+          "#{author["name"]} <#{email}>"
+        else
+          author
+        end
+      end
+
+      def uri
+        if uri = @payload["uri"]
+          return uri
+        end
+
+        repository = @payload["repository"]
+
+        if repository["private"]
+          "git@github.com:#{URI(repository["url"]).path[1..-1]}"
+        else
+          uri = URI(repository["url"])
+          uri.scheme = "git"
+          uri.to_s
+        end
+      end
+
+      def branch
+        @payload["ref"].split("refs/heads/").last
+      end
+    end
+  end
+end

data/lib/janky/github/receiver.rb

@@ -0,0 +1,69 @@
+module Janky
+  module GitHub
+    # Rack app handling GitHub Post-Receive [1] requests.
+    #
+    # The JSON payload is parsed into a GitHub::Payload. We then find the
+    # associated Repository record based on the Payload's repository git URL
+    # and create the associated records: Branch, Commit and Build.
+    #
+    # Finally, we trigger a new Jenkins build.
+    #
+    # [1]: http://help.github.com/post-receive-hooks/
+    class Receiver
+      def initialize(secret)
+        @secret = secret
+      end
+
+      def call(env)
+        dup.call!(env)
+      end
+
+      def call!(env)
+        @request = Rack::Request.new(env)
+
+        if !valid_signature?
+          return Rack::Response.new("Invalid signature", 403).finish
+        end
+
+        if !payload.head_commit
+          return Rack::Response.new("Ignored", 400).finish
+        end
+
+        result = BuildRequest.handle(
+          payload.uri,
+          payload.branch,
+          payload.head_commit,
+          payload.compare,
+          @request.POST["room"]
+        )
+
+        Rack::Response.new("OK: #{result}", 201).finish
+      end
+
+      def valid_signature?
+        digest    = OpenSSL::Digest::Digest.new("sha1")
+        signature = @request.env["HTTP_X_HUB_SIGNATURE"].split("=").last
+
+        signature == OpenSSL::HMAC.hexdigest(digest, @secret, data)
+      end
+
+      def payload
+        @payload ||= GitHub::Payload.parse(data)
+      end
+
+      def data
+        @data ||= data!
+      end
+
+      def data!
+        if @request.content_type != "application/json"
+          return Rack::Response.new("Invalid Content-Type", 400).finish
+        end
+
+        body = ""
+        @request.body.each { |chunk| body << chunk }
+        body
+      end
+    end
+  end
+end

data/lib/janky/helpers.rb

@@ -0,0 +1,17 @@
+module Janky
+  module Helpers
+    def self.registered(app)
+      app.enable :raise_errors
+      app.disable :show_exceptions
+      app.helpers self
+    end
+
+    def find_repo(name)
+      unless repo = Repository.find_by_name(name)
+        halt(404, "Unknown repository: #{name.inspect}")
+      end
+
+      repo
+    end
+  end
+end

data/lib/janky/hubot.rb

@@ -0,0 +1,117 @@
+module Janky
+  # Web API taylored for Hubot's needs. Supports setting up and disabling
+  # repositories, querying the status of branch or a repository and triggering
+  # builds.
+  #
+  # The client side implementation is at
+  # <https://github.com/github/hubot/blob/master/scripts/ci.js>
+  class Hubot < Sinatra::Base
+    register Helpers
+
+    # Setup a new repository.
+    post "/setup" do
+      nwo  = params["nwo"]
+      name = params["name"]
+      repo = Repository.setup(nwo, name)
+
+      if repo
+        url  = "#{settings.base_url}/#{repo.name}"
+        [201, "Setup #{repo.name} at #{repo.uri} | #{url}"]
+      else
+        [400, "Couldn't access #{nwo}. Check the permissions."]
+      end
+    end
+
+    # Activate/deactivate auto-build for the given repository.
+    post "/toggle/:repo_name" do |repo_name|
+      repo   = find_repo(repo_name)
+      status = repo.toggle_auto_build ? "enabled" : "disabled"
+
+      [200, "#{repo.name} is now #{status}"]
+    end
+
+    # Build a repository's branch.
+    post "/:repo_name/:branch" do |repo_name, branch_name|
+      repo    = find_repo(repo_name)
+      branch  = repo.branch_for(branch_name)
+      build   = branch.current_build
+      room_id = params["room_id"] && Integer(params["room_id"])
+
+      if build
+        build.rerun(room_id)
+
+        [201, "Going ham on #{build.repo_name}/#{build.branch_name}"]
+      else
+        [404, "Unknown branch #{branch_name.inspect}. Push again"]
+      end
+    end
+
+    # Get a list of available rooms.
+    get "/rooms" do
+      Yajl.dump(Campfire.room_names)
+    end
+
+    # Update a repository's notification room.
+    put "/:repo_name" do |repo_name|
+      repo = find_repo(repo_name)
+      room = params["room"]
+
+      if room_id = Campfire.room_id(room)
+        repo.update_attributes!(:room_id => room_id)
+        [200, "Room for #{repo.name} updated to #{room}"]
+      else
+        [403, "Unknown room: #{room.inspect}"]
+      end
+    end
+
+    # Get the status of all projects.
+    get "/" do
+      content_type "text/plain"
+      repos = Repository.all.map do |repo|
+        master = repo.branch_for("master")
+
+        "%-17s %-13s %-10s %40s" % [
+          repo.name,
+          master.status,
+          repo.campfire_room,
+          repo.uri
+        ]
+      end
+      repos.join("\n")
+    end
+
+    # Get the status of a repository's branch.
+    get "/:repo_name/:branch_name" do |repo_name, branch_name|
+      limit = params["limit"]
+
+      repo   = find_repo(repo_name)
+      branch = repo.branch_for(branch_name)
+      builds = branch.completed_builds.limit(limit).map do |build|
+        { :sha1     => build.sha1,
+          :repo     => build.repo_name,
+          :branch   => build.branch_name,
+          :green    => build.green?,
+          :building => branch.building?,
+          :number   => build.number,
+          :status   => (build.green? ? "was successful" : "failed"),
+          :compare  => build.compare,
+          :duration => build.duration }
+      end
+
+      builds.to_json
+    end
+
+    # Learn everything you need to know about Janky.
+    get "/help" do
+      content_type "text/plain"
+<<-EOS
+hubot ci build janky
+hubot ci build janky/fix-everything
+hubot ci setup github/janky [name]
+hubot ci toggle janky
+hubot ci rooms
+hubot ci set room janky The Danger Room
+EOS
+    end
+  end
+end

data/lib/janky/job_creator.rb

@@ -0,0 +1,111 @@
+module Janky
+  class JobCreator
+    def initialize(server_url, callback_url)
+      @server_url   = server_url
+      @callback_url = callback_url
+    end
+
+    def run(name, uri, template_path)
+      creator.run(name, uri, template_path)
+    end
+
+    def creator
+      @creator ||= Creator.new(HTTP, @server_url, @callback_url)
+    end
+
+    def enable_mock!
+      @creator = Creator.new(Mock.new, @server_url, @callback_url)
+    end
+
+    class Creator
+      def initialize(adapter, server_url, callback_url)
+        @adapter      = adapter
+        @server_url   = server_url
+        @callback_url = callback_url
+      end
+
+      def run(name, uri, template_path)
+        template = Tilt.new(template_path.to_s)
+        config   = template.render(Object.new, {
+          :name         => name,
+          :repo         => uri,
+          :callback_url => @callback_url
+        })
+
+        exception_context(config, name, uri)
+
+        if !@adapter.exists?(@server_url, name)
+          @adapter.run(@server_url, name, config)
+          true
+        end
+      end
+
+      def exception_context(config, name, uri)
+        Exception.push(
+          :server_url   => @server_url.inspect,
+          :callback_url => @callback_url.inspect,
+          :adapter      => @adapter.inspect,
+          :config       => config.inspect,
+          :name         => name.inspect,
+          :repo         => uri.inspect
+        )
+      end
+    end
+
+    class Mock
+      def run(server_url, name, config)
+        name   || raise(Error, "no name")
+        config || raise(Error, "no config")
+        (URI === server_url) || raise(Error, "server_url is not a URI")
+
+        true
+      end
+
+      def exists?(server_url, name)
+        false
+      end
+    end
+
+    class HTTP
+      def self.exists?(server_url, name)
+        uri  = server_url
+        user = uri.user
+        pass = uri.password
+        http = Net::HTTP.new(uri.host, uri.port)
+
+        get = Net::HTTP::Get.new("/job/#{name}/")
+        get.basic_auth(user, pass) if user && pass
+        response = http.request(get)
+
+        case response.code
+        when "200"
+          true
+        when "404"
+          false
+        else
+          Exception.push_http_response(response)
+          raise "Failed to determine job existance"
+        end
+      end
+
+      def self.run(server_url, name, config)
+        uri  = server_url
+        user = uri.user
+        pass = uri.password
+        http = Net::HTTP.new(uri.host, uri.port)
+
+        post = Net::HTTP::Post.new("/createItem?name=#{name}")
+        post.basic_auth(user, pass) if user && pass
+        post["Content-Type"] = "application/xml"
+        post.body = config
+
+        response = http.request(post)
+
+        unless response.code == "200"
+          Exception.push_http_response(response)
+          raise Error, "Failed to create job"
+        end
+      end
+    end
+  end
+end