process_command 0.1.0

data/README.md

@@ -0,0 +1,39 @@
+# ProcessCommand
+
+Interprocess communication with command for ruby
+
+## Usage
+
+    #in receiver process(pid: 9999)
+    require 'process_command'
+    ProcessCommand.init_receiver
+    ProcessCommand.on(:pause) { p "server paused" }
+    ProcessCommand.on(:resume) { p "server resumed" }
+
+    #in sender process
+    require 'process_command'
+    ProcessCommand.send :pause, 9999
+
+## Mode
+
+* Unix socket (default)
+
+    ProcessCommand.mode = :socket
+
+* Signal
+
+    ProcessCommand.mode = :signal
+
+## Customization
+
+For logger
+
+    ProcessCommand.logger = ProcessCommand::Logger
+
+For mode socket, default path /tmp, you can change it
+    ProcessCommand::Socket::Setting.set_path(path)
+
+For mode signal, default signals are USR1, USR2, HUP, you can change them both in sender and receiver
+
+    ProcessCommand::Signal::Setting.set_bits(bit0_signal, bit1_signal)
+    ProcessCommand::Signal::Setting.set_control(control_signal)

data/lib/process_command/base_receiver.rb

@@ -0,0 +1,40 @@
+module ProcessCommand
+
+  class BaseReceiver
+
+
+    class << self
+
+      def init
+        init_listener
+        Thread.new do
+          init_handler
+        end
+      end
+
+      def add_command_block(command, block)
+        @command_blocks ||= {}
+        @command_blocks[command.to_s] = block
+      end
+
+      def run_command_block(command)
+        command = command.to_s
+        block = @command_blocks[command]
+        if block
+          Thread.new do
+            begin
+              block.call
+            rescue Exception => e
+              ProcessCommand.logger.error "block execute error for command (#{command}), error: #{e.message}"
+            end
+          end
+        else
+          ProcessCommand.logger.error "block not found for command (#{command})"
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/process_command/logger.rb

@@ -0,0 +1,19 @@
+module ProcessCommand
+
+  class Logger
+
+    class << self
+
+      def info(message)
+        p "INFO: #{message}"
+      end
+
+      def error(message)
+        p "ERROR: #{message}"
+      end
+
+    end
+
+  end
+
+end

data/lib/process_command/signal/command.rb

@@ -0,0 +1,20 @@
+module ProcessCommand
+
+  module Signal
+
+    class Command
+
+      def self.i2s(command)
+        command.to_s(16).scan(/.{2}/).map{|c| c.to_i(16).chr}.join
+      end
+
+      def self.s2i(command)
+        command.to_s.each_char.map{|c| c.ord.to_s(16)}.join.to_i(16)
+      end
+
+    end
+
+  end
+
+end
+

data/lib/process_command/signal/receiver.rb

@@ -0,0 +1,55 @@
+module ProcessCommand
+
+  module Signal
+
+    class Receiver < ProcessCommand::BaseReceiver
+
+      class << self
+
+        attr_accessor :command
+        RECEIVER_QUEUE = Queue.new
+
+        def init
+          @command = 0
+          super
+        end
+
+        def init_listener
+          ::Signal.trap(Setting.bit0) do
+            Thread.new{ RECEIVER_QUEUE << 0}
+          end
+          ::Signal.trap(Setting.bit1) do
+            Thread.new{ RECEIVER_QUEUE << 1}
+          end
+          ::Signal.trap(Setting.control) do
+            Thread.new{ RECEIVER_QUEUE << :control}
+          end
+        end
+
+        def init_handler
+          while value = RECEIVER_QUEUE.pop
+            command = Receiver.command
+            case value
+            when 0
+              command <<= 1
+            when 1
+              command <<= 1
+              command |= 1
+            when :control
+              run_command_block Command.i2s(command) if command
+              command = 0
+            else
+              ProcessCommand.logger.error "illegal value #{value}, reset command 0"
+              command = 0
+            end
+            self.command = command
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/process_command/signal/sender.rb

@@ -0,0 +1,37 @@
+module ProcessCommand
+
+  module Signal
+
+    class Sender
+
+      SENDER_LOCK = Mutex.new
+      DEFAULT_DELAY = 0.05
+
+      class << self
+
+        def set_delay(delay)
+          @delay = delay
+        end
+
+        def send(command, pid)
+          @delay ||= DEFAULT_DELAY
+          command = Command.s2i(command).to_s(2)
+          return if command.empty?
+          SENDER_LOCK.synchronize do
+            while bit = command.slice!(0)
+              signal = bit == '0' ? Setting.bit0 : Setting.bit1
+              Process.kill(signal, pid)
+              sleep @delay
+            end
+            Process.kill(Setting.control, pid)
+          end
+        end
+
+
+      end
+
+    end
+
+  end
+
+end

data/lib/process_command/signal/setting.rb

@@ -0,0 +1,41 @@
+module ProcessCommand
+
+  module Signal
+
+    class Setting
+
+      DEFAULT_BIT0 = :USR1
+      DEFAULT_BIT1 = :USR2
+      DEFAULT_CONTROL = :HUP
+
+      class << self
+
+        def set_bits(bit0, bit1)
+          @bit0 = bit0
+          @bit1 = bit1
+        end
+
+        def set_control(control)
+          @control = control
+        end
+
+        def bit0
+          @bit0 ||= DEFAULT_BIT0
+        end
+
+        def bit1
+          @bit1 ||= DEFAULT_BIT1
+        end
+
+        def control
+          @control ||= DEFAULT_CONTROL
+        end
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/process_command/socket/receiver.rb

@@ -0,0 +1,33 @@
+require 'socket'
+module ProcessCommand
+
+  module Socket
+
+    class Receiver < ProcessCommand::BaseReceiver
+
+      class << self
+
+        RECEIVER_QUEUE = Queue.new
+
+        def init_listener
+          path = Setting.socket_path Process.pid
+          File.delete path if File.exists? path
+          @server = UNIXServer.new path
+        end
+
+        def init_handler
+          while client = @server.accept
+            Thread.new do
+              command = client.read
+              run_command_block command
+            end
+          end
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/process_command/socket/sender.rb

@@ -0,0 +1,26 @@
+require 'socket'
+module ProcessCommand
+
+  module Socket
+
+    class Sender
+
+      class << self
+
+        def send(command, pid)
+          command = command.to_s
+          path = Setting.socket_path pid
+          server = UNIXSocket.new path
+          server.write command
+          server.close
+        rescue Exception => e
+          ProcessCommand.logger.error "send error, #{e.message}"
+        end
+
+      end
+
+    end
+
+  end
+
+end

data/lib/process_command/socket/setting.rb

@@ -0,0 +1,31 @@
+module ProcessCommand
+
+  module Socket
+
+    class Setting
+
+      DEFAULT_PATH = "/tmp"
+
+      class << self
+
+        def set_path(path)
+          @path = path
+        end
+
+        def path
+          @path ||= DEFAULT_PATH
+        end
+
+        def socket_path(pid)
+          "#{self.path}/process_command_#{pid}.sock"
+        end
+
+
+      end
+
+    end
+
+  end
+
+end
+

data/lib/process_command.rb

@@ -0,0 +1,57 @@
+require 'process_command/base_receiver'
+require 'process_command/logger'
+require 'process_command/signal/command'
+require 'process_command/signal/setting'
+require 'process_command/signal/receiver'
+require 'process_command/signal/sender'
+require 'process_command/socket/setting'
+require 'process_command/socket/receiver'
+require 'process_command/socket/sender'
+require 'active_support/core_ext/module/attribute_accessors'
+
+module ProcessCommand
+
+  mattr_accessor :mode
+  mattr_accessor :logger
+
+  def self.receiver
+    case self.mode
+    when :signal
+      ProcessCommand::Signal::Receiver
+    when :socket
+      ProcessCommand::Socket::Receiver
+    else
+      nil
+    end
+  end
+
+  def self.sender
+    case self.mode
+    when :signal
+      ProcessCommand::Signal::Sender
+    when :socket
+      ProcessCommand::Socket::Sender
+    else
+      nil
+    end
+  end
+
+  def self.init_receiver
+    self.receiver.init
+  end
+
+  #for receiver
+  def self.on(command, &block)
+    self.receiver.add_command_block command, block
+  end
+
+  #for sender
+  def self.send(command, pid)
+    self.sender.send(command, pid)
+  end
+
+end
+
+ProcessCommand.mode = :socket #:signal
+ProcessCommand.logger = ProcessCommand::Logger
+

metadata

@@ -0,0 +1,61 @@
+--- !ruby/object:Gem::Specification
+name: process_command
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Leon Li
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2012-04-06 00:00:00.000000000Z
+dependencies: []
+description: Interprocess communication with command for ruby
+email: qianthinking@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/process_command/base_receiver.rb
+- lib/process_command/logger.rb
+- lib/process_command/signal/receiver.rb
+- lib/process_command/signal/command.rb
+- lib/process_command/signal/setting.rb
+- lib/process_command/signal/sender.rb
+- lib/process_command/socket/receiver.rb
+- lib/process_command/socket/setting.rb
+- lib/process_command/socket/sender.rb
+- lib/process_command.rb
+- README.md
+homepage: https://github.com/qianthinking/process_command
+licenses: []
+post_install_message: 
+rdoc_options:
+- --line-numbers
+- --inline-source
+- --title
+- RAlgorithms
+- --main
+- README.md
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '1.2'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 2
+summary: Interprocess communication with command for ruby.
+test_files: []