rbgo 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: d9e43797ac2188d0ed30432699def2789333d41d5dbacfacbc34710af4f1c505
+  data.tar.gz: 36b4745d925d33b30c759295d36337de1b283668959f922149d02e5fbc8c0738
+SHA512:
+  metadata.gz: ca341dd5a7f430802ca235d01906ef67b801238c5566e1f415838c742ad28e10ac6d28862fa8bfde87f688bf2ada43a5bfd3fc21603f0933df8b8c620c3080e0
+  data.tar.gz: 023e7bbcbb60fff0b8768b773a0176753af86bf72fa970d48410a17ffe8dcd7f6d8bcf7b43d7ca77760bbf581a097cb1ae7481dd31a00dc7078c4b66a2725f3f

data/.gitignore

@@ -0,0 +1,8 @@
+main.rb
+.idea
+pkg/*
+*.gem
+.bundle
+tmp/*
+.rbx
+

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,21 @@
+PATH
+  remote: .
+  specs:
+    rbgo (0.1.0)
+      sys-cpu (~> 0.8)
+
+GEM
+  remote: http://rubygems.org/
+  specs:
+    ffi (1.11.1)
+    sys-cpu (0.8.0)
+      ffi
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  rbgo!
+
+BUNDLED WITH
+   2.0.2

data/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2019 王寅
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -0,0 +1,113 @@
+# I like the way how golang does in concurrency.
+ 
+You can produce a light weight routine easily with a keyword 'go' and communicate with each routine by channel.
+
+In MRI the GIL prevents you from running code parallelly, but there ara also other ruby implementations such as TruffleRuby or JRuby which can utilize all CPU cores.
+
+In MRI write program to run concurrently even not parallelly is also important.
+
+# This project is trying to help writing concurrent program with ruby a little easier.     
+
+# select_chan                       
+select channels like golang in ruby
+
+Chan is buffered or non-buffered, just like make(chan Type,n) or make(chan Type) in golang
+but not statically typed in my implementation.
+
+example:
+
+```ruby
+require_relative 'select_chan'
+
+include Channel
+
+ch1 = Chan.new  # non-buffer channel
+ch2 = Chan.new(2) # buffer channel 
+ch3 = Chan.new(1)
+
+ch3 << 'hello'
+
+select_chan(
+  on_read(chan: ch1){|obj, ok| # obj is the value read from ch1, ok indicates success or failure by close
+    #do when read success
+  },
+  on_read(chan: ch2){
+    #do when read success
+  },
+  on_write(chan: ch3, obj: 'world'){
+    #do when write success
+  }
+){ puts 'call default block' }
+```
+# go                                
+create lightweight routine like golang
+
+example:
+
+```ruby
+require_relative 'corun'
+require_relative 'wait_group'
+
+using CoRunExtensions
+
+wg = WaitGroup.new
+
+wg.add(1)
+go do
+  puts 'start' 
+
+  Fiber.yield  # like Gosched()
+
+  puts 'end'
+
+  wg.done
+end
+
+wg.add(1)
+go do
+  sleep 1
+  puts 'sleep end'
+  wg.done
+end
+
+wg.wait
+puts 'wg.wait done'
+
+```            
+# NetworkService
+
+open TCP or UDP service 
+
+because service handles network request in async mode, it can handle many requests concurrently. If use some Non-GIL ruby implementations such as TruffleRuby or JRuby, it can utilize all your CPU cores.  
+
+
+```ruby  
+require_relative 'network_service'
+        
+#localhost, port 3000
+tcp_service = NetworkServiceFactory.open_tcp_service(3000) do|sock, clientAddrInfo|
+  p [sock, clientAddrInfo]
+end                  
+
+                                        
+
+p "start tcp service: #{[tcp_service.host, tcp_service.port, tcp_service.type]}"
+
+tcp_service.stop
+                            
+          
+
+#localhost, port auto pick
+udp_service = NetworkServiceFactory.open_udp_service(0) do|msg, reply_msg|
+  p msg
+  reply_msg.reply("I receive your message")
+end
+
+p "start udp service: #{[udp_service.host, udp_service.port, udp_service.type]}"
+
+udp_service.stop
+
+
+sleep
+
+``` 

data/lib/rbgo/corun.rb

@@ -0,0 +1,192 @@
+require 'thread'
+require 'fiber'
+require 'sys-cpu'
+require 'singleton'
+
+module Rbgo
+  module CoRun
+
+    class Routine
+      attr_accessor :error
+
+      def alive?
+        return fiber.alive? unless fiber.nil?
+        true
+      end
+
+      private
+
+      attr_accessor :args, :blk, :fiber
+
+      def initialize(*args, &blk)
+        self.args = args
+        self.blk  = blk
+        Scheduler.instance.schedule(self)
+      end
+
+      def perform
+        self.fiber = Fiber.new do |args|
+          blk.call(*args)
+        end if fiber.nil?
+
+        if fiber.alive?
+          fiber.resume(*args)
+        end
+        nil
+      end
+    end
+
+    class Scheduler
+      include Singleton
+      attr_accessor :num_thread
+
+      private
+
+      attr_accessor :thread_pool
+      attr_accessor :task_queue
+      attr_accessor :msg_queue
+      attr_accessor :supervisor_thread
+
+      def initialize
+        self.num_thread  = Sys::CPU.num_cpu
+        self.thread_pool = []
+
+        self.msg_queue  = Queue.new
+        self.task_queue = Queue.new
+
+        msg_queue << :init
+        create_supervisor_thread
+        generate_check_msg
+      end
+
+      # only called by supervisor thread
+      def create_thread
+        begin
+          thread_pool << Thread.new do
+            Thread.current.report_on_exception = false
+            begin
+              should_exit      = false
+              yield_task_queue = Queue.new
+              local_task_queue = Queue.new
+              loop do
+                task = nil
+                if local_task_queue.empty?
+                  task = task_queue.deq(true) rescue nil
+                  if task.nil?
+                    task = yield_task_queue.deq unless yield_task_queue.empty?
+                    task = task_queue.deq if task.nil?
+                    local_task_queue << task
+                  else
+                    local_task_queue << task
+                    local_task_queue << yield_task_queue.deq unless yield_task_queue.empty?
+                  end
+                end
+                task = local_task_queue.deq
+
+                begin
+                  Thread.current.thread_variable_set(:performing, true)
+                  task.send :perform
+                rescue Exception => ex
+                  task.error = ex
+                  next
+                ensure
+                  Thread.current.thread_variable_set(:performing, false)
+                end
+
+                if task.alive?
+                  yield_task_queue << task
+                end
+
+                should_exit = Thread.current.thread_variable_get(:should_exit) &&
+                  yield_task_queue.empty? &&
+                  local_task_queue.empty?
+                break if should_exit
+              end
+            ensure
+              msg_queue << :thread_exit unless should_exit
+            end
+          end
+        rescue Exception => ex
+          STDERR.puts ex
+        end
+        nil
+      end
+
+      def create_supervisor_thread
+        self.supervisor_thread = Thread.new do
+          begin
+            loop do
+              msg = msg_queue.deq
+              case msg
+              when :thread_exit, :init, :check
+                check_thread_pool
+              end
+            end
+          ensure
+            STDERR.puts 'supervisor thread exit'
+          end
+        end
+        nil
+      end
+
+      def generate_check_msg
+        Thread.new do
+          begin
+            loop do
+              msg_queue << :check
+              sleep 3
+            end
+          ensure
+            STDERR.puts 'check generator thread exit'
+          end
+        end
+        nil
+      end
+
+      # only called by supervisor thread
+      def check_thread_pool
+        temp = []
+        thread_pool.each do |th|
+          case th.status
+          when 'run'
+            temp << th
+          when 'sleep'
+            performing = th.thread_variable_get(:performing)
+            if performing
+              th.thread_variable_set(:should_exit, true)
+            else
+              temp << th
+            end
+          end
+        end
+        self.thread_pool = temp
+        n                = num_thread - thread_pool.size
+        if n > 0
+          n.times { create_thread }
+        elsif n < 0
+          n = -n
+          thread_pool.take(n).each do |th|
+            th.thread_variable_set(:should_exit, true)
+          end
+          self.thread_pool = thread_pool.drop(n)
+        end
+        nil
+      end
+
+      public
+
+      def schedule(routine)
+        task_queue << routine
+        nil
+      end
+    end
+  end
+
+  module CoRunExtensions
+    refine Object do
+      def go(*args, &blk)
+        CoRun::Routine.new(*args, &blk)
+      end
+    end
+  end
+end

data/lib/rbgo/network_service.rb

@@ -0,0 +1,128 @@
+require 'socket'
+require_relative 'select_chan'
+require_relative 'corun'
+
+module Rbgo
+  module NetworkServiceFactory
+    using CoRunExtensions
+    include Channel
+
+    class Service
+      attr_reader :host, :port, :type
+      attr_accessor :task
+
+      def alive?
+        service_routine.alive?
+      end
+
+      def stop
+        sockets.each do |sock|
+          sock.close
+        end
+      end
+
+      private
+
+      attr_accessor :service_routine, :sockets
+      attr_writer :host, :port, :type
+
+      def initialize
+        self.type    = :unknown
+        self.host    = nil
+        self.port    = 0
+        self.sockets = []
+      end
+
+      class << self
+        private :new
+      end
+    end
+
+    def open_tcp_service(host = nil, port, &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
+          Socket.tcp_server_sockets(host, port) do |sockets|
+            service.send :port=, sockets.first.local_address.ip_port
+            service.send :sockets=, sockets
+
+            res_chan << service
+
+            begin
+              Socket.accept_loop(sockets) do |sock, clientAddrInfo|
+                go do
+                  begin
+                    service.task.call(sock, clientAddrInfo) unless service.task.nil?
+                  ensure
+                    sock.close
+                  end
+                end
+              end
+            rescue Exception => ex
+              STDERR.puts ex
+            end
+
+          end
+        rescue Exception => ex
+          res_chan << service
+          STDERR.puts ex
+        end
+      end
+
+      service.send :service_routine=, routine
+
+      res_chan.deq
+      service
+    end
+
+    def open_udp_service(host = nil, port, &blk)
+
+      res_chan = Chan.new(1)
+      service  = Service.send :new
+
+      routine = go do
+        service.send :type=, :udp
+        service.send :host=, host
+        service.send :port=, port
+        service.task = blk
+        begin
+          Socket.udp_server_sockets(host, port) do |sockets|
+            service.send :port=, sockets.first.local_address.ip_port
+            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) unless service.task.nil?
+                end
+              end
+            rescue Exception => ex
+              STDERR.puts ex
+            end
+
+          end
+        rescue Exception => ex
+          res_chan << service
+          STDERR.puts ex
+        end
+      end
+
+      service.send :service_routine, routine
+
+      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/select_chan.rb

@@ -0,0 +1,383 @@
+require 'thread'
+require 'set'
+require 'monitor'
+
+module Rbgo
+  module Channel
+    module Chan
+
+      def self.new(max = 0)
+        if max <= 0
+          NonBufferChan.new
+        else
+          BufferChan.new(max)
+        end
+      end
+
+      private
+
+      def register(observer:, mode: :rw)
+        unless observer.is_a? ConditionVariable
+          return false
+        end
+        mode = mode.to_sym.downcase
+        if mode == :rw
+          @readable_observers.synchronize do
+            @readable_observers.add(observer)
+          end
+          @writable_observers.synchronize do
+            @writable_observers.add(observer)
+          end
+        elsif mode == :r
+          @readable_observers.synchronize do
+            @readable_observers.add(observer)
+          end
+        elsif mode == :w
+          @writable_observers.synchronize do
+            @writable_observers.add(observer)
+          end
+        else
+          return false
+        end
+        true
+      end
+
+      def unregister(observer:, mode: :rw)
+        mode = mode.to_sym.downcase
+        if mode == :rw
+          @readable_observers.synchronize do
+            @readable_observers.delete(observer)
+          end
+          @writable_observers.synchronize do
+            @writable_observers.delete(observer)
+          end
+        elsif mode == :r
+          @readable_observers.synchronize do
+            @readable_observers.delete(observer)
+          end
+        elsif mode == :w
+          @writable_observers.synchronize do
+            @writable_observers.delete(observer)
+          end
+        else
+          return false
+        end
+        true
+      end
+
+      def notify_readable_observers
+        @readable_observers.each(&:broadcast)
+        nil
+      end
+
+      def notify_writable_observers
+        @writable_observers.each(&:broadcast)
+        nil
+      end
+    end
+
+    # NonBufferChan
+    #
+    #
+    #
+    #
+    #
+    class NonBufferChan
+      include Chan
+
+      def initialize
+        self.enq_mutex             = Mutex.new
+        self.deq_mutex             = Mutex.new
+        self.enq_cond              = ConditionVariable.new
+        self.deq_cond              = ConditionVariable.new
+        self.resource_array        = []
+        self.close_flag            = false
+        self.have_enq_waiting_flag = false
+        self.have_deq_waiting_flag = false
+
+        @readable_observers = Set.new
+        @readable_observers.extend(MonitorMixin)
+        @writable_observers = Set.new
+        @writable_observers.extend(MonitorMixin)
+      end
+
+      def push(obj, nonblock = false)
+        if closed?
+          raise ClosedQueueError.new
+        end
+
+        if nonblock
+          raise ThreadError.new unless enq_mutex.try_lock
+        else
+          enq_mutex.lock
+        end
+
+        begin
+          if nonblock
+            raise ThreadError.new unless have_deq_waiting_flag
+          end
+
+          begin
+            if closed?
+              raise ClosedQueueError.new
+            else
+              deq_mutex.synchronize do
+                resource_array[0] = obj
+                enq_cond.signal
+                until resource_array.empty? || closed?
+                  self.have_enq_waiting_flag = true
+
+                  begin
+                    Thread.new do
+                      deq_mutex.synchronize do
+                        # no op
+                      end
+                      notify_readable_observers
+                    end
+                  rescue Exception => ex
+                    STDERR.puts ex
+                    sleep 1
+                    retry
+                  end
+
+                  deq_cond.wait(deq_mutex)
+                end
+                raise ClosedQueueError.new if closed?
+              end
+            end
+          ensure
+            self.have_enq_waiting_flag = false
+          end
+        ensure
+          enq_mutex.unlock
+        end
+
+        self
+      end
+
+      def pop(nonblock = false)
+        resource = nil
+        if closed?
+          return [nil, false]
+        end
+
+        if nonblock
+          raise ThreadError.new unless deq_mutex.try_lock
+        else
+          deq_mutex.lock
+        end
+
+        begin
+          if nonblock
+            raise ThreadError.new unless have_enq_waiting_flag
+          end
+
+          while resource_array.empty? && !closed?
+            self.have_deq_waiting_flag = true
+            notify_writable_observers
+            enq_cond.wait(deq_mutex)
+          end
+          resource = resource_array.first
+          resource_array.clear
+          self.have_deq_waiting_flag = false
+          deq_cond.signal
+        ensure
+          deq_mutex.unlock
+        end
+
+        [resource, !closed?]
+      end
+
+      def close
+        self.close_flag = true
+        enq_cond.broadcast
+        deq_cond.broadcast
+        notify_readable_observers
+        notify_writable_observers
+        self
+      end
+
+      def closed?
+        close_flag
+      end
+
+      alias_method :<<, :push
+      alias_method :enq, :push
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+
+      private
+
+      attr_accessor :enq_mutex, :deq_mutex, :enq_cond,
+                    :deq_cond, :resource_array, :close_flag,
+                    :have_enq_waiting_flag, :have_deq_waiting_flag
+    end
+
+
+    # BufferChan
+    #
+    #
+    #
+    #
+    #
+    #
+    class BufferChan < SizedQueue
+      include Chan
+      include Enumerable
+
+      def each
+        if block_given?
+          loop do
+            begin
+              yield pop(true)
+            rescue ThreadError
+              return
+            end
+          end
+        else
+          enum_for(:each)
+        end
+      end
+
+      def initialize(max)
+        super(max)
+        @readable_observers = Set.new
+        @readable_observers.extend(MonitorMixin)
+        @writable_observers = Set.new
+        @writable_observers.extend(MonitorMixin)
+      end
+
+      def push(obj, nonblock = false)
+        super(obj, nonblock)
+        notify_readable_observers
+        self
+      rescue ThreadError
+        raise ClosedQueueError.new if closed?
+        raise
+      end
+
+      def pop(nonblock = false)
+        res = nil
+        begin
+          res = super(nonblock)
+          notify_writable_observers
+          res
+        rescue ThreadError
+          raise unless closed?
+        end
+        [res, !closed?]
+      end
+
+      def clear
+        super
+        notify_writable_observers
+        self
+      end
+
+      def close
+        super
+        notify_readable_observers
+        notify_writable_observers
+        self
+      end
+
+      alias_method :<<, :push
+      alias_method :enq, :push
+      alias_method :deq, :pop
+      alias_method :shift, :pop
+    end
+
+
+    # select_chan
+    #
+    #
+    #
+    #
+    #
+    #
+    #
+    def select_chan(*ops)
+      ops.shuffle!
+
+      mutex = Mutex.new
+      cond  = ConditionVariable.new
+
+      loop do
+
+        ops.each do |op|
+          begin
+            return op.call
+          rescue ThreadError
+          end
+        end
+
+        return yield if block_given?
+
+        ops.each do |op|
+          op.register(cond)
+        end
+
+        mutex.synchronize do
+          cond.wait mutex
+        end
+
+      end
+
+    ensure
+
+      ops.each do |op|
+        op.unregister(cond)
+      end
+
+    end
+
+    # on_read
+    #
+    #
+    #
+    #
+    def on_read(chan:, &blk)
+      raise ArgumentError.new('chan must be a Chan') unless chan.is_a? Chan
+      op = Proc.new do
+        res, ok = chan.deq(true)
+        if blk.nil?
+          [res, ok]
+        else
+          blk.call(res, ok)
+        end
+      end
+      op.define_singleton_method(:register) do |cond|
+        chan.send :register, observer: cond, mode: :r
+      end
+      op.define_singleton_method(:unregister) do |cond|
+        chan.send :unregister, observer: cond, mode: :r
+      end
+      op
+    end
+
+    # on_write
+    #
+    #
+    #
+    #
+    #
+    def on_write(chan:, obj:, &blk)
+      raise ArgumentError.new('chan must be a Chan') unless chan.is_a? Chan
+      op = Proc.new do
+        res = chan.enq(obj, true)
+        res = blk.call unless blk.nil?
+        res
+      end
+
+      op.define_singleton_method(:register) do |cond|
+        chan.send :register, observer: cond, mode: :w
+      end
+      op.define_singleton_method(:unregister) do |cond|
+        chan.send :unregister, observer: cond, mode: :w
+      end
+      op
+    end
+
+    module_function :select_chan, :on_read, :on_write
+  end
+end

data/lib/rbgo/version.rb

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

data/lib/rbgo/wait_group.rb

@@ -0,0 +1,46 @@
+require 'thread'
+
+module Rbgo
+  class WaitGroup
+    def initialize(init_count = 0)
+      self.total_count = [0, init_count].max
+      self.mutex       = Mutex.new
+      self.cond        = ConditionVariable.new
+    end
+
+    def add(count)
+      mutex.synchronize do
+        c = total_count + count
+        if c < 0
+          raise RuntimeError.new('WaitGroup counts < 0')
+        else
+          self.total_count = c
+        end
+      end
+    end
+
+    def done
+      mutex.synchronize do
+        c = total_count - 1
+        if c < 0
+          raise RuntimeError.new('WaitGroup counts < 0')
+        else
+          self.total_count = c
+        end
+        cond.broadcast if c == 0
+      end
+    end
+
+    def wait
+      mutex.synchronize do
+        while total_count > 0
+          cond.wait(mutex)
+        end
+      end
+    end
+
+    private
+
+    attr_accessor :total_count, :mutex, :cond
+  end
+end

data/lib/rbgo.rb

@@ -0,0 +1,4 @@
+require_relative 'rbgo/corun'
+require_relative 'rbgo/select_chan'
+require_relative 'rbgo/wait_group'
+require_relative 'rbgo/network_service'

data/rbgo.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+
+require_relative "lib/rbgo/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rbgo"
+  s.version     = Rbgo::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.authors     = ["Wang Yin"]
+  s.email       = ["24588062@qq.com"]
+  s.homepage    = "https://github.com/wangyin-git/select_chan"
+  s.summary     = "Write concurrent program with Ruby in Golang style"
+  s.description = <<-END
+                    You can produce a light weight routine easily with a keyword 'go' and communicate with each routine by channel.
+
+                    In MRI the GIL prevents you from running code parallelly, but there ara also other ruby implementations such as TruffleRuby or JRuby which can utilize all CPU cores.
+
+                    In MRI write program to run concurrently even not parallelly is also important.    
+
+                    This project is trying to help writing concurrent program with ruby a little easier
+                  END
+  s.add_dependency "sys-cpu", "~> 0.8"
+  s.files         = `git ls-files`.split("\n")
+  s.license       = 'MIT'
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: rbgo
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Wang Yin
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-08-03 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sys-cpu
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+description: "                    You can produce a light weight routine easily with
+  a keyword 'go' and communicate with each routine by channel.\n\n                    In
+  MRI the GIL prevents you from running code parallelly, but there ara also other
+  ruby implementations such as TruffleRuby or JRuby which can utilize all CPU cores.\n\n
+  \                   In MRI write program to run concurrently even not parallelly
+  is also important.    \n\n                    This project is trying to help writing
+  concurrent program with ruby a little easier\n"
+email:
+- 24588062@qq.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- LICENSE
+- README.md
+- lib/rbgo.rb
+- lib/rbgo/corun.rb
+- lib/rbgo/network_service.rb
+- lib/rbgo/select_chan.rb
+- lib/rbgo/version.rb
+- lib/rbgo/wait_group.rb
+- rbgo.gemspec
+homepage: https://github.com/wangyin-git/select_chan
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Write concurrent program with Ruby in Golang style
+test_files: []