rakie 0.0.2 → 0.0.8

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 95d75f7ea14d2462c94b21bd025f17e5150075e295dd1dc9f927efb08826c424
-  data.tar.gz: 2642f719d6ae1427e99efc89b3d841fe7c7471f5cfd2da0597ad4df89d347b0e
+  metadata.gz: 81b73eacd5a896ae3c13192543965d353a0b2dcd1e1ae021664e91793d130d77
+  data.tar.gz: bf30ef52373d98df118064c99aaaf7465e6ac8f684d0d49bea01f7d9c6f1a5ff
 SHA512:
-  metadata.gz: ae10ff4d934dac0f08a066d2809930132b736e4cb4bda7f7cf25f30cc48f7554b4b474e8ee7cbb7fcd57b7b4e75157d9a592ff9a8351f3d9fbee431b4006e944
-  data.tar.gz: 287525054ef601031d860c7a8b75b1985e91d7430cee7b489b7fb726c06cbe15223c3ebd63cad3fbdf590793d3cb343dbfc0a6890cba89a9cbf6b632541ab6a2
+  metadata.gz: 8a2152503ca81745b8ed0cc467826cd8efd4d8006b8760ed102500f80c3bc88bf946196d03bc3242f87e7db512152147781384be05d891d51fa4aca4928428d2
+  data.tar.gz: 29934b5f3ecf636d047c04b00a83e45ddf54a581476f65b23cfe106f231c9cf399536d42f5b2b194ed96c747c41639999be7009e4521481ae989727b4902e5eb

data/lib/rakie.rb

@@ -1,10 +1,24 @@
 
 module Rakie
-  
+  NAME = "rakie"
+  MODE_DEV = 0
+  MODE_REL = 1
+
+  def self.current_mode
+    @current_mode ||= MODE_REL
+  end
 end
 
 require "rakie/channel"
 require "rakie/event"
+require "rakie/proto"
+require "rakie/http_proto"
+require "rakie/websocket_proto"
 require "rakie/simple_server"
+require "rakie/http_server"
+require "rakie/websocket"
+require "rakie/websocket_server"
 require "rakie/tcp_channel"
 require "rakie/tcp_server_channel"
+require "rakie/log"
+require "rakie/version"

data/lib/rakie/channel.rb

@@ -2,10 +2,13 @@ module Rakie
   class Channel
     attr_accessor :delegate
 
+    DEFAULT_BUFFER_SIZE = 512 * 1024
+
     def initialize(io, delegate=nil)
       @io = io
       @read_buffer = String.new
       @write_buffer = String.new
+      @write_task = []
       @delegate = delegate
       Event.push(io, self, Event::READ_EVENT)
     end
@@ -13,25 +16,28 @@ module Rakie
     def on_read(io)
       begin
         loop do
-          @read_buffer << io.read_nonblock(4096)
+          @read_buffer << io.read_nonblock(DEFAULT_BUFFER_SIZE)
         end
 
       rescue IO::EAGAINWaitReadable
-        puts("Channel read finished")
+        Log.debug("Channel read pending")
 
-      rescue
+      rescue IO::EWOULDBLOCKWaitReadable
+        Log.debug("Channel read pending")
+
+      rescue Exception => e
         # 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}")
+        Log.debug("Channel error #{io}: #{e}")
         return Event::HANDLE_FAILED
       end
 
-      puts("Channel has delegate?: #{@delegate}")
       if @delegate != nil
+        Log.debug("Channel handle on_recv")
         len = @delegate.on_recv(self, @read_buffer)
 
         if len > @read_buffer.length
@@ -39,40 +45,77 @@ module Rakie
         end
 
         @read_buffer = @read_buffer[len .. -1]
-        puts("Channel handle on_recv")
       end
 
       return Event::HANDLE_CONTINUED
     end
 
+    def handle_write(len)
+      task = @write_task[0]
+
+      while len > 0
+        if len < task
+          @write_task[0] = task - len
+        end
+
+        len -= task
+        @write_task.shift
+
+        if @delegate != nil
+          @delegate.on_send(self)
+           Log.debug("Channel handle on_send")
+        end
+      end
+    end
+
     def on_write(io)
+      len = 0
+      offset = 0
+
       begin
         while @write_buffer.length > 0
           len = io.write_nonblock(@write_buffer)
+          offset += len
           @write_buffer = @write_buffer[len .. -1]
         end
 
-        puts("Channel write finished")
+        Log.debug("Channel write finished")
 
       rescue IO::EAGAINWaitWritable
-        puts("Channel write continue")
+        self.handle_write(offset)
+
+        Log.debug("Channel write pending")
+        return Event::HANDLE_CONTINUED
+
+      rescue IO::EWOULDBLOCKWaitWritable
+        self.handle_write(offset)
+
+        Log.debug("Channel write pending")
         return Event::HANDLE_CONTINUED
 
       rescue
-        puts("Channel close #{io}")
+        Log.debug("Channel close #{io}")
         return Event::HANDLE_FAILED
       end
 
+      self.handle_write(offset)
+
       return Event::HANDLE_FINISHED
     end
 
-    def on_close(io)
+    def on_detach(io)
       begin
         io.close
 
+        if @delegate
+          @delegate.on_close(self)
+        end
+
       rescue
-        puts("Channel is already closed")
+        Log.debug("Channel is already closed")
       end
+
+      Log.debug("Channel close ok")
     end
 
     def read(size)
@@ -96,7 +139,9 @@ module Rakie
       end
 
       @write_buffer << data
-      Event.modify(@io, self, Event::READ_EVENT | Event::WRITE_EVENT)
+      @write_task << data.length
+
+      Event.modify(@io, self, (Event::READ_EVENT | Event::WRITE_EVENT))
 
       return 0
     end

data/lib/rakie/event.rb

@@ -9,6 +9,10 @@ module Rakie
     HANDLE_CONTINUED = 0
     HANDLE_FINISHED = 1
 
+    OPERATION_ADD = 0
+    OPERATION_MODIFY = 1
+    OPERATION_DELETE = 2
+
     def initialize
       @wait_ios = []
       @lock = Mutex.new
@@ -24,36 +28,39 @@ module Rakie
     
     def process_signal(io)
       signal = io.read(1)
-      puts("Event handling #{signal}")
 
-      if signal == 'a'
-        new_io, new_handler, new_event = @wait_ios.shift
+      if signal == 'q'
+        return 1
+      end
+
+      operation, new_io, new_handler, new_event = @wait_ios.shift
+      if new_io.closed?
+        return 0
+      end
+
+      Log.debug("Event handling #{signal} with #{new_io.fileno} to #{new_event}")
+
+      if operation == OPERATION_ADD
         @ios[new_io] = new_event
         @handlers[new_io] = new_handler
-        puts("Event add all #{new_io} to #{new_event}")
+        Log.debug("Event add all #{new_io.fileno} to #{new_event}")
 
-      elsif signal == 'd'
-        new_io, = @wait_ios.shift
+      elsif operation == OPERATION_DELETE
         handler = @handlers[new_io]
 
         if handler != nil
-          handler.on_close(new_io)
-          puts("Event close #{new_io}")
+          Log.debug("Event close #{new_io}")
+          handler.on_detach(new_io)
         end
 
         @ios.delete(new_io)
         @handlers.delete(new_io)
+        Log.debug("Event remove all #{new_io}")
 
-        puts("Event remove all #{new_io}")
-
-      elsif signal == 'm'
-        new_io, new_handler, new_event = @wait_ios.shift
+      elsif operation == OPERATION_MODIFY
         @ios[new_io] = new_event
         @handlers[new_io] = new_handler
-        puts("Event modify all #{new_io} to #{new_event}")
-
-      elsif signal == 'q'
-        return 1
+        Log.debug("Event modify all #{new_io.fileno} to #{new_event}")
       end
 
       return 0
@@ -61,9 +68,18 @@ module Rakie
 
     def run_loop
       loop do
+        # p @ios
+        # begin
+        #   read_ios = @ios.select {|k, v| v & READ_EVENT > 0}
+        #   write_ios = @ios.select {|k, v| v & WRITE_EVENT > 0}
+        # rescue Exception => e
+        #   p @ios
+        # end
+
         read_ios = @ios.select {|k, v| v & READ_EVENT > 0}
         write_ios = @ios.select {|k, v| v & WRITE_EVENT > 0}
 
+        # Log.debug("Event selecting ...")
         read_ready, write_ready = IO.select(read_ios.keys, write_ios.keys, [], 5)
 
         if read_ready != nil
@@ -89,16 +105,16 @@ module Rakie
             result = handler.on_read(io)
 
             if result == HANDLE_FINISHED
-              @ios[io] = @ios[io] & ~READ_EVENT
-              puts("Event remove read #{io}")
+              @ios[io] &= ~READ_EVENT
+              Log.debug("Event remove read #{io}")
 
             elsif result == HANDLE_FAILED
-              handler.on_close(io)
-              puts("Event close #{io}")
+              handler.on_detach(io)
+              Log.debug("Event close #{io}")
 
               @ios.delete(io)
               @handlers.delete(io)
-              puts("Event remove all #{io}")
+              Log.debug("Event remove all #{io}")
             end
           end
         end
@@ -114,16 +130,16 @@ module Rakie
             result = handler.on_write(io)
 
             if result == HANDLE_FINISHED
-              @ios[io] = @ios[io] & ~WRITE_EVENT
-              puts("Event remove write #{io}")
+              @ios[io] &= ~WRITE_EVENT
+              Log.debug("Event remove write #{io}")
 
             elsif result == HANDLE_FAILED
-              handler.on_close(io)
-              puts("Event close #{io}")
+              handler.on_detach(io)
+              Log.debug("Event close #{io}")
 
               @ios.delete(io)
               @handlers.delete(io)
-              puts("Event remove all #{io}")
+              Log.debug("Event remove all #{io}")
             end
           end
         end
@@ -132,39 +148,58 @@ module Rakie
 
     def push(io, handler, event)
       @lock.lock
-      @wait_ios.push([io, handler, event])
+      @wait_ios.push([OPERATION_ADD, 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')
+      @wait_ios.push([OPERATION_DELETE, io, nil, nil])
+      @signal_out.write('a')
       @lock.unlock
     end
 
     def modify(io, handler, event)
       @lock.lock
-      @wait_ios.push([io, handler, event])
-      @signal_out.write('m')
+      @wait_ios.push([OPERATION_MODIFY, io, handler, event])
+      @signal_out.write('a')
       @lock.unlock
     end
 
     def self.instance
-      @instance ||= Event.new
+      @instance ||= Array.new(self.concurrent) { |i| Event.new }
     end
 
     def self.push(io, listener, type)
-      self.instance.push(io, listener, type)
+      i = io.fileno % self.concurrent
+      inst = self.instance[i]
+      inst.push(io, listener, type)
+      # instance.push(io, listener, type)
     end
 
     def self.delete(io)
-      self.instance.delete(io)
+      i = io.fileno % self.concurrent
+      inst = self.instance[i]
+      inst.delete(io)
+      # self.instance.delete(io)
     end
 
     def self.modify(io, listener, type)
-      self.instance.modify(io, listener, type)
+      i = io.fileno % self.concurrent
+      inst = self.instance[i]
+      inst.modify(io, listener, type)
+      # self.instance.modify(io, listener, type)
+    end
+
+    # @return [Integer]
+    def self.concurrent
+      @concurrent ||= 2
+    end
+
+    # @param [Integer] count
+    def self.concurrent=(count)
+      @concurrent = count
     end
   end
 end

data/lib/rakie/http.rb

@@ -0,0 +1,5 @@
+module Rakie
+  class Http
+    
+  end
+end

data/lib/rakie/http_proto.rb

@@ -0,0 +1,197 @@
+module Rakie
+  class HttpMIME
+    TEXT = "text/plain"
+    HTML = "text/html"
+    JSON = "application/json"
+  end
+
+  class HttpRequest
+    include Proto
+
+    attr_accessor :head, :headers, :content
+
+    PARSE_HEAD = PARSE_BEGIN
+    PARSE_HEADERS = 1
+    PARSE_CONTENT = 2
+
+    class Head
+      attr_accessor :method, :path, :version
+
+      def initialize
+        @method = 'HEAD'
+        @path = '/'
+        @version = 'HTTP/1.1'
+      end
+    end
+
+    def initialize
+      @head = Head.new
+      @headers = {}
+      @content = ''
+    end
+
+    # @param [String] source
+    def parse_source_head(source)
+      offset = parse_offset
+
+      if eol_offset = source.index("\r\n")
+        head_s = source[0 .. eol_offset]
+        head_method, head_path, head_version = head_s.split(' ')
+
+        head.method = head_method
+        head.path = head_path
+        head.version = head_version
+
+        self.parse_state = PARSE_HEADERS
+        self.parse_offset = offset + 2
+
+        Log.debug("Rakie::HttpRequest parse source head ok")
+        return ParseStatus::CONTINUE
+      end
+
+      return ParseStatus::PENDING
+    end
+
+    def parse_source_header_item(header)
+      if semi_offset = header.index(':')
+        return [
+          header[0 .. (semi_offset - 1)].downcase,
+          header[(semi_offset + 1) .. -1].strip
+        ]
+      end
+      
+      return nil
+    end
+
+    # @param [String] source
+    def parse_source_headers(source)
+      offset = parse_offset
+
+      while eol_offset = source.index("\r\n", offset)
+        header = source[offset .. (eol_offset - 1)]
+
+        if header.length == 0
+          self.parse_state = PARSE_CONTENT
+          self.parse_offset = eol_offset + 2
+
+          Log.debug("Rakie::HttpRequest parse source header done")
+          return ParseStatus::CONTINUE
+        end
+
+        header_key, header_value = self.parse_source_header_item(header)
+
+        if header_key
+          headers[header_key] = header_value
+          Log.debug("Rakie::HttpRequest parse source #{header_key}, #{header_value} header ok")
+        end
+
+        offset = eol_offset + 2
+      end
+
+      self.parse_offset = offset
+
+      return ParseStatus::PENDING
+    end
+
+    # @param [String] source
+    def parse_source_content(source)
+      len = headers["content-length"]
+      offset = parse_offset
+
+      if len == nil
+        return ParseStatus::COMPLETE
+      end
+
+      len = len.to_i
+
+      if source.length >= len + offset
+        self.content = source[offset .. (offset + len - 1)]
+        self.parse_state = PARSE_HEAD
+        self.parse_offset = offset + len
+
+        Log.debug("Rakie::HttpRequest parse source content ok")
+        return ParseStatus::COMPLETE
+      end
+
+      return ParseStatus::PENDING
+    end
+
+    # @param [String] source
+    # @return [Integer]
+    def deserialize(source)
+      current_state = parse_state
+
+      case current_state
+      when PARSE_HEAD
+        return parse_source_head(source)
+
+      when PARSE_HEADERS
+        return parse_source_headers(source)
+
+      when PARSE_CONTENT
+        return parse_source_content(source)
+      end
+    end
+
+    # @return [String]
+    def serialize
+      data = ""
+
+      data += "#{head.method} #{head.path} #{head.version}"
+      data += "\r\n"
+
+      headers_list = []
+      headers.each do |k, v|
+        headers_list << "#{k}: #{v}"
+      end
+
+      data += headers_list.join("\r\n")
+      data += "\r\n\r\n"
+
+      data += content
+    end
+  end
+
+  class HttpResponse
+    include Proto
+
+    PARSE_HEAD = 0
+    PARSE_HEADERS = 1
+    PARSE_CONTENT = 2
+
+    attr_accessor :head, :headers, :content
+
+    class Head
+      attr_accessor :version, :status, :message
+
+      def initialize
+        @version = 'HTTP/1.1'
+        @status = 200
+        @message = 'OK'
+      end
+    end
+
+    def initialize
+      @head = Head.new
+      @headers = {}
+      @content = ''
+    end
+
+    def serialize
+      data = ""
+
+      data += "#{head.version} #{head.status} #{head.message}"
+      data += "\r\n"
+
+      headers_list = []
+      headers.each do |k, v|
+        headers_list << "#{k}: #{v}"
+      end
+
+      data += headers_list.join("\r\n")
+      data += "\r\n\r\n"
+
+      data += content
+    end
+  end
+end