cukeq 0.0.1.dev

data/lib/cukeq/scm.rb

@@ -0,0 +1,51 @@
+module CukeQ
+  class Scm
+    attr_reader :url
+
+    autoload :GitBridge, "cukeq/scm/git_bridge"
+    autoload :SvnBridge, "cukeq/scm/svn_bridge"
+
+    ROOT = File.expand_path("~/.cukeq")
+
+    def initialize(url)
+      @url = url.kind_of?(String) ? URI.parse(url) : url
+    end
+
+    def working_copy
+      @working_copy ||= "#{ROOT}/repos/#{url.host}/#{url.path.gsub(/[^A-z]+/, '_')}"
+    end
+
+    def current_revision
+      bridge.current_revision
+    end
+
+    def update(&blk)
+      log self.class, :updating, url.to_s => working_copy
+      bridge.update(&blk)
+      log self.class, :done
+    end
+
+    def bridge
+      @bridge ||= (
+        case url.scheme
+        when "git"
+          GitBridge.new url, working_copy
+        when "svn"
+          SvnBridge.new url, working_copy
+        when "http", "https"
+         # TODO: fix heuristic for http scm urls
+          if url.to_s.include?("svn")
+            SvnBridge.new url, working_copy
+          elsif url.to_s.include?("git")
+            GitBridge.new url, working_copy
+          else
+            raise "unknown scm: #{url}"
+          end
+        else
+          raise "unknown scm: #{url}"
+        end
+      )
+    end
+
+  end # Scm
+end # CukeQ

data/lib/cukeq/scm/git_bridge.rb

@@ -0,0 +1,36 @@
+require "git"
+
+module CukeQ
+  class Scm
+    class GitBridge
+
+      def initialize(url, working_copy)
+        @url          = url
+        @working_copy = working_copy
+      end
+
+      def update(&blk)
+        repo.reset_hard
+        repo.pull
+
+        # TODO: async
+        yield
+      end
+
+      def current_revision
+        repo.revparse("HEAD")
+      end
+
+      def repo
+        @repo ||= (
+          unless File.directory? @working_copy
+            Git.clone(@url, @working_copy)
+          end
+
+          Git.open(@working_copy)
+        )
+      end
+
+    end # GitBridge
+  end # Scm
+end # CukeQ

data/lib/cukeq/scm/shell_svn_bridge.rb

@@ -0,0 +1,65 @@
+require "open3"
+require "nokogiri"
+
+module CukeQ
+  class Scm
+    class ShellSvnBridge
+
+      def initialize(url, working_copy)
+        @url          = url
+        @working_copy = working_copy
+      end
+
+      def update(&blk)
+        ensure_working_copy
+        Dir.chdir(@working_copy) { execute "svn update --non-interactive" }
+
+        # TODO: async
+        yield
+      end
+
+      def current_revision
+        ensure_working_copy
+        info[:revision]
+      end
+
+      private
+
+      def info
+        data = {}
+
+        xml = Dir.chdir(@working_copy) { execute "svn --xml info" }
+        doc = Nokogiri::XML(xml)
+
+        data[:revision] = doc.css("info entry commit").first['revision'].to_i
+        data[:url] = doc.css("url").text
+
+        data
+      end
+
+      def ensure_working_copy
+        return if File.directory? @working_copy
+
+        log self.class, :checkout, @url.to_s => @working_copy
+        execute "svn checkout #{@url} #{@working_copy}"
+      end
+
+      def execute(cmd)
+        out, err = nil
+
+        Open3.popen3(cmd) do |stdin, stdout, stderr|
+          out = stdout.read
+          err = stderr.read
+        end
+
+        unless $?.success?
+          raise SystemCallError, "#{cmd.inspect}, stdout: #{out.inspect}, stderr: #{err.inspect}"
+        end
+
+        out
+      end
+    end # ShellSvnBridge
+
+    SvnBridge = ShellSvnBridge
+  end # Scm
+end # CukeQ

data/lib/cukeq/scm/svn_bridge.rb

@@ -0,0 +1,77 @@
+require "svn/client" # apt-get install libsvn-ruby
+
+module CukeQ
+  class Scm
+    class SvnBridge
+
+      def initialize(url, working_copy)
+        @url          = url
+        @working_copy = working_copy
+
+        @simple_auth = Hash.new do |hash, realm|
+          hash[realm] = simple_auth_for(realm) || raise_auth_error
+        end
+
+        setup_auth
+      end
+
+      def update(&blk)
+        ensure_working_copy
+        ctx.update(@working_copy).to_s
+
+        # TODO: async
+        yield
+      end
+
+      def current_revision
+        ensure_working_copy
+
+        Dir.chdir(@working_copy) do
+          ctx.status(@working_copy, "BASE").to_s
+        end
+      end
+
+      private
+
+      def ctx
+        @ctx ||= Svn::Client::Context.new
+      end
+
+      def setup_auth
+        ctx.add_simple_prompt_provider(0) do |cred, realm, username, save|
+          cred.username = ENV['CUKEQ_SVN_USERNAME'] || @url.user || @simple_auth[realm]["username"]
+          cred.password = ENV['CUKEQ_SVN_PASSWORD'] || @url.password || @simple_auth[realm]["password"]
+          cred
+        end
+
+        if ENV['CUKEQ_SVN_INSECURE_SSL']
+          ctx.add_ssl_server_trust_prompt_provider do |cred, host, failures, info, was|
+            cred.accepted_failures = failures
+            cred
+          end
+        end
+      end
+
+      def simple_auth_for(realm)
+        Svn::Core::Config.read_auth_data(Svn::Core::AUTH_CRED_SIMPLE, realm)
+      end
+
+      def raise_auth_error
+        raise <<-END
+         No SVN credentials provided. Either of these will do:
+            * set CUKEQ_SVN_USERNAME and CUKEQ_SVN_PASSWORD
+            * add username and password to the repo URL: https://foo:bar@svn.example.com/
+            * make sure your credentials are saved to disk (~/.subversion/auth)
+         END
+      end
+
+      def ensure_working_copy
+        return if File.directory? @working_copy
+
+        log self.class, :checkout, @url.to_s => @working_copy
+        ctx.checkout(@url.to_s, @working_copy)
+      end
+
+    end # SvnBridge
+  end # Scm
+end # CukeQ

data/lib/cukeq/slave.rb

@@ -0,0 +1,114 @@
+# encoding: utf-8
+
+module CukeQ
+  class Slave
+    DEFAULT_BROKER_URI = URI.parse("amqp://cukeq-slave:cukeq123@localhost:5672/cukeq")
+
+    class << self
+      def execute(argv = [])
+        configured_instance(argv).start
+      end
+
+      def configured_instance(argv = [])
+        opts = parse(argv)
+
+        if b = opts[:broker]
+          b.user     ||= DEFAULT_BROKER_URI.user
+          b.password ||= DEFAULT_BROKER_URI.password
+          b.host     ||= DEFAULT_BROKER_URI.host
+          b.port     ||= DEFAULT_BROKER_URI.port
+          b.path     = b.path.empty? ? DEFAULT_BROKER_URI.path : b.path
+        else
+          opts[:broker] = DEFAULT_BROKER_URI
+        end
+
+        new(
+          Broker.new(opts[:broker]),
+          ScenarioRunner.new
+        )
+      end
+
+      def parse(argv)
+        options = {}
+
+        argv.extend(OptionParser::Arguable)
+        argv.options do |opts|
+          opts.on("-b", "--broker URI (default: #{DEFAULT_BROKER_URI})") do |b|
+            options[:broker] = URI.parse(b)
+          end
+        end.parse!
+
+        options
+      end
+    end # class << self
+
+    attr_reader :broker, :scenario_runner
+
+    def initialize(broker, scenario_runner)
+      @broker          = broker
+      @scenario_runner = scenario_runner
+    end
+
+    def start
+      @broker.start {
+        ping_pong
+        poll
+      }
+    end
+
+    #
+    # Publish a message on the results queue
+    #
+
+    def publish(message)
+      log log_name, :publish, message
+
+      @broker.publish :results, message.to_json
+    end
+
+    #
+    # Run a job
+    #
+
+    def job(message)
+      log log_name, :job, message
+
+      @scenario_runner.run(message) { |result|
+        publish(result)
+        EM.next_tick { poll } # job done, start polling again
+      }
+    end
+
+    POLL_INTERVAL = 0.25
+
+    #
+    # Poll for new jobs
+    #
+
+    def poll
+      @broker.queue_for(:jobs).pop { |input|
+        if input
+          job JSON.parse(input)
+        else
+          EM.add_timer(POLL_INTERVAL) { poll }
+        end
+      }
+    end
+
+    #
+    # Subscribe to :ping, respond to :pong
+    #
+
+    def ping_pong
+      @broker.subscribe(:ping) { |message|
+        log log_name, :ping
+        @broker.publish :pong, {:id => CukeQ.identifier, :class => self.class.name}.to_json
+      }
+    end
+
+    def log_name
+      @log_name ||= [self.class, Process.pid]
+    end
+
+  end # Slave
+end # CukeQ

data/lib/cukeq/webapp.rb

@@ -0,0 +1,38 @@
+module CukeQ
+  class WebApp
+    attr_reader :uri
+
+    def initialize(uri)
+      @uri = uri
+    end
+
+    def run(callback)
+      @callback = callback
+      handler.run(self, :Host => @uri.host, :Port => @uri.port)
+    end
+
+    def call(env)
+      log self.class, :called
+
+      request = Rack::Request.new(env)
+
+      unless request.post?
+        return [405, {'Allow' => 'POST'}, []]
+      end
+
+      begin
+        data = JSON.parse(request.body.read)
+        @callback.call(data) if @callback
+      rescue JSON::ParserError
+        return [406, {'Content-Type' => 'application/json'}, []]
+      end
+
+      [202, {}, %w[ok]]
+    end
+
+    def handler
+      Rack::Handler::Thin
+    end
+
+  end # App
+end # CukeQ

data/spec/cukeq/broker_spec.rb

@@ -0,0 +1,78 @@
+require File.expand_path("../../spec_helper", __FILE__)
+
+describe CukeQ::Broker do
+  def queues
+    @queues ||= {
+      :results => mock("results-queue"),
+      :jobs    => mock("jobs-queue")
+    }
+  end
+
+  def running_broker
+    broker = CukeQ::Broker.new(URI.parse("amqp://cukeq-master@localhost:1234/cukeq"))
+    broker.instance_variable_set("@queues", queues)
+
+    broker
+  end
+
+  it "accepts a String URI" do
+    broker = CukeQ::Broker.new("amqp://cukeq-master@localhost:1234/cukeq")
+    broker.user.should == "cukeq-master"
+    broker.host.should == "localhost"
+  end
+
+  describe "#start" do
+    it "starts AMQP with the given broker config" do
+      broker = CukeQ::Broker.new(URI.parse("amqp://cukeq-master@localhost:1234/cukeq"))
+
+      expected_params = {
+        :host => 'localhost',
+        :port => 1234,
+        :vhost => "/cukeq",
+        :user => 'cukeq-master'
+      }
+
+      AMQP.should_receive(:start).with(hash_including(expected_params)).and_yield
+
+      mock_q = mock("queue")
+      MQ.should_receive(:new).exactly(4).times.and_return(mock_q)
+      mock_q.should_receive(:queue).exactly(4).times
+
+      broker.start
+    end
+  end
+
+  it "should publish messages on the given queue" do
+    broker = running_broker
+    message = "some message"
+
+    queues.each do |name, queue|
+      queue.should_receive(:publish).with(message)
+      broker.publish(name, message)
+    end
+  end
+
+  it "should subscribe/unsubscribe from the given queue" do
+    EM.stub(:add_periodic_timer)
+    broker = running_broker
+
+    # TODO: this looks pretty stupid, could we just expose the queues directly?
+    queues[:results].should_receive(:subscribe)
+    broker.subscribe(:results) {}
+  end
+
+  describe "#queue_for" do
+    it "should return the right queue" do
+      broker = running_broker
+      broker.queue_for(:results).should == queues[:results]
+      broker.queue_for(:jobs).should == queues[:jobs]
+    end
+
+    it "raises an error if the queue is not found" do
+      broker = running_broker
+      lambda { broker.queue_for(:foo) }.should raise_error
+    end
+  end
+
+
+end