simultaneous 0.2.0

data/simultaneous.gemspec

@@ -0,0 +1,96 @@
+## This is the rakegem gemspec template. Make sure you read and understand
+## all of the comments. Some sections require modification, and others can
+## be deleted if you don't need them. Once you understand the contents of
+## this file, feel free to delete any comments that begin with two hash marks.
+## You can find comprehensive Gem::Specification documentation, at
+## http://docs.rubygems.org/read/chapter/20
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+  s.rubygems_version = '1.3.5'
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = 'simultaneous'
+  s.version           = '0.2.0'
+  s.date              = '2011-11-03'
+  s.rubyforge_project = 'simultaneous'
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = "Simultaneous is the background task launcher used by Spontaneous CMS"
+  s.description = "Simultaneous is designed for the very specific use case of a small set of users collaborating on editing a single website. Because of that it is optimised for infrequent invocation of very long running publishing tasks and provides an event based messaging system that allows launched tasks to communicate back to the CMS web-server and for that server to then fire off update messages through HTML5 Server-Sent Events."
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["Garry Hill"]
+  s.email    = 'garry@magnetised.info'
+  s.homepage = 'http://spontaneouscms.org'
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  ## If your gem includes any executables, list them here.
+  s.executables = ["simultaneous-server", "simultaneous-console"]
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README LICENSE]
+
+  ## List your runtime dependencies here. Runtime dependencies are those
+  ## that are needed for an end user to actually USE your code.
+  s.add_dependency('eventmachine', [">= 1.0.0.beta.4", "< 2.0"])
+  s.add_dependency('rack', [">= 1.0", "< 2.0"])
+  s.add_dependency('rack-async', [">= 0.0.1", "< 2.0"])
+
+  ## List your development dependencies here. Development dependencies are
+  ## those that are only needed during development
+  s.add_development_dependency('rr', ["~> 1.0.4"])
+
+  ## Leave this section as-is. It will be automatically generated from the
+  ## contents of your Git repository via the gemspec task. DO NOT REMOVE
+  ## THE MANIFEST COMMENTS, they are used as delimiters by the task.
+  # = MANIFEST =
+  s.files = %w[
+    Gemfile
+    LICENSE
+    README
+    Rakefile
+    bin/simultaneous-console
+    bin/simultaneous-server
+    lib/simultaneous.rb
+    lib/simultaneous/broadcast_message.rb
+    lib/simultaneous/client.rb
+    lib/simultaneous/command.rb
+    lib/simultaneous/command/client_event.rb
+    lib/simultaneous/command/fire.rb
+    lib/simultaneous/command/kill.rb
+    lib/simultaneous/command/set_pid.rb
+    lib/simultaneous/command/task_complete.rb
+    lib/simultaneous/connection.rb
+    lib/simultaneous/rack.rb
+    lib/simultaneous/server.rb
+    lib/simultaneous/task.rb
+    lib/simultaneous/task_client.rb
+    lib/simultaneous/task_description.rb
+    simultaneous.gemspec
+    test/helper.rb
+    test/tasks/example.rb
+    test/test_client.rb
+    test/test_command.rb
+    test/test_connection.rb
+    test/test_faf.rb
+    test/test_message.rb
+    test/test_server.rb
+    test/test_task.rb
+  ]
+  # = MANIFEST =
+
+  ## Test files will be grabbed from the file list. Make sure the path glob
+  ## matches what you actually use.
+  s.test_files = s.files.select { |path| path =~ /^test\/test_.*\.rb/ }
+end

data/test/helper.rb

@@ -0,0 +1,14 @@
+require 'minitest/spec'
+require 'minitest/autorun'
+require 'rr'
+require 'simultaneous'
+require 'fileutils'
+
+
+$debug = false
+
+SOCKET = "/tmp/#{$$}-faf.socket"
+
+class MiniTest::Spec
+  include RR::Adapters::MiniTest
+end

data/test/tasks/example.rb

@@ -0,0 +1,22 @@
+#!/usr/bin/env ruby
+
+require 'rubygems'
+
+$:.unshift(File.expand_path("../../../lib", __FILE__))
+
+require 'simultaneous'
+
+class MyTask
+  include Simultaneous::Task
+
+  def run
+    puts ARGV[0]
+    # 10.times do |i|
+    #   puts i
+    #   sleep(1)
+    # end
+    simultaneous_event("example", "done")
+  end
+end
+
+MyTask.new.run

data/test/test_client.rb

@@ -0,0 +1,24 @@
+require File.expand_path('../helper', __FILE__)
+
+describe Simultaneous::Client do
+  it "should send right command to server" do
+    EM.run {
+      task = Simultaneous.add_task(:publish, "/publish", {:param1 => "value1", :param2 => "value2"}, 12)
+      command = Object.new
+      mock(command).domain=("faf.org")
+      mock(command).dump { "dumpedcommand" }
+      mock(Simultaneous::Command::Fire).new(task, {:param2 => "value3"}) { command }
+
+      Simultaneous.domain = "faf.org"
+      Simultaneous.connection = SOCKET
+      Simultaneous::Server.start
+
+      mock(Simultaneous::Server).receive_data("dumpedcommand") { EM.stop }
+
+      Thread.new {
+        pid = Simultaneous.publish({:param2 => "value3"})
+      }.join
+    }
+  end
+
+end

data/test/test_command.rb

@@ -0,0 +1,72 @@
+require File.expand_path('../helper', __FILE__)
+
+describe Simultaneous::Command do
+  before do
+    Simultaneous.domain = "example.net"
+    @task = Simultaneous::TaskDescription.new(:publish, "/publish", 9, {:param1 => "value1", :param2 => "value2"})
+  end
+  it "should serialize and deserialize correctly" do
+    task = Simultaneous::TaskDescription.new(:publish, "/publish", 9, {:param1 => "value1", :param2 => "value2"})
+    cmd = Simultaneous::Command::CommandBase.new(task, {"param2" => "newvalue2", :param3 => "value3"})
+    cmd2 = Simultaneous::Command.load(cmd.dump)
+    task2 = cmd2.task
+    task2.binary.must_equal task.binary
+    task2.params.must_equal task.params
+    task2.name.must_equal task.name
+    cmd.params.must_equal({"param1" => "value1", "param2" => "newvalue2", "param3" => "value3"})
+  end
+
+  it "should only run scripts belonging to the same user as the ruby process" do
+    stub(File).exist?("/publish") { true }
+    stub(File).exists?("/publish") { true }
+    stat = Object.new
+    stub(stat).uid { Process.uid + 1 }
+    stub(File).stat("/publish") { stat }
+    cmd = Simultaneous::Command::Fire.new(@task)
+    lambda { cmd.run }.must_raise(Simultaneous::PermissionsError)
+  end
+
+  it "should not raise an error if the binary belongs to this process" do
+    stat = Object.new
+    stub(stat).uid { Process.uid }
+    stub(File).stat("/publish") { stat }
+    cmd = Simultaneous::Command::Fire.new(@task)
+    cmd.permitted?
+  end
+
+  it "should raise an error if the binary belongs to this process" do
+    stat = Object.new
+    uid = Process.uid
+    stub(stat).uid { uid }
+    stub(File).stat("/publish") { stat }
+    stub(Process).euid { uid + 1 }
+    cmd = Simultaneous::Command::Fire.new(@task)
+    lambda { cmd.permitted? }.must_raise(Simultaneous::PermissionsError)
+  end
+
+  it "should give error if binary doesn't exist" do
+    stub(File).exist?("/publish") { false }
+    stub(File).exists?("/publish") { false }
+    stub(File).owned?("/publish") { true }
+    cmd = Simultaneous::Command::Fire.new(@task)
+    lambda { cmd.run }.must_raise(Simultaneous::FileNotFoundError)
+  end
+
+  it "should raise error if command isn't one of the approved list" do
+    cmd = Object.new
+    mock(cmd).run.times(0)
+    lambda { Simultaneous::Server.run(cmd) }.must_raise(Simultaneous::PermissionsError)
+  end
+
+  it "should work with binaries involving a command" do
+    task = Simultaneous::TaskDescription.new(:publish, "/publish all")
+    stat = Object.new
+    stub(stat).uid { Process.uid }
+    stub(File).stat("/publish") { stat }
+    stub(File).exist?("/publish") { true }
+    stub(File).exists?("/publish") { true }
+    cmd = Simultaneous::Command::Fire.new(task)
+    cmd.valid?
+  end
+
+end

data/test/test_connection.rb

@@ -0,0 +1,91 @@
+require File.expand_path('../helper', __FILE__)
+
+describe Simultaneous::Connection do
+
+  after do
+    # FileUtils.rm( "/tmp/socket.sock") if File.exist?( "/tmp/socket.sock")
+  end
+
+  it "should allow me to generate a connection string from host & port values" do
+    Simultaneous::Connection.tcp("localhost", 999).must_equal "localhost:999"
+  end
+  it "should be correct recognise TCP connections" do
+    %w(127.0.0.1:9999 localhost:1234 123.239.23.1:9999 host.domain.com:9999).each do |c|
+      Simultaneous::Connection.new(c).tcp?.must_be :==, true
+      Simultaneous::Connection.new(c).unix?.must_be :==, false
+    end
+  end
+
+  it "should be correct recognise UNIX connections" do
+    %w(/path/to/socket.sock socket file.sock).each do |c|
+      Simultaneous::Connection.new(c).tcp?.must_be :==, false
+      Simultaneous::Connection.new(c).unix?.must_be :==, true
+    end
+  end
+
+  it "should open an EventMachine TCP server connection" do
+    conn = Simultaneous::Connection.new("127.0.0.1:9999")
+    handler = Object.new
+    mock(EventMachine).start_server("127.0.0.1", 9999, handler)
+    conn.start_server(handler)
+  end
+  it "should open an EventMachine TCP client connection" do
+    conn = Simultaneous::Connection.new("127.0.0.1:9999")
+    handler = Object.new
+    mock(EventMachine).connect("127.0.0.1", 9999, handler)
+    conn.async_socket(handler)
+  end
+
+  it "should open an synchronous TCP client connection" do
+    conn = Simultaneous::Connection.new("127.0.0.1:9999")
+    socket = Object.new
+    mock(socket).write("string")
+    mock(socket).flush
+    mock(socket).close_write
+    mock(socket).close
+    mock(TCPSocket).new("127.0.0.1", 9999) { socket }
+    conn.sync_socket do |s|
+      s.write("string")
+    end
+  end
+
+  it "should open an EventMachine Unix server connection" do
+    conn = Simultaneous::Connection.new("/tmp/socket.sock")
+    handler = Object.new
+    mock(EventMachine).start_server("/tmp/socket.sock", handler)
+    conn.start_server(handler)
+  end
+  it "should open an EventMachine Unix client connection" do
+    conn = Simultaneous::Connection.new("/tmp/socket.sock")
+    handler = Object.new
+    mock(EventMachine).connect("/tmp/socket.sock", handler)
+    conn.async_socket(handler)
+  end
+
+  it "should open an synchronous Unix client connection" do
+    conn = Simultaneous::Connection.new("/tmp/socket.sock")
+    socket = Object.new
+    mock(socket).write("string")
+    mock(socket).flush
+    mock(socket).close_write
+    mock(socket).close
+    mock(UNIXSocket).new("/tmp/socket.sock") { socket }
+    conn.sync_socket do |s|
+      s.write("string")
+    end
+  end
+
+  it "should set the correct permissions on the EventMachine server socket" do
+    socket = "/tmp/socket.sock"
+    gid = "789"
+    FileUtils.rm(socket) if File.exist?(socket)
+    mock(File).chmod(0770, socket)
+    mock(File).chown(nil, gid, socket)
+    handler = Module.new
+    mock(EventMachine).start_server(socket, handler) { FileUtils.touch(socket) }
+    conn = Simultaneous::Connection.new(socket, {:gid => gid})
+    conn.start_server(handler)
+    FileUtils.rm(socket) if File.exist?(socket)
+  end
+
+end

data/test/test_faf.rb

@@ -0,0 +1,43 @@
+require File.expand_path('../helper', __FILE__)
+
+describe Simultaneous do
+  it "should translate a hash to command line arguments" do
+    Simultaneous.to_arguments({
+      :param1 => "value1",
+      :param2 => "value2",
+      :array => [1, 2, "3 of 4"],
+      :hash  => {:name => "Fred", :age => 23}
+    }).must_equal %(--array=1 2 "3 of 4" --hash=name:"Fred" age:23 --param1="value1" --param2="value2")
+  end
+  it "should enable mapping of task to a binary" do
+    Simultaneous.add_task(:publish, "/path/to/binary")
+    Simultaneous.binary(:publish).must_equal  "/path/to/binary"
+    Simultaneous[:publish].binary.must_equal  "/path/to/binary"
+  end
+
+  it "should enable setting of a niceness value for the task" do
+    Simultaneous.add_task(:publish1, "/path/to/binary", {:niceness => 10})
+    Simultaneous[:publish1].niceness.must_equal  10
+    Simultaneous.add_task(:publish2, "/path/to/binary", {:nice => 12})
+    Simultaneous[:publish2].niceness.must_equal  12
+  end
+
+
+  it "should enable launching a task by its name" do
+    Simultaneous.add_task(:publish, "/path/to/binary")
+    args = {:param1 => "param1", :param2 => "param2"}
+    mock(Simultaneous).fire(:publish, args)
+    Simultaneous.publish(args)
+  end
+
+  it "should enable setting of path to socket" do
+    Simultaneous.connection = "/tmp/something"
+    Simultaneous.connection.must_equal  "/tmp/something"
+  end
+
+  it "should enable setting of domain" do
+    Simultaneous.domain = "domain_name"
+    Simultaneous.domain.must_equal  "domain_name"
+  end
+
+end

data/test/test_message.rb

@@ -0,0 +1,81 @@
+require File.expand_path('../helper', __FILE__)
+
+describe Simultaneous::BroadcastMessage do
+
+  describe "when parsing input" do
+    before do
+      @message = Simultaneous::BroadcastMessage.new
+    end
+    it "should begin as invalid" do
+      @message.valid?.wont_be :==, true
+    end
+
+    it "should recognise the domain: header" do
+      @message << "domain: name"
+      @message.domain.must_equal "name"
+      @message.valid?.wont_be :==, true
+    end
+
+    it "should recognise the event: header" do
+      @message << "event: name"
+      @message.event.must_equal "name"
+      @message.valid?.wont_be :==, true
+    end
+
+    it "should recognise the data: header" do
+      @message << "data: a"
+      @message.data.must_equal "a"
+      @message << "data: b"
+      @message.data.must_equal "a\nb"
+      @message << "data: c"
+      @message.data.must_equal "a\nb\nc"
+      @message.valid?.wont_be :==, true
+    end
+
+    it "should ignore comments" do
+      @message << ": a"
+      @message.data.must_equal ""
+    end
+
+    it "should ignore blank lines" do
+      @message << ""
+      @message.data.must_equal ""
+    end
+  end
+
+  describe "when data has been parsed" do
+    before do
+      @message = Simultaneous::BroadcastMessage.new
+      @message.event = "event"
+      @message.domain = "domain"
+      @message.data = "line 1\nline 2"
+    end
+
+    it "should be valid" do
+      @message.valid?.must_equal true
+    end
+
+    it "should serialise to a SSE-friendly format" do
+      @message.to_event.must_equal((<<-SRC).gsub(/^ */, ''))
+        domain: domain
+        event: event
+        data: line 1
+        data: line 2
+
+      SRC
+    end
+  end
+
+  describe "when initialising" do
+    it "should accept values at initialisation" do
+      message = Simultaneous::BroadcastMessage.new({
+        :domain => "domain",
+        :event => "event",
+        :data => "line 1\nline 2"
+      })
+      message.domain.must_equal "domain"
+      message.event.must_equal "event"
+      message.data.must_equal "line 1\nline 2"
+    end
+  end
+end