rbgo 0.3.2 → 0.3.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: a366b8a6e6ab4c87ba41bd939f9d7f27668901accc91b2c8391e1408e25a6cac
-  data.tar.gz: b44e73f8e6a5d45bcf5840d5c4de9294af6bea333ec88cc30da9a218b5991232
+  metadata.gz: 17553429e36bb85945fd70a9f0a5e1e77e0987d2c202d32f1c2c5e6cba2690b5
+  data.tar.gz: 11b5fa246822d7e8612046cd68465f13d838d7b86ea60bce80e4a89d6d6f7d28
 SHA512:
-  metadata.gz: 227992f58aa87e3ee24160589bb5dfc9a51e6dd333295532be497492c12261549242eb87637fb7245140608014ef123937c100d8b4b2da6c3bc8238c23304e14
-  data.tar.gz: f05339257fee9a92046468e77095281a6106daedeb75b337fd5246001b63cf6f526415e7aa277f1c6564517e8ec68e88aabf24fe557146578ce2abf1729ef824
+  metadata.gz: 13cd9e6735154aca3a0c539044fca29edf3fe84a97969b9c2dc05e55eed3976e019bf5f7ccd6c3d6408ee7ea388d4cc4d0789cc73516ae35a142a7d93643b900
+  data.tar.gz: 42222f0c07f7e2932c1815b0b75b0eb043553793f454238d12857819b67116bff6083078eb4fd3d9a17ea0c5d2301df4b3a472ec0c4c5a3de06169695db261c7

data/.gitignore

@@ -7,4 +7,6 @@ tmp/*
 .rbx
 Gemfile.lock
 .bash_history
+*.key
+*.pem
 

data/README.md

@@ -9,7 +9,7 @@ but not statically typed in my implementation.
 example:
 
 ```ruby
-relative 'rbgo'
+require 'rbgo'
 
 include Rbgo::Channel
 
@@ -123,7 +123,20 @@ go do
     # ...
     Fiber.yield 
   end
+end      
+
+# yield_io create a new thread to do operations, current routine will yield to do other task,
+# it will come back to go on execute when yield_io block finish.  
+
+require 'open-uri'
+go do
+  res = yield_io do
+    f = open("http://www.google.com")
+    f.read
+  end
+  p res
 end
+               
 
 # Or use go!        
 
@@ -322,6 +335,15 @@ go do
                               # this operation will *NOT* block the current thread
                               # when io operation complete, thread will resume to execute from this point.
   p data
+end                   
+              
+require 'open-uri'
+go do
+  res = yield_io do
+    f = open("http://www.google.com")
+    f.read
+  end
+  p res
 end
 
 sleep 2

data/lib/rbgo.rb

@@ -5,6 +5,7 @@ require_relative 'rbgo/reentrant_mutex'
 require_relative 'rbgo/reentrant_rw_mutex'
 require_relative 'rbgo/semaphore'
 require_relative 'rbgo/synchronized_collection'
+require_relative 'rbgo/observer'
 require_relative 'rbgo/once'
 require_relative 'rbgo/actor'
 require_relative 'rbgo/task_list'

data/lib/rbgo/actor.rb

@@ -180,7 +180,7 @@ module Rbgo
               break
             else
               call_handler(msg)
-            end
+            end                            
             Fiber.yield
           end
         end

data/lib/rbgo/corun.rb

@@ -2,13 +2,15 @@ require 'thread'
 require 'fiber'
 require 'system'
 require 'singleton'
+require 'openssl'
 require_relative 'io_machine'
+require_relative 'io_receipt'
 require_relative 'once'
 
 module Rbgo
   module CoRun
     IS_CORUN_FIBER     = :is_corun_fiber_bbc0f70e
-    LOCAL_TASK_QUEUES = :local_task_queues_bbc0f70e
+    LOCAL_TASK_QUEUES  = :local_task_queues_bbc0f70e
     YIELD_IO_OPERATION = :yield_bbc0f70e
 
     def self.is_in_corun_fiber?
@@ -17,7 +19,24 @@ module Rbgo
 
     def self.have_other_task_on_thread?
       queues = Thread.current.thread_variable_get(LOCAL_TASK_QUEUES)
-      queues&.any?{|q| !q.empty?}
+      queues&.any? { |q| !q.empty? }
+    end
+
+    def self.yield_io(&blk)
+      if is_in_corun_fiber?
+        receipt = IOReceipt.new([:yield_io])
+        CoRun::Routine.new(new_thread: true, queue_tag: :none) do
+          begin
+            res = blk&.call
+            receipt.res = res
+          ensure
+            receipt.notify
+          end
+        end
+        Fiber.yield [YIELD_IO_OPERATION, receipt]
+      else
+        blk&.call
+      end
     end
 
     def self.read_from(io, length: nil)
@@ -124,10 +143,15 @@ module Rbgo
       end
 
       def perform
-        self.fiber = Fiber.new do |*args|
-          Thread.current[IS_CORUN_FIBER] = true
-          blk.call(*args)
-        end if fiber.nil?
+        if fiber.nil?
+          self.fiber = Fiber.new do |*args|
+            Thread.current[IS_CORUN_FIBER] = true
+            blk.call(*args)
+          end
+          fiber.define_singleton_method(:transfer) do
+            raise 'can not call transfer on CoRun fiber'
+          end
+        end
 
         if fiber.alive?
           if io_receipt.nil?
@@ -203,8 +227,8 @@ module Rbgo
               yield_task_queue      = Queue.new
               pending_io_task_queue = Queue.new
               local_task_queue      = Queue.new
-              Thread.current.thread_variable_set(LOCAL_TASK_QUEUES,[yield_task_queue, pending_io_task_queue, local_task_queue])
-              task_queue            = get_queue(queue_tag)
+              Thread.current.thread_variable_set(LOCAL_TASK_QUEUES, [yield_task_queue, pending_io_task_queue, local_task_queue])
+              task_queue = get_queue(queue_tag)
               local_task_queue << init_task if init_task
               loop do
                 task = nil
@@ -292,7 +316,7 @@ module Rbgo
               end
             end
           ensure
-            Rbgo.logger&.debug('Rbgo') { 'supervisor thread exit' }
+            Rbgo.logger&.warn('Rbgo') { 'supervisor thread exit' }
           end
         end
         nil
@@ -306,7 +330,7 @@ module Rbgo
               sleep check_interval
             end
           ensure
-            Rbgo.logger&.debug('Rbgo') { 'check generator thread exit' }
+            Rbgo.logger&.warn('Rbgo') { 'check generator thread exit' }
           end
         end
         nil
@@ -377,6 +401,10 @@ module Rbgo
       def have_other_task_on_thread?
         CoRun.have_other_task_on_thread?
       end
+
+      def yield_io(&blk)
+        CoRun.yield_io(&blk)
+      end
     end
 
     refine IO do
@@ -418,5 +446,31 @@ module Rbgo
         CoRun.sendmsg_to(self, mesg, flags: flags, dest_sockaddr: dest_sockaddr, controls: controls)
       end
     end
+
+    refine OpenSSL::SSL::SSLSocket do
+      def yield_accept
+        CoRun.accept_from(self)
+      end
+
+      def yield_connect(remote_sockaddr)
+        CoRun.connect_to(self, remote_sockaddr: remote_sockaddr)
+      end
+
+      def yield_read(len = nil)
+        CoRun.read_from(self, length: len)
+      end
+
+      def yield_read_line(sep = $/, limit = nil)
+        CoRun.read_line_from(self, sep: sep, limit: limit)
+      end
+
+      def yield_read_partial(maxlen)
+        CoRun.read_partial_from(self, maxlen: maxlen)
+      end
+
+      def yield_write(str)
+        CoRun.write_to(self, str: str)
+      end
+    end
   end
 end

data/lib/rbgo/io_machine.rb

@@ -1,42 +1,8 @@
 require 'nio'
 require_relative 'actor'
+require_relative 'io_receipt'
 
 module Rbgo
-  class IOReceipt
-    attr_reader :registered_op, :done_flag
-    attr_accessor :res
-
-    def wait
-      mutex.synchronize do
-        until done_flag
-          cond.wait(mutex)
-        end
-      end
-      nil
-    end
-
-    def notify
-      mutex.synchronize do
-        self.done_flag = true
-        cond.signal
-      end
-      nil
-    end
-
-    private
-
-    attr_accessor :mutex, :cond
-    attr_writer :registered_op, :done_flag
-
-    def initialize(op)
-      self.done_flag     = false
-      self.mutex         = Mutex.new
-      self.cond          = ConditionVariable.new
-      self.registered_op = op
-    end
-  end
-
-
   class IOMachine
     def do_read(io, length: nil)
       op      = [:register_read, io, length]
@@ -638,25 +604,24 @@ module Rbgo
     def handle_write_msg(receipt, actor)
       op  = receipt.registered_op
       io  = op[1]
-      str = op[2].to_s
+      buf = op[2].to_s
 
       monitor = register(receipt, interest: :w)
       return if monitor.nil?
 
-      buf = NIO::ByteBuffer.new(str.bytesize)
-      buf << str
-      buf.flip
       bytes_written_n  = 0
       monitor.value    ||= []
       monitor.value[1] = proc do
         begin
-          if buf.remaining > 0
-            n               = buf.write_to(io)
-            bytes_written_n += n
+          if buf.size - bytes_written_n > 0
+            n               = io.write_nonblock(buf[bytes_written_n..-1], exception: false)
+            if n.is_a? Numeric
+              bytes_written_n += n
+            end
           else
             monitors.delete(monitor.io)
             monitor.close
-            receipt.res = str.bytesize
+            receipt.res = buf.bytesize
             receipt.notify
           end
         rescue Exception => ex
@@ -674,6 +639,15 @@ module Rbgo
     def register(receipt, interest:)
       io                 = receipt.registered_op[1]
       registered_monitor = monitors[io]
+
+      if io.closed?
+        monitors.delete(io)
+        registered_monitor.close if registered_monitor
+        receipt.res = nil
+        receipt.notify
+        return nil
+      end
+
       if registered_monitor && (registered_monitor.interests == interest || registered_monitor.interests == :rw)
         actor.send_msg receipt
         return nil

data/lib/rbgo/io_receipt.rb

@@ -0,0 +1,35 @@
+module Rbgo
+  class IOReceipt
+    attr_reader :registered_op, :done_flag
+    attr_accessor :res
+
+    def wait
+      mutex.synchronize do
+        until done_flag
+          cond.wait(mutex)
+        end
+      end
+      nil
+    end
+
+    def notify
+      mutex.synchronize do
+        self.done_flag = true
+        cond.signal
+      end
+      nil
+    end
+
+    private
+
+    attr_accessor :mutex, :cond
+    attr_writer :registered_op, :done_flag
+
+    def initialize(op)
+      self.done_flag     = false
+      self.mutex         = Mutex.new
+      self.cond          = ConditionVariable.new
+      self.registered_op = op
+    end
+  end
+end

data/lib/rbgo/network_service.rb

@@ -1,4 +1,5 @@
 require 'socket'
+require 'openssl'
 require_relative 'select_chan'
 require_relative 'corun'
 
@@ -39,7 +40,138 @@ module Rbgo
       end
     end
 
-    def open_tcp_service(host = nil, port, &blk)
+    def self.open_tcp_service_with_sockets(sockets, &blk)
+      res_chan = Chan.new(1)
+      service  = Service.send :new
+
+      routine = go! do
+        service.send :type=, :tcp
+        service.send :host=, sockets.first.local_address.ip_address
+        service.send :port=, sockets.first.local_address.ip_port
+        service.task = blk
+        service.send :sockets=, sockets
+        res_chan << service
+        begin
+          Socket.accept_loop(sockets) do |sock, clientAddrInfo|
+            go do
+              if service.task.nil?
+                sock.close
+              else
+                service.task.call(sock, clientAddrInfo)
+              end
+            end
+          end
+        rescue Exception => ex
+          Rbgo.logger&.error('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+        end
+      end
+      service.send :service_routine=, routine
+      res_chan.deq
+      service
+    end
+
+    def self.open_ssl_service_with_socket(socket, cert_file, key_file, &blk)
+      res_chan = Chan.new(1)
+      service  = Service.send :new
+
+      routine = go! do
+        service.send :type=, :tcp
+        service.send :host=, socket.local_address.ip_address
+        service.send :port=, socket.local_address.ip_port
+        service.task = blk
+        begin
+          cert     = OpenSSL::X509::Certificate.new(File.read(cert_file))
+          key      = OpenSSL::PKey::RSA.new(File.open(key_file))
+          ctx      = OpenSSL::SSL::SSLContext.new()
+          ctx.cert = cert
+          ctx.key  = key
+
+          tcp_server = socket
+          ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx)
+          service.send :sockets=, [ssl_server]
+          res_chan << service
+          begin
+            loop do
+              sock = ssl_server.accept
+              sock.sync_close = true
+              go do
+                if service.task.nil?
+                  sock.close
+                else
+                  service.task.call(sock, sock.io.remote_address)
+                end
+              end
+            end
+          rescue Exception => ex
+            if ex.is_a? OpenSSL::SSL::SSLError
+              Rbgo.logger&.info('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+              retry
+            else
+              Rbgo.logger&.error('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+            end
+          end
+        rescue Exception => ex
+          res_chan << service
+          Rbgo.logger&.error('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+        end
+      end
+      service.send :service_routine=, routine
+      res_chan.deq
+      service
+    end
+
+    def self.open_ssl_service(host = nil, port, cert_file, key_file, &blk)
+      res_chan = Chan.new(1)
+      service  = Service.send :new
+
+      routine = go! do
+        service.send :type=, :tcp
+        service.send :host=, host
+        service.send :port=, port
+        service.task = blk
+        begin
+          cert     = OpenSSL::X509::Certificate.new(File.read(cert_file))
+          key      = OpenSSL::PKey::RSA.new(File.open(key_file))
+          ctx      = OpenSSL::SSL::SSLContext.new()
+          ctx.cert = cert
+          ctx.key  = key
+
+          tcp_server = TCPServer.new(host, port)
+          service.send :port=, tcp_server.local_address.ip_port
+          ssl_server = OpenSSL::SSL::SSLServer.new(tcp_server, ctx)
+          service.send :sockets=, [ssl_server]
+          res_chan << service
+          begin
+            loop do
+              sock = ssl_server.accept
+              sock.sync_close = true
+              go do
+                if service.task.nil?
+                  sock.close
+                else
+                  service.task.call(sock, sock.io.remote_address)
+                end
+              end
+            end
+          rescue Exception => ex
+            if ex.is_a? OpenSSL::SSL::SSLError
+              Rbgo.logger&.info('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+              retry
+            else
+              Rbgo.logger&.error('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+            end
+          end
+        rescue Exception => ex
+          res_chan << service
+          Rbgo.logger&.error('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+        end
+      end
+      service.send :service_routine=, routine
+      res_chan.deq
+      service
+    end
+
+    def self.open_tcp_service(host = nil, port, &blk)
 
       res_chan = Chan.new(1)
       service  = Service.send :new
@@ -78,7 +210,32 @@ module Rbgo
       service
     end
 
-    def open_udp_service(host = nil, port, &blk)
+    def self.open_udp_service_with_sockets(sockets, &blk)
+      res_chan = Chan.new(1)
+      service  = Service.send :new
+      routine  = go! do
+        service.send :type=, :udp
+        service.send :host=, sockets.first.local_address.ip_address
+        service.send :port=, sockets.first.local_address.ip_port
+        service.task = blk
+        service.send :sockets=, sockets
+        res_chan << service
+        begin
+          Socket.udp_server_loop_on(sockets) do |msg, msg_src|
+            go do
+              service.task&.call(msg, msg_src)
+            end
+          end
+        rescue Exception => ex
+          Rbgo.logger&.error('Rbgo') { "#{ex.message}\n#{ex.backtrace}" }
+        end
+      end
+      service.send :service_routine=, routine
+      res_chan.deq
+      service
+    end
+
+    def self.open_udp_service(host = nil, port, &blk)
 
       res_chan = Chan.new(1)
       service  = Service.send :new
@@ -96,7 +253,7 @@ module Rbgo
             begin
               Socket.udp_server_loop_on(sockets) do |msg, msg_src|
                 go do
-                  service.task.call(msg, msg_src) unless service.task.nil?
+                  service.task&.call(msg, msg_src)
                 end
               end
             rescue Exception => ex
@@ -112,8 +269,5 @@ module Rbgo
       res_chan.deq
       service
     end
-
-    module_function :open_tcp_service, :open_udp_service
-    public :open_tcp_service, :open_udp_service
   end
 end

data/lib/rbgo/observer.rb

@@ -0,0 +1,69 @@
+require 'thread'
+require_relative 'synchronized_collection'
+require_relative 'corun'
+
+module Rbgo
+  module Observable
+    @mutex = Mutex.new
+
+    def add_observer(observer, func = :update)
+      unless defined? @observer_peers
+        Observable.instance_variable_get(:@mutex).synchronize do
+          @observer_peers = SyncHash.new unless defined? @observer_peers
+        end
+      end
+
+      unless observer.respond_to? func
+        raise NoMethodError, "observer does not respond to `#{func}'"
+      end
+      @observer_peers[observer] = func
+    end
+
+    def delete_observer(observer)
+      @observer_peers.delete observer if defined? @observer_peers
+    end
+
+    def delete_observers
+      @observer_peers.clear if defined? @observer_peers
+    end
+
+    def count_observers
+      if defined? @observer_peers
+        @observer_peers.size
+      else
+        0
+      end
+    end
+
+    def changed(state = true)
+      Observable.instance_variable_get(:@mutex).synchronize do
+        @observer_state = state
+      end
+    end
+
+    def changed?
+      if defined? @observer_state and @observer_state
+        true
+      else
+        false
+      end
+    end
+
+    def notify_observers(*arg)
+      if defined? @observer_state and @observer_state
+        if defined? @observer_peers
+          Observable.instance_variable_get(:@mutex).synchronize do
+            if @observer_state
+              @observer_peers.each do |k, v|
+                CoRun::Routine.new(new_thread: false, queue_tag: :default) do
+                  k.send v, *arg
+                end
+              end
+              @observer_state = false
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/rbgo/select_chan.rb

@@ -1,4 +1,5 @@
 require 'thread'
+require 'set'
 
 module Rbgo
   module Channel
@@ -29,25 +30,35 @@ module Rbgo
         end
       end
 
-      def self.after(seconds)
+      def self.after(seconds, &blk)
         ch = new
         CoRun::Routine.new(new_thread: true, queue_tag: :none) do
-          sleep seconds
-          ch << Time.now rescue nil
-          ch.close
+          begin
+            sleep seconds
+            v = blk.nil? ? Time.now : blk.call
+            ch << v rescue nil
+          ensure
+            ch.close
+          end
         end
         ch
       end
 
-      def self.tick(every_seconds)
+      def self.tick(every_seconds, &blk)
         ch = new
         CoRun::Routine.new(new_thread: true, queue_tag: :none) do
-          loop do
-            sleep every_seconds
-            begin
-              ch.enq(Time.now, true)
-            rescue ThreadError
+          begin
+            loop do
+              break if ch.closed?
+              sleep every_seconds
+              v = blk.nil? ? Time.now : blk.call
+              begin
+                ch.enq(v, true)
+              rescue ThreadError
+              end
             end
+          ensure
+            ch.close
           end
         end
         ch
@@ -57,9 +68,11 @@ module Rbgo
         ch = new
         CoRun::Routine.new(new_thread: false, queue_tag: :default) do
           begin
+            res = nil
             Timeout::timeout(timeout) do
-              blk.call
+              res = blk.call
             end
+            ch << res rescue nil
           rescue Timeout::Error
           ensure
             ch.close
@@ -75,11 +88,16 @@ module Rbgo
 
       def register(io)
         register_mutex.synchronize do
-          ios.delete_if { |io| io.closed? }
           ios << io
         end
       end
 
+      def unregister(io)
+        register_mutex.synchronize do
+          ios.delete(io)
+        end
+      end
+
       def notify
         register_mutex.synchronize do
           ios.each do |io|
@@ -110,7 +128,7 @@ module Rbgo
         self.have_enq_waiting_flag = false
         self.have_deq_waiting_flag = false
 
-        self.ios            = []
+        self.ios            = Set.new
         self.register_mutex = Mutex.new
       end
 
@@ -241,12 +259,12 @@ module Rbgo
       alias_method :queue_max, :max
       alias_method :queue_max=, :max=
       include Chan
-      
+
       def initialize(max)
         super(max)
         @mutex              = Mutex.new
         @cond               = ConditionVariable.new
-        self.ios            = []
+        self.ios            = Set.new
         self.register_mutex = Mutex.new
       end
 
@@ -331,10 +349,10 @@ module Rbgo
 
       io_hash      = {}
       close_io_blk = proc do
-        io_hash.each_pair.flat_map do |k, v|
-          [k, v[1]]
-        end.each do |io|
-          io.close rescue nil
+        io_hash.each_pair do |io_r, (op, io_w)|
+          io_r.close rescue nil
+          io_w.close rescue nil
+          op.unregister(io_w)
         end
       end
 
@@ -392,6 +410,9 @@ module Rbgo
       op.define_singleton_method(:register) do |io_w|
         chan.send :register, io_w
       end
+      op.define_singleton_method(:unregister) do|io_w|
+        chan.send :unregister, io_w
+      end
       op
     end
 
@@ -411,6 +432,9 @@ module Rbgo
       op.define_singleton_method(:register) do |io_w|
         chan.send :register, io_w
       end
+      op.define_singleton_method(:unregister) do|io_w|
+        chan.send :unregister, io_w
+      end
       op
     end
 

data/lib/rbgo/synchronized_collection.rb

@@ -2,73 +2,44 @@ require 'monitor'
 require 'set'
 
 module Rbgo
-  class SyncArray
-    def self.[](*args)
-      SyncArray.new(Array.[](*args))
-    end
-
-    def self.try_convert(obj)
-      a = Array.try_convert(obj)
-      a.nil? ? nil : SyncArray.new(a)
-    end
+  class SyncArray < Array
+    include MonitorMixin
 
-    def initialize(*args, &blk)
-      @a = Array.new(*args, &blk)
-      @a.extend(MonitorMixin)
+    def initialize(*args)
+      super(*args)
     end
 
-    Array.public_instance_methods.each do |m|
+    Array.public_methods.each do |m|
       define_method(m) do |*args, &blk|
-        @a.synchronize do
-          @a.send m, *args, &blk
-        end
+        synchronize { super(*args, &blk) }
       end
     end
   end
 
-  class SyncHash
-    def self.[](*args)
-      h = SyncHash.new
-      h.instance_eval do
-        @h = Hash.[](*args)
-        @h.extend(MonitorMixin)
-      end
-    end
-
-    def self.try_convert(obj)
-      h = Hash.try_convert(obj)
-      h.nil? ? nil : SyncHash.[](h)
-    end
+  class SyncHash < Hash
+    include MonitorMixin
 
-    def initialize(*args, &blk)
-      @h = Hash.new(*args, &blk)
-      @h.extend(MonitorMixin)
+    def initialize(*args)
+      super(*args)
     end
 
-    Hash.public_instance_methods.each do |m|
+    Hash.public_methods.each do |m|
       define_method(m) do |*args, &blk|
-        @h.synchronize do
-          @h.send m, *args, &blk
-        end
+        synchronize { super(*args, &blk) }
       end
     end
   end
 
-  class SyncSet
-    def self.[](*args)
-      SyncSet.new(Set.[](*args))
-    end
+  class SyncSet < Set
+    include MonitorMixin
 
-    def initialize(enum = nil)
-      @s = Set.new(enum)
-      @s.extend(MonitorMixin)
+    def initialize(*args)
+      super(*args)
     end
 
-    Set.public_instance_methods.each do |m|
+    Set.public_methods.each do |m|
       define_method(m) do |*args, &blk|
-        @s.synchronize do
-          @s.send m, *args, &blk
-        end
+        synchronize { super(*args, &blk) }
       end
     end
   end

data/lib/rbgo/version.rb

@@ -1,3 +1,3 @@
 module Rbgo
-  VERSION = "0.3.2"
+  VERSION = "0.3.3"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: rbgo
 version: !ruby/object:Gem::Version
-  version: 0.3.2
+  version: 0.3.3
 platform: ruby
 authors:
 - Wang Yin
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-09-27 00:00:00.000000000 Z
+date: 2020-01-02 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: system
@@ -53,7 +53,9 @@ files:
 - lib/rbgo/actor.rb
 - lib/rbgo/corun.rb
 - lib/rbgo/io_machine.rb
+- lib/rbgo/io_receipt.rb
 - lib/rbgo/network_service.rb
+- lib/rbgo/observer.rb
 - lib/rbgo/once.rb
 - lib/rbgo/reentrant_mutex.rb
 - lib/rbgo/reentrant_rw_mutex.rb