rakie 0.0.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 95d75f7ea14d2462c94b21bd025f17e5150075e295dd1dc9f927efb08826c424
+  data.tar.gz: 2642f719d6ae1427e99efc89b3d841fe7c7471f5cfd2da0597ad4df89d347b0e
+SHA512:
+  metadata.gz: ae10ff4d934dac0f08a066d2809930132b736e4cb4bda7f7cf25f30cc48f7554b4b474e8ee7cbb7fcd57b7b4e75157d9a592ff9a8351f3d9fbee431b4006e944
+  data.tar.gz: 287525054ef601031d860c7a8b75b1985e91d7430cee7b489b7fb726c06cbe15223c3ebd63cad3fbdf590793d3cb343dbfc0a6890cba89a9cbf6b632541ab6a2

data/lib/rakie/channel.rb

@@ -0,0 +1,121 @@
+module Rakie
+  class Channel
+    attr_accessor :delegate
+
+    def initialize(io, delegate=nil)
+      @io = io
+      @read_buffer = String.new
+      @write_buffer = String.new
+      @delegate = delegate
+      Event.push(io, self, Event::READ_EVENT)
+    end
+
+    def on_read(io)
+      begin
+        loop do
+          @read_buffer << io.read_nonblock(4096)
+        end
+
+      rescue IO::EAGAINWaitReadable
+        puts("Channel read finished")
+
+      rescue
+        # Process the last message on exception
+        if @delegate != nil
+          @delegate.on_recv(self, @read_buffer)
+          @read_buffer = String.new # Reset buffer
+        end
+
+        puts("Channel error #{io}")
+        return Event::HANDLE_FAILED
+      end
+
+      puts("Channel has delegate?: #{@delegate}")
+      if @delegate != nil
+        len = @delegate.on_recv(self, @read_buffer)
+
+        if len > @read_buffer.length
+          len = @read_buffer.length
+        end
+
+        @read_buffer = @read_buffer[len .. -1]
+        puts("Channel handle on_recv")
+      end
+
+      return Event::HANDLE_CONTINUED
+    end
+
+    def on_write(io)
+      begin
+        while @write_buffer.length > 0
+          len = io.write_nonblock(@write_buffer)
+          @write_buffer = @write_buffer[len .. -1]
+        end
+
+        puts("Channel write finished")
+
+      rescue IO::EAGAINWaitWritable
+        puts("Channel write continue")
+        return Event::HANDLE_CONTINUED
+
+      rescue
+        puts("Channel close #{io}")
+        return Event::HANDLE_FAILED
+      end
+
+      return Event::HANDLE_FINISHED
+    end
+
+    def on_close(io)
+      begin
+        io.close
+
+      rescue
+        puts("Channel is already closed")
+      end
+    end
+
+    def read(size)
+      if self.eof?
+        return ""
+      end
+
+      if size > data.length
+        size = data.length
+      end
+
+      data = @read_buffer[0 .. (size - 1)]
+      @read_buffer = @read_buffer[size .. -1]
+
+      return data
+    end
+
+    def write(data)
+      if @io.closed?
+        return -1
+      end
+
+      @write_buffer << data
+      Event.modify(@io, self, Event::READ_EVENT | Event::WRITE_EVENT)
+
+      return 0
+    end
+
+    def close
+      if @io.closed?
+        return nil
+      end
+
+      Event.delete(@io)
+      return nil
+    end
+
+    def eof?
+      @read_buffer.empty?
+    end
+
+    def closed?
+      @io.closed?
+    end
+  end
+end

data/lib/rakie/event.rb

@@ -0,0 +1,170 @@
+module Rakie
+  class Event
+    @instance = nil
+
+    READ_EVENT = 1
+    WRITE_EVENT = 2
+
+    HANDLE_FAILED = -1
+    HANDLE_CONTINUED = 0
+    HANDLE_FINISHED = 1
+
+    def initialize
+      @wait_ios = []
+      @lock = Mutex.new
+      @signal_in, @signal_out = IO.pipe
+      @ios = {
+        @signal_in => READ_EVENT
+      }
+      @handlers = {}
+      @run_loop = Thread.new do
+        self.run_loop
+      end
+    end
+    
+    def process_signal(io)
+      signal = io.read(1)
+      puts("Event handling #{signal}")
+
+      if signal == 'a'
+        new_io, new_handler, new_event = @wait_ios.shift
+        @ios[new_io] = new_event
+        @handlers[new_io] = new_handler
+        puts("Event add all #{new_io} to #{new_event}")
+
+      elsif signal == 'd'
+        new_io, = @wait_ios.shift
+        handler = @handlers[new_io]
+
+        if handler != nil
+          handler.on_close(new_io)
+          puts("Event close #{new_io}")
+        end
+
+        @ios.delete(new_io)
+        @handlers.delete(new_io)
+
+        puts("Event remove all #{new_io}")
+
+      elsif signal == 'm'
+        new_io, new_handler, new_event = @wait_ios.shift
+        @ios[new_io] = new_event
+        @handlers[new_io] = new_handler
+        puts("Event modify all #{new_io} to #{new_event}")
+
+      elsif signal == 'q'
+        return 1
+      end
+
+      return 0
+    end
+
+    def run_loop
+      loop do
+        read_ios = @ios.select {|k, v| v & READ_EVENT > 0}
+        write_ios = @ios.select {|k, v| v & WRITE_EVENT > 0}
+
+        read_ready, write_ready = IO.select(read_ios.keys, write_ios.keys, [], 5)
+
+        if read_ready != nil
+          read_ready.each do |io|
+            if io == @signal_in
+              @lock.lock
+
+              if self.process_signal(io) != 0
+                @lock.unlock
+                return
+              end
+
+              @lock.unlock
+              next
+            end
+
+            handler = @handlers[io]
+
+            if handler == nil
+              next
+            end
+
+            result = handler.on_read(io)
+
+            if result == HANDLE_FINISHED
+              @ios[io] = @ios[io] & ~READ_EVENT
+              puts("Event remove read #{io}")
+
+            elsif result == HANDLE_FAILED
+              handler.on_close(io)
+              puts("Event close #{io}")
+
+              @ios.delete(io)
+              @handlers.delete(io)
+              puts("Event remove all #{io}")
+            end
+          end
+        end
+
+        if write_ready != nil
+          write_ready.each do |io|
+            handler = @handlers[io]
+
+            if handler == nil
+              next
+            end
+
+            result = handler.on_write(io)
+
+            if result == HANDLE_FINISHED
+              @ios[io] = @ios[io] & ~WRITE_EVENT
+              puts("Event remove write #{io}")
+
+            elsif result == HANDLE_FAILED
+              handler.on_close(io)
+              puts("Event close #{io}")
+
+              @ios.delete(io)
+              @handlers.delete(io)
+              puts("Event remove all #{io}")
+            end
+          end
+        end
+      end
+    end
+
+    def push(io, handler, event)
+      @lock.lock
+      @wait_ios.push([io, handler, event])
+      @signal_out.write('a')
+      @lock.unlock
+    end
+
+    def delete(io)
+      @lock.lock
+      @wait_ios.push([io, nil, nil])
+      @signal_out.write('d')
+      @lock.unlock
+    end
+
+    def modify(io, handler, event)
+      @lock.lock
+      @wait_ios.push([io, handler, event])
+      @signal_out.write('m')
+      @lock.unlock
+    end
+
+    def self.instance
+      @instance ||= Event.new
+    end
+
+    def self.push(io, listener, type)
+      self.instance.push(io, listener, type)
+    end
+
+    def self.delete(io)
+      self.instance.delete(io)
+    end
+
+    def self.modify(io, listener, type)
+      self.instance.modify(io, listener, type)
+    end
+  end
+end

data/lib/rakie/simple_server.rb

@@ -0,0 +1,149 @@
+module Rakie
+  class SimpleServer
+    PARSE_ERROR = -1
+    PARSE_OK = 0
+    PARSE_PENDING = 1
+    PARSE_COMPLETE = 2
+
+    PARSE_TYPE = 0
+    PARSE_LEN = 1
+    PARSE_ENTITY = 2
+
+    def initialize(delegate=nil)
+      @channel = TCPServerChannel.new('127.0.0.1', 10086, self)
+      @clients = {}
+      @delegate = delegate
+    end
+
+    def on_accept(channel)
+      channel.delegate = self
+      @clients[channel] = {
+        :parse_status => PARSE_TYPE,
+        :parse_offset => 0,
+        :request => {
+          :type => 0,
+          :len => 0,
+          :entity => ""
+        },
+        :response => {
+          :type => 0,
+          :len => 0,
+          :entity => ""
+        }
+      }
+      puts("SimpleServer accept client: #{channel}")
+    end
+
+    def parse_data_type(client, data)
+      if data.length >= 1
+        type = data[0].ord
+        client[:request][:type] = type
+        client[:parse_status] = PARSE_LEN
+        client[:parse_offset] += 1
+
+        puts("SimpleServer parse data type ok")
+        return PARSE_OK
+      end
+
+      return PARSE_PENDING
+    end
+
+    def parse_data_len(client, data)
+      offset = client[:parse_offset]
+
+      if data.length >= 4 + offset
+        len = data[offset .. (4 + offset - 1)]
+        len = len.unpack('l')[0]
+
+        if len == nil
+          return PARSE_ERROR
+        end
+
+        client[:request][:len] = len
+        client[:parse_status] = PARSE_ENTITY
+        client[:parse_offset] = offset + 4
+
+        puts("SimpleServer parse data len ok")
+        return PARSE_OK
+      end
+
+      return PARSE_PENDING
+    end
+
+    def parse_data_entity(client, data)
+      len = client[:request][:len]
+      offset = client[:parse_offset]
+
+      if data.length >= len + offset
+        client[:request][:entity] = data[offset .. (offset + len - 1)]
+        client[:parse_status] = PARSE_TYPE
+        client[:parse_offset] = offset + len
+
+        puts("SimpleServer parse data entity ok")
+        return PARSE_COMPLETE
+      end
+
+      return PARSE_PENDING
+    end
+
+    def parse_data(client, data)
+      result = PARSE_OK
+
+      while result == PARSE_OK
+        current_status = client[:parse_status]
+
+        case current_status
+        when PARSE_TYPE
+          result = self.parse_data_type(client, data)
+
+        when PARSE_LEN
+          result = self.parse_data_len(client, data)
+
+        when PARSE_ENTITY
+          result = self.parse_data_entity(client, data)
+        end
+      end
+
+      puts("SimpleServer parse data result #{result}")
+
+      return result
+    end
+
+    def pack_data(response)
+      data = ""
+      data += [response[:type]].pack('c')
+      data += [response[:len]].pack('l')
+      data += response[:entity]
+    end
+
+    def on_recv(channel, data)
+      puts("SimpleServer recv: #{data}")
+      client = @clients[channel]
+      client[:parse_offset] = 0
+      result = self.parse_data(client, data)
+
+      pp client
+
+      if result == PARSE_COMPLETE
+        if @delegate != nil
+          @delegate.handle(client[:request], client[:response])
+
+        else
+          client[:response] = client[:request]
+        end
+        
+        channel.write(self.pack_data(client[:response])) # Response data
+
+      elsif result == PARSE_ERROR
+        channel.close
+        @clients.delete(channel)
+        puts("SimpleServer: Illegal request")
+        return client[:parse_offset]
+      end
+
+      return client[:parse_offset]
+    end
+  end
+end
+
+require "pp"

data/lib/rakie/tcp_channel.rb

@@ -0,0 +1,10 @@
+module Rakie
+  class TCPChannel < Channel
+    def initialize(ip, port, delegate=nil)
+      @io = TCPSocket.new(ip, port)
+      super(@io, delegate)
+    end
+  end
+end
+
+require "socket"

data/lib/rakie/tcp_server_channel.rb

@@ -0,0 +1,52 @@
+module Rakie
+  class TCPServerChannel < Channel
+    def initialize(ip, port=nil, delegate=nil)
+      io = nil
+      
+      if port == nil
+        port = ip
+        io = TCPServer.new(ip)
+
+      else
+        io = TCPServer.new(ip, port)
+      end
+      
+      @clients = []
+
+      super(io, delegate)
+    end
+
+    def on_read(io)
+      begin
+        client_io, = io.accept_nonblock
+        channel = Channel.new(client_io)
+
+        if @delegate != nil
+          puts("TCPServerChannel has delegate")
+          @delegate.on_accept(channel)
+
+        else
+          puts("TCPServerChannel no delegate")
+          @clients << channel
+        end
+
+        puts("TCPServerChannel accept #{channel}")
+
+      rescue IO::EAGAINWaitReadable
+        puts("TCPServerChannel accept wait")
+
+      rescue
+        puts("TCPServerChannel Accept failed #{io}")
+        return Event::HANDLE_FAILED
+      end
+
+      return Event::HANDLE_CONTINUED
+    end
+
+    def accept
+      @clients.shift
+    end
+  end
+end
+
+require "socket"

data/lib/rakie.rb

@@ -0,0 +1,10 @@
+
+module Rakie
+  
+end
+
+require "rakie/channel"
+require "rakie/event"
+require "rakie/simple_server"
+require "rakie/tcp_channel"
+require "rakie/tcp_server_channel"

data/test/test_rakie.rb

@@ -0,0 +1,5 @@
+require 'test/unit'
+
+class RakieTest < Test::Unit::TestCase
+  
+end

metadata

@@ -0,0 +1,51 @@
+--- !ruby/object:Gem::Specification
+name: rakie
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+platform: ruby
+authors:
+- Jakit Liang
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-03-29 00:00:00.000000000 Z
+dependencies: []
+description: Rakie is lucky and lucky
+email: jakitliang@163.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- Rakefile
+- lib/rakie.rb
+- lib/rakie/channel.rb
+- lib/rakie/event.rb
+- lib/rakie/simple_server.rb
+- lib/rakie/tcp_channel.rb
+- lib/rakie/tcp_server_channel.rb
+- test/test_rakie.rb
+homepage: https://github.com/Jakitto/rakie
+licenses:
+- BSD-2-Clause-Patent
+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.9
+signing_key:
+specification_version: 4
+summary: Rakie!
+test_files:
+- test/test_rakie.rb