pione 0.1.0

data/lib/pione/util/misc.rb

@@ -0,0 +1,73 @@
+module Pione
+  module Util
+    module Misc
+      # Ignores all exceptions of the block execution.
+      # @yield []
+      #   target block
+      # @return [void]
+      def ignore_exception(&b)
+        begin
+          b.call
+        rescue Exception
+          # do nothing
+        end
+      end
+
+      # Generates random UUID.
+      # @return [String]
+      #   generated UUID string
+      # @note
+      #   we use uuidtools gem for generating UUID
+      def generate_uuid
+        UUIDTools::UUID.random_create.to_s
+      end
+
+      def generate_uuid_int
+        UUIDTools::UUID.random_create.to_i
+      end
+
+      # Returns the hostname of the machine.
+      # @return [String]
+      #   hostname
+      def hostname
+        Socket.gethostname
+      end
+
+      # Returns CPU core number. The number is based on +/proc/cpuinfo+. Platforms
+      # that don't have cpuinfo returns 1.
+      # @return [Integer]
+      #    CPU core nunmber
+      def core_number
+        begin
+          `cat /proc/cpuinfo | grep processor | wc -l`.to_i
+        rescue
+          1
+        end
+      end
+
+      # Parses IP address string. Address string is written with port number.
+      # @return [Array<String, Integer>]
+      def parse_ip_address(s)
+        ":"
+      end
+
+      # Returns my IP address list. The list includes IPv4 addresses only.
+      def my_ip_address_list
+        addrs = Socket.ip_address_list.select do |addr|
+          addr.ipv4? and not(addr.ipv4_loopback?) and not(addr.ipv4_multicast?)
+        end
+        if not(addrs.empty?)
+          privates = addrs.select{|addr| addr.ipv4_private?}
+          not_privates = addrs - privates
+          privates = privates.sort{|a,b| a.ip_address <=> b.ip_address}
+          not_privates = not_privates.sort{|a, b| a.ip_address <=> b.ip_address}
+          (privates + not_privates).map {|addr| addr.ip_address}
+        else
+          Socket.ip_address_list.select{|addr| addr.ipv4_loopback?}.map{|addr| addr.ip_address}
+        end
+      end
+    end
+
+    extend Misc
+  end
+end

data/lib/pione/util/terminal.rb

@@ -0,0 +1,78 @@
+module Pione
+  module Util
+    # Terminal is a set of utility methods for displaying characters in terminal.
+    module Terminal
+      # @api private
+      @@color_mode = true
+
+      # Sets color mode.
+      #
+      # @param [bool] bool
+      #   whether color mode is true
+      # @return [void]
+      def color_mode=(bool)
+        @@color_mode = bool
+      end
+      module_function :color_mode=
+
+      # Returns a colored string.
+      #
+      # @param [Symbol] color
+      #   color name
+      # @param [String] str
+      #   target string
+      # @return [String]
+      def color(color, str)
+        case color
+        when :red
+          red(str)
+        when :green
+          green(str)
+        when :magenta
+          magenta(str)
+        else
+          str
+        end
+      end
+      module_function :color
+
+      # Returns a red colored string.
+      #
+      # @param [String] str
+      #   target string
+      # @return [String]
+      def red(str)
+        colorize(str, "\x1b[31m", "\x1b[39m")
+      end
+      module_function :red
+
+      # Returns a green colored string.
+      #
+      # @param [String] str
+      #   target string
+      # @return [String]
+      def green(str)
+        colorize(str, "\x1b[32m", "\x1b[39m")
+      end
+      module_function :green
+
+      # Returns a magenta colored string.
+      #
+      # @param [String] str
+      #   target string
+      # @return [String]
+      def magenta(str)
+        colorize(str, "\x1b[35m", "\x1b[39m")
+      end
+      module_function :magenta
+
+      private
+
+      # @api private
+      def colorize(str, bc, ec)
+        @@color_mode ? bc + str + ec : str
+      end
+      module_function :colorize
+    end
+  end
+end

data/lib/pione/util/waiter-table.rb

@@ -0,0 +1,53 @@
+module Pione
+  module Util
+    class WaiterTable
+      include DRbUndumped
+
+      def initialize
+        @mutex = Mutex.new
+        @table = {}
+        @waiting_thread = {}
+      end
+
+      def push(req_id, val)
+        @mutex.synchronize {@table[req_id] = val}
+        thread = @mutex.synchronize {@waiting_thread[req_id]}
+        if thread && thread.status == "sleep"
+          thread.run
+        end
+      end
+
+      def take(req_id, msg_id, args)
+        unless @mutex.synchronize {@table.has_key?(req_id)}
+          @mutex.synchronize {@waiting_thread[req_id] = Thread.current}
+          Thread.stop
+          @mutex.synchronize {@waiting_thread.delete(req_id)}
+        end
+        return @mutex.synchronize {@table.delete(req_id)}
+      end
+
+      def to_s
+        @mutex.synchronize do
+          table = convert_string(@table)
+          waiting = convert_string(@waiting)
+          "#<WaiterTable @table=%s @waiting=%s>" % [table, waiting]
+        end
+      end
+
+      def convert_string(obj)
+        case obj
+        when Hash
+          "{%s}" % obj.map do |k,v|
+            "%s=>%s" % [convert_string(k), convert_string(v)]
+          end.join(", ")
+        when Array
+          "[%s]" % obj.map{|elt| convert_string(elt)}.join(", ")
+        when DRbObject
+          "#<DRbObject @drburi=%s, @drbref=%s>" % [obj.__drburi, obj.__drbref]
+        else
+          obj.inspect
+        end
+      end
+    end
+  end
+end

data/lib/pione/version.rb

@@ -0,0 +1,3 @@
+module Pione
+  VERSION = "0.1.0"
+end

data/misc/env.sh

@@ -0,0 +1,2 @@
+export PATH=$PWD/bin:$PATH
+export RUBYLIB=$PWD/lib

data/misc/test-drb-stop-service.rb

@@ -0,0 +1,34 @@
+require 'drb'
+
+class TestService
+  include DRbUndumped
+
+  def test
+    "abc"
+  end
+
+  def pid
+    Process.pid
+  end
+end
+
+uri = "druby://localhost:33333"
+
+pid1 = Process.fork do
+  puts "child: #{Process.pid}"
+  ts = TestService.new
+  DRb.start_service(uri, ts)
+  p ts.pid
+  sleep 10
+  Process.daemon
+  puts "aaaaaaaaaaaaaaaaaaaaa"
+end
+
+sleep 1
+
+ref = DRbObject.new_with_uri(uri)
+puts ref.pid
+
+#DRb.remove_server(server)
+sleep 1
+

data/misc/test-ensure-and-thread-kill.rb

@@ -0,0 +1,40 @@
+
+list = []
+
+def make_thread(list)
+  th = Thread.new do
+    begin
+      while true do
+        sleep 100
+      end
+    ensure
+      sleep 0.01
+      list << th.object_id
+    end
+  end
+end
+
+def kill_threads(threads)
+  threads.list.each do |th|
+    th.kill
+    th.kill
+    th.kill
+  end
+  if threads.list.map{|th| th.alive?}.include?(true)
+    kill_threads(threads)
+  end
+end
+
+threads = ThreadGroup.new
+1..100.times do
+  threads.add make_thread(list)
+end
+kill_threads(threads)
+
+while threads.list.map{|th| th.alive?}.include?(true)
+  sleep 1
+end
+
+sleep 10
+
+puts "size: #{list.size}"

data/misc/test-many-waiters-client.rb

@@ -0,0 +1,56 @@
+require 'drb/drb'
+require 'rinda/rinda'
+
+Thread.abort_on_exception = true
+
+module DRb
+  class DRbConn
+    @table = {}
+    def self.open(remote_uri)  # :nodoc:
+      begin
+        conn = nil
+
+        @mutex.synchronize do
+          cache = @table[remote_uri]
+          if not(cache.nil?) && cache.alive?
+            conn = cache
+          else
+            puts "new"
+            cache.close unless cache.nil?
+            conn = self.new(remote_uri) unless conn
+            @table[remote_uri] = conn
+          end
+        end
+
+        succ, result = yield(conn)
+        return succ, result
+
+      ensure
+        if conn
+          if succ
+            puts "succ"
+          else
+            conn.close
+          end
+        end
+      end
+    end
+  end
+end
+
+DRb.start_service
+
+ts = DRbObject.new_with_uri('druby://localhost:30000')
+$count = 0
+10000.times do
+  Thread.new do
+    $count += 1
+    ts.take([:a])
+  end
+end
+
+loop do
+  break if $count == 10000
+  puts $count
+  sleep 1
+end

data/misc/test-many-waiters-server.rb

@@ -0,0 +1,14 @@
+require 'drb/drb'
+require 'rinda/rinda'
+require 'rinda/tuplespace'
+
+ts = Rinda::TupleSpace.new
+DRb.start_service('druby://localhost:30000', ts)
+Thread.new do
+  loop do
+    p DRb::DRbConn.instance_variable_get(:@pool)
+    sleep 1
+  end
+end
+
+DRb.thread.join

data/misc/write_and_take_test.rb

@@ -0,0 +1,36 @@
+require 'benchmarkx'
+require 'innocent-white/tuple-space-server'
+
+#
+# apt-get install rmagic
+# gem install rmagic
+# gem install benchmarkx
+#
+
+$ts_server = InnocentWhite::TupleSpaceServer.new(task_worker_resource: 4)
+
+def write(n)
+  n.times do |i|
+    $ts_server.write([:test, i])
+  end
+end
+
+def take(n)
+  n.times do |i|
+    $ts_server.take([:test, i])
+  end
+end
+
+def write_and_take(n)
+  write(n)
+  take(n)
+end
+
+include BenchmarkX
+benchmark("       " + CAPTION, 7, FMTSTR) do |x|
+  x.filename = "example/write_and_take_test.png"
+  x.gruff.title = "write and take test"
+  [500, 1000, 1500, 2000, 2500, 3000, 3500, 4000, 4500, 5000].each do |i|
+    x.report("#{i}:")   {write_and_take(i)}
+  end
+end

data/pione.gemspec

@@ -0,0 +1,49 @@
+# -*- ruby -*-
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pione/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pione"
+  gem.version       = Pione::VERSION
+  gem.authors       = ["Keita Yamaguchi"]
+  gem.email         = ["keita.yamaguchi@gmail.com"]
+  gem.description   = %q{PIONE(Process-rule for Input/Output Negotiation Enviromenment) is a rule-based workflow engine.}
+  gem.summary       = %q{rule-based workflow engine}
+  gem.homepage      = "http://pione.github.com/"
+  gem.license       = "MIT"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.required_ruby_version = '>= 1.9.2'
+
+  #
+  # dependencies
+  #
+
+  # requisite for system
+  gem.add_dependency "parslet", "~> 1.4.0"
+  gem.add_dependency "uuidtools", "~> 2.1.3"
+  gem.add_dependency "highline", "~> 1.6.15"
+
+  # for dropbox resource
+  gem.add_dependency "dropbox-sdk"
+
+  # for web client only
+  gem.add_dependency "sinatra"
+  gem.add_dependency "thin"
+
+  # test framework
+  gem.add_development_dependency "bacon", "~> 1.2.0"
+
+  # maintainanse tools
+  gem.add_development_dependency "rake"
+  gem.add_development_dependency "bundler"
+
+  # for documentation
+  gem.add_development_dependency "yard"
+end