simultaneous 0.2.0

data/lib/simultaneous/client.rb

@@ -0,0 +1,111 @@
+# encoding: UTF-8
+
+require 'eventmachine'
+
+module Simultaneous
+  class Client
+
+
+    attr_reader :domain
+
+    def initialize(domain, connection_string, &block)
+      @connection = Simultaneous::Connection.new(connection_string)
+      @domain = domain
+      @callbacks = []
+      @socket = nil
+      connect
+    end
+
+    def handler
+      handler = Class.new(EventMachine::Connection) do
+        include EventMachine::Protocols::LineText2
+
+        def client=(client); @client = client end
+        def client; @client end
+
+        def connection_completed
+          # $stdout.puts "Client connection completed\\n"
+        end
+
+        def receive_line(line)
+          client.receive(line)
+        end
+
+        # def unbind
+        #   $stdout.puts "Client Connection closed\\n"
+        #   client.reconnect!
+        # end
+      end
+      handler
+    end
+
+    def reconnect!
+      @socket = nil
+      connect
+    end
+
+    def close
+      @socket.close_connection_after_writing if @socket
+    end
+
+    def run(command)
+      command.domain = self.domain
+      send(command.dump)
+    end
+
+    def send(message)
+      connection do |c|
+        c.send_data(message)
+      end
+    end
+
+    def connection(&callback)
+      callback.call(@socket) if @socket
+    end
+
+    def connect
+      event_machine do
+        # EventMachine.connect(*Simultaneous.parse_connection(@connection_string), handler) do |conn|
+        @connection.async_socket(handler) do |conn|
+          conn.client = self
+          @socket = conn
+        end
+      end
+    end
+
+    def receive(data)
+      if data == ""
+        notify! if @message
+      else
+        @message ||= Simultaneous::BroadcastMessage.new
+        @message << data
+      end
+    end
+
+    def notify!
+      if @message.valid? and @message.domain == @domain
+        subscribers[@message.event].each do |subscriber|
+          subscriber.call(@message)
+        end
+      end
+      @message = nil
+    end
+
+    def subscribers
+      @subscribers ||= Hash.new { |hash, key| hash[key] = [] }
+    end
+
+    def on_event(event, &block)
+      subscribers[event.to_s] << block
+    end
+
+    def event_machine(&block)
+      if EM.reactor_running?
+        block.call
+      else
+        Thread.new { EM.run }
+        EM.next_tick { block.call }
+      end
+    end
+  end
+end

data/lib/simultaneous/command/client_event.rb

@@ -0,0 +1,24 @@
+# encoding: UTF-8
+
+module Simultaneous
+  module Command
+    class ClientEvent < CommandBase
+
+      def initialize(domain, event, data)
+        @domain, @event, @data = domain, event, data
+      end
+
+      def run
+        message = Simultaneous::BroadcastMessage.new({
+          :domain => @domain,
+          :event => @event,
+          :data => @data
+        })
+        Simultaneous::Server.broadcast(message.to_event)
+      end
+      def debug
+        "ClientEvent: #{@domain}:#{@event} #{@data.inspect}\n"
+      end
+    end
+  end
+end

data/lib/simultaneous/command/fire.rb

@@ -0,0 +1,155 @@
+# encoding: UTF-8
+
+require 'fileutils'
+
+module Simultaneous
+  module Command
+    class Fire < CommandBase
+      attr_reader :task_uid, :task_gid
+
+      def initialize(task, params={})
+        super
+        @task_uid = Process.euid
+        @task_gid = Process.egid
+      end
+
+      def niceness
+        @task.niceness
+      end
+
+      def binary
+        @task.binary
+      end
+
+      def binary_file
+        @task.binary.split(" ").first
+      end
+
+      def cmd
+        %(#{binary} #{Simultaneous.to_arguments(@params)})
+      end
+
+      def valid?
+        exists? && permitted?
+      end
+
+      def permitted?
+        raise PermissionsError, "'#{binary_file}' does not belong to user '#{ENV["USER"]}'" unless File.stat(binary_file).uid == task_uid
+        true
+      end
+
+      def exists?
+        raise FileNotFoundError, "'#{binary_file}'" unless File.exists?(binary_file)
+        true
+      end
+
+      def env
+        @task.env.merge({
+          Simultaneous::ENV_CONNECTION => Simultaneous.connection,
+          Simultaneous::ENV_TASK_NAME => task_name,
+          Simultaneous::ENV_DOMAIN => domain
+        })
+      end
+
+      def run
+        if valid?
+          pid = fork do
+            ## set up the environment so that the task can access the F&F server
+            env.each { | k, v | ENV[k] = v }
+            ## TODO: figure out how to pass a logfile path to this
+            daemonize(cmd, @task.logfile)
+            Process.setpriority(Process::PRIO_PROCESS, 0, niceness) if niceness > 0
+            ## change to the UID of the originating thread if necessary
+            Process::UID.change_privilege(task_uid) unless Process.euid == task_uid
+            File.umask(0022)
+            Dir.chdir(@task.pwd)
+            exec(cmd)
+          end
+          Process.detach(pid) if pid
+          # don't return the PID as it's actually wrong (the daemonize call forks again so our original
+          # PID is at least 1 out)
+          "OK"
+        end
+      end
+
+      def debug
+        "Fire :#{namespaced_task_name}: #{cmd}\n"
+      end
+
+      private
+
+      # The following adapted from Daemons.daemonize
+      def daemonize(app_name = nil, logfile_name = nil)
+        srand # Split rand streams between spawning and daemonized process
+          safefork and exit # Fork and exit from the parent
+
+        # Detach from the controlling terminal
+        unless sess_id = Process.setsid
+          raise RuntimeException.new('cannot detach from controlling terminal')
+        end
+
+        # Prevent the possibility of acquiring a controlling terminal
+        trap 'SIGHUP', 'IGNORE'
+        exit if pid = safefork
+
+        $0 = app_name if app_name
+
+        Dir.chdir "/"   # Release old working directory
+        File.umask 0000 # Ensure sensible umask
+
+        # Make sure all file descriptors are closed
+        ObjectSpace.each_object(IO) do |io|
+          unless [STDIN, STDOUT, STDERR].include?(io)
+            begin
+              unless io.closed?
+                io.close
+              end
+            rescue ::Exception
+            end
+          end
+        end
+
+        redirect_io(logfile_name)
+
+        return sess_id
+      end
+
+      def redirect_io(logfile_name)
+        begin; STDIN.reopen "/dev/null"; rescue ::Exception; end
+
+        if logfile_name
+          FileUtils.mkdir_p(File.dirname(logfile_name))
+          begin
+            STDOUT.reopen logfile_name, "a"
+            File.chmod(0644, logfile_name)
+            STDOUT.sync = true
+          rescue ::Exception
+            begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+          end
+        else
+          begin; STDOUT.reopen "/dev/null"; rescue ::Exception; end
+        end
+
+        begin; STDERR.reopen STDOUT; rescue ::Exception; end
+        STDERR.sync = true
+      end
+
+      def safefork
+        tryagain = true
+
+        while tryagain
+          tryagain = false
+          begin
+            if pid = fork
+              return pid
+            end
+          rescue Errno::EWOULDBLOCK
+            sleep 5
+            tryagain = true
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/simultaneous/command/kill.rb

@@ -0,0 +1,19 @@
+# encoding: UTF-8
+
+module Simultaneous
+  module Command
+    class Kill < CommandBase
+
+      def initialize(task_name, signal="TERM")
+        @task_name, @signal = task_name.to_sym, signal
+      end
+
+      def run
+        Simultaneous::Server.kill(namespaced_task_name, @signal)
+      end
+      def debug
+        "Kill :#{namespaced_task_name}: #{@signal}\n"
+      end
+    end
+  end
+end

data/lib/simultaneous/command/set_pid.rb

@@ -0,0 +1,22 @@
+# encoding: UTF-8
+
+module Simultaneous
+  module Command
+    class SetPid < CommandBase
+
+      attr_reader :task_name, :pid
+
+      def initialize(task_name, pid)
+        @task_name, @pid = task_name.to_sym, pid.to_i
+      end
+
+      def run
+        Simultaneous::Server.pids[namespaced_task_name] = @pid
+      end
+
+      def debug
+        "SetPid :#{namespaced_task_name}: #{@pid}\n"
+      end
+    end
+  end
+end

data/lib/simultaneous/command/task_complete.rb

@@ -0,0 +1,18 @@
+# encoding: UTF-8
+
+module Simultaneous
+  module Command
+    class TaskComplete < CommandBase
+      def initialize(task_name)
+        @task_name = task_name
+      end
+
+      def run
+        Simultaneous::Server.task_complete(namespaced_task_name)
+      end
+      def debug
+        "TaskComplete :#{namespaced_task_name}\n"
+      end
+    end
+  end
+end

data/lib/simultaneous/command.rb

@@ -0,0 +1,75 @@
+# encoding: UTF-8
+
+module Simultaneous
+  module Command
+    SEPARATOR = "||".freeze
+
+    def self.load(command)
+      Marshal.load(command)
+    end
+
+    def self.allowed?(cmd)
+      allowed_commands.include?(cmd.class)
+    end
+
+    def self.allowed_commands
+      @allowed_commands ||= self.constants.map { |c| self.const_get(c) }.select do |k|
+        k.respond_to?(:ancestors) && k.ancestors.include?(CommandBase)
+      end
+    end
+
+    class CommandBase
+      attr_reader :tag, :cmd, :params, :task
+
+      def initialize(task, params={})
+        @task, @params = task, merge_params(task.params, params)
+        @task_name = task.name
+      end
+
+      def dump
+        Marshal.dump(self)
+      end
+
+      def run
+        # overridden in subclasses
+      end
+
+      def domain=(domain)
+        @domain = domain
+      end
+
+      def domain
+        @domain ||= ""
+      end
+
+      def task_name
+        @task_name.to_s
+      end
+
+      def namespaced_task_name
+        "#{domain}/#{task_name}"
+      end
+
+      def merge_params(task_params, call_params)
+        params = task_params.to_a.inject({}) do |hash, (key, value)|
+          hash[key.to_s] = value; hash
+        end
+        call_params.each do |key, value|
+          params[key.to_s] = value
+        end if call_params
+        params
+      end
+
+      def debug()
+        "#{self.class.name.split("::").last} :#{@task_name}\n"
+      end
+    end
+
+
+    autoload :Fire,         "simultaneous/command/fire"
+    autoload :Kill,         "simultaneous/command/kill"
+    autoload :SetPid,       "simultaneous/command/set_pid"
+    autoload :ClientEvent,  "simultaneous/command/client_event"
+    autoload :TaskComplete, "simultaneous/command/task_complete"
+  end
+end

data/lib/simultaneous/connection.rb

@@ -0,0 +1,81 @@
+# encoding: UTF-8
+
+module Simultaneous
+  class Connection
+    TCP_CONNECTION_MATCH = %r{^([^/]+):(\d+)}
+
+    def self.tcp(host, port)
+      "#{host}:#{port}"
+    end
+
+    attr_reader :options
+
+    def initialize(connection_string, options = {})
+      @options = options
+      @tcp = false
+      if connection_string =~ TCP_CONNECTION_MATCH
+        @tcp = true
+        @host, @port = $1, $2.to_i
+      else
+        @socket = connection_string
+      end
+    end
+
+    def tcp?
+      @tcp
+    end
+
+    def unix?
+      !@tcp
+    end
+
+    def start_server(handler, &block)
+      if tcp?
+        EventMachine::start_server(@host, @port, handler, &block)
+      else
+        EventMachine::start_server(@socket, handler, &block)
+        set_socket_permissions(@socket)
+        EM.add_shutdown_hook {
+          FileUtils.rm(@socket) if @socket and File.exist?(@socket)
+        }
+      end
+    end
+
+    def async_socket(handler, &block)
+      if tcp?
+        EventMachine.connect(@host, @port, handler, &block)
+      else
+        EventMachine.connect(@socket, handler, &block)
+      end
+    end
+
+    def sync_socket
+      socket = open_sync_socket
+      if block_given?
+        begin
+          yield(socket)
+          socket.flush
+          socket.close_write
+        ensure
+          socket.close if socket rescue nil
+        end
+      end
+      socket
+    end
+
+    def open_sync_socket
+      if tcp?
+        TCPSocket.new(@host, @port)
+      else
+        UNIXSocket.new(@socket)
+      end
+    end
+
+    def set_socket_permissions(socket)
+      if File.exist?(socket)
+        File.chmod(0770, socket)
+        File.chown(nil, options[:gid], socket) if options[:gid]
+      end
+    end
+  end
+end