drbqs 0.0.0

data/README.rdoc

@@ -0,0 +1,19 @@
+= drbqs
+
+Description goes here.
+
+== Contributing to drbqs
+ 
+* Check out the latest master to make sure the feature hasn't been implemented or the bug hasn't been fixed yet
+* Check out the issue tracker to make sure someone already hasn't requested it and/or contributed it
+* Fork the project
+* Start a feature/bugfix branch
+* Commit and push until you are happy with your contribution
+* Make sure to add tests for it. This is important so I don't break it in a future version unintentionally.
+* Please try not to mess with the Rakefile, version, or history. If you want to have your own version, or is otherwise necessary, that is fine, but please isolate to its own commit so I can cherry-pick around it.
+
+== Copyright
+
+Copyright (c) 2011 Takayuki YAMAGUCHI. See LICENSE.txt for
+further details.
+

data/Rakefile

@@ -0,0 +1,43 @@
+require 'rubygems'
+require 'bundler'
+begin
+  Bundler.setup(:default, :development)
+rescue Bundler::BundlerError => e
+  $stderr.puts e.message
+  $stderr.puts "Run `bundle install` to install missing gems"
+  exit e.status_code
+end
+require 'rake'
+
+require 'jeweler'
+Jeweler::Tasks.new do |gem|
+  # gem is a Gem::Specification... see http://docs.rubygems.org/read/chapter/20 for more options
+  gem.name = "drbqs"
+  gem.homepage = "http://github.com/ytaka/drbqs"
+  gem.license = "GPL3"
+  gem.summary = "dRuby Queueing System"
+  gem.description = "Queuing system over network that is implemented by dRuby."
+  gem.email = "d@ytak.info"
+  gem.authors = ["Takayuki YAMAGUCHI"]
+  # Include your dependencies below. Runtime dependencies are required when using your gem,
+  # and development dependencies are only needed for development (ie running rake tasks, tests, etc)
+  #  gem.add_runtime_dependency 'jabber4r', '> 0.1'
+  #  gem.add_development_dependency 'rspec', '> 1.2.3'
+end
+Jeweler::RubygemsDotOrgTasks.new
+
+require 'rspec/core'
+require 'rspec/core/rake_task'
+RSpec::Core::RakeTask.new(:spec) do |spec|
+  spec.pattern = FileList['spec/**/*_spec.rb']
+end
+
+RSpec::Core::RakeTask.new(:rcov) do |spec|
+  spec.pattern = 'spec/**/*_spec.rb'
+  spec.rcov = true
+end
+
+task :default => :spec
+
+require 'yard'
+YARD::Rake::YardocTask.new

data/VERSION

@@ -0,0 +1 @@
+0.0.0

data/lib/drbqs.rb

@@ -0,0 +1,12 @@
+require 'thread'
+require 'logger'
+require 'fileutils'
+require 'drb'
+require 'drb/acl'
+require 'rinda/tuplespace'
+require 'rinda/rinda'
+
+module DRbQS
+  autoload :Server, 'drbqs/server'
+  autoload :Client, 'drbqs/client'
+end

data/lib/drbqs/client.rb

@@ -0,0 +1,44 @@
+require 'drbqs/connection'
+require 'drbqs/task_client'
+
+module DRbQS
+
+  class Client
+    def initialize(access_uri, opts = {})
+      @access_uri = access_uri
+      @logger = Logger.new(opts[:log_file] || 'drbqs_client.log')
+      @logger.level = opts[:log_level] || Logger::ERROR
+      @connection = nil
+      @task_client = nil
+    end
+
+    def connect
+      obj = DRbObject.new_with_uri(@access_uri)
+      @connection = ConnectionClient.new(obj[:message], @logger)
+      node_id = @connection.get_id
+      @task_client = TaskClient.new(node_id, obj[:queue], obj[:result], @logger)
+    end
+
+    def calculate
+      cn = Thread.new do
+        loop do
+          @task_client.add_new_task
+          @connection.respond_alive_signal
+          @task_client.send_result
+          sleep(1)
+        end
+      end
+      exec = Thread.new do
+        loop do
+          marshal_obj, method_sym, args = @task_client.get
+          obj = Marshal.load(marshal_obj)
+          result = obj.__send__(method_sym, *args)
+          @task_client.transmit(result)
+        end
+      end
+      exec.join
+      cn.join
+    end
+  end
+
+end

data/lib/drbqs/connection.rb

@@ -0,0 +1,35 @@
+module DRbQS
+  # The class of connection to s.erver.
+  class ConnectionClient
+    def initialize(message, logger = nil)
+      @message = message
+      @logger = logger
+      @id = nil
+    end
+
+    def create_id_string
+      t = Time.now
+      sprintf("%d%d%d", t.to_i, t.usec, rand(1000))
+    end
+    private :create_id_string
+
+    def get_id
+      s = create_id_string
+      @message.write([:connect, s])
+      @id = @message.take([s, Fixnum])[1]
+    end
+
+    def respond_alive_signal
+      begin
+        node_id, sym = @message.take([@id, Symbol], 0)
+        case sym
+        when :alive_p
+          @message.write([:alive, @id])
+        when :exit
+          Kernel.exit
+        end
+      rescue
+      end
+    end
+  end
+end

data/lib/drbqs/message.rb

@@ -0,0 +1,92 @@
+module DRbQS
+  class NodeList
+    def initialize
+      @id = 0
+      @list = {}
+      @check = []
+    end
+
+    def get_new_id(id_str)
+      @id += 1
+      @list[@id] = id_str
+      @id
+    end
+
+    def each(&block)
+      @list.each(&block)
+    end
+
+    def set_check_connection
+      @check = @list.keys
+    end
+
+    def delete_not_alive
+      @check.each do |id|
+        @list.delete(id)
+      end
+      deleted = @check
+      @check = []
+      deleted
+    end
+
+    def set_alive(id)
+      @check.delete(id)
+    end
+
+    def empty?
+      @list.size == 0
+    end
+  end
+
+  class MessageServer
+    def initialize(message, logger = nil)
+      @message = message
+      @node_list = NodeList.new
+      @logger = logger
+    end
+
+    def get_message
+      begin
+        mes = @message.take([Symbol, nil], 0)
+        manage_message(*mes)
+      rescue Rinda::RequestExpiredError
+      end
+    end
+
+    def manage_message(mes, arg)
+      @logger.debug("Get message") { [mes, arg] } if @logger
+      case mes
+      when :connect
+        a = [arg, @node_list.get_new_id(arg)]
+        @logger.debug("New node") { a } if @logger
+        @message.write(a)
+      when :alive
+        @node_list.set_alive(arg)
+      else
+        puts "Invalid message from #{arg.to_s}"
+      end
+    end
+    private :manage_message
+
+    def check_connection
+      deleted = @node_list.delete_not_alive
+      @logger.info("IDs of deleted nodes") { deleted } if @logger
+      @node_list.each do |id, str|
+        @message.write([id, :alive_p])
+      end
+      @node_list.set_check_connection
+      deleted
+    end
+
+    def send_exit
+      @node_list.each do |node_id, id_str|
+        @message.write([node_id, :exit])
+      end
+    end
+
+    def node_not_exist?
+      @node_list.empty?
+    end
+  end
+
+end

data/lib/drbqs/queue.rb

@@ -0,0 +1,96 @@
+module DRbQS
+  class Task
+    attr_reader :hook
+
+    def initialize(obj, method_sym, args = [], &hook)
+      begin
+        @marshal_obj = Marshal.dump(obj)
+      rescue
+        raise "Can not dump an instance of #{obj.class}."
+      end
+      @method_sym = method_sym
+      @args = args
+      @hook = hook
+    end
+
+    def drb_args(task_id)
+      [task_id, @marshal_obj, @method_sym, @args]
+    end
+  end
+
+  class QueueServer
+
+    def initialize(queue, result, logger = nil)
+      @queue = queue
+      @result = result
+      @task_id = 0
+      @cache = {}
+      @calculating = {}
+      @logger = logger
+    end
+
+    def queue_task(task_id)
+      @queue.write(@cache[task_id].drb_args(task_id))
+    end
+    private :queue_task
+
+    # &hook take two arguments: a QueueServer object and a result of task.
+    def add(task)
+      @task_id += 1
+      @logger.info("New task: #{@task_id}") if @logger
+      @cache[@task_id] = task
+      queue_task(@task_id)
+    end
+
+    def get_accept_signal
+      begin
+        sym, task_id, node_id = @result.take([:accept, Fixnum, Fixnum], 0)
+        @calculating[node_id] = task_id
+        @logger.info("Accept: task #{task_id} by node #{node_id}.") if @logger
+      rescue
+      end
+    end
+
+    def requeue_for_deleted_node_id(deleted)
+      deleted.each do |node_id|
+        if task_id = @calculating[node_id]
+          queue_task(task_id)
+          @calculating.delete(task_id)
+        end
+      end
+    end
+
+    def get_result
+      begin
+        loop do
+          sym, task_id, result = @result.take([:result, Fixnum, nil], 0)
+          @logger.info("Get: result of #{task_id}.") if @logger
+          @calculating.delete(task_id)
+          task = @cache.delete(task_id)
+          if hook = task.hook
+            hook.call(self, result)
+          end
+        end
+      rescue
+      end
+    end
+
+    # If queue is empty, return true. Otherwise, false.
+    # Even if there are calculating tasks,
+    # the method can return true.
+    def empty?
+      @cache.size - @calculating.size == 0
+    end
+
+    # If there are no tasks in queue and calculating,
+    # return true. Otherwise, false.
+    def finished?
+      @cache.size == 0
+    end
+
+    def calculating_task_number
+      @calculating.size
+    end
+  end
+
+end

data/lib/drbqs/server.rb

@@ -0,0 +1,106 @@
+require 'drbqs/message'
+require 'drbqs/queue'
+
+module DRbQS
+  class CheckAlive
+    def initialize(interval)
+      @interval = interval || 300
+      @last = Time.now
+    end
+
+    def significant_interval?
+      (Time.now - @last) >= @interval
+    end
+
+    def set_checking
+      @last = Time.now
+    end
+  end
+
+  ROOT_DEFAULT_PORT = 13500
+
+  class Server
+    attr_reader :queue
+
+    def initialize(opts = {})
+      @port = opts[:port] || ROOT_DEFAULT_PORT
+      @acl = opts[:acl]
+      @ts = {
+        :message => Rinda::TupleSpace.new,
+        :queue => Rinda::TupleSpace.new,
+        :result => Rinda::TupleSpace.new
+      }
+      @logger = Logger.new(opts[:log_file] || 'drbqs_server.log')
+      @logger.level = opts[:log_level] || Logger::ERROR
+      @message = MessageServer.new(@ts[:message], @logger)
+      @queue= QueueServer.new(@ts[:queue], @ts[:result], @logger)
+      @check_alive = CheckAlive.new(opts[:check_alive])
+      @empty_queue_hook = nil
+    end
+
+    def start
+      DRb.install_acl(@acl) if @acl
+      uri = "druby://:#{@port}"
+      DRb.start_service(uri, @ts)
+      @logger.info("Start DRb service") { uri } if @logger
+    end
+
+    def check_connection(force = nil)
+      if force || @check_alive.significant_interval?
+        @logger.info("Check connection") if @logger
+        @message.check_connection
+        @check_alive.set_checking
+      end
+    end
+    private :check_connection
+
+    def set_empty_queue_hook(&block)
+      if block_given?
+        @empty_queue_hook = block
+      else
+        @empty_queue_hook = nil
+      end
+    end
+
+    def set_finish_hook(&block)
+      if block_given?
+        @finish_hook = block
+      else
+        @finish_hook = nil
+      end
+    end
+
+    def exec_hook
+      if @empty_queue_hook && @queue.empty?
+        @logger.info("Execute empty queue hook.") if @logger
+        @empty_queue_hook.call(self)
+      end
+      if @finish_hook && @queue.finished?
+        @logger.info("Execute finish hook.") if @logger
+        @finish_hook.call(self)
+      end
+    end
+    private :exec_hook
+
+    WAIT_NODE_EXIT = 3
+
+    def exit
+      @message.send_exit
+      until @message.node_not_exist?
+        sleep(WAIT_NODE_EXIT)
+        check_connection(true)
+      end
+      Kernel.exit
+    end
+
+    def wait
+      loop do
+        @message.get_message
+        check_connection
+        @queue.get_result
+        exec_hook
+        sleep(1)
+      end
+    end
+  end
+end