rakie 0.0.3 → 0.0.5

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8361c3cfc878d6edc052170cc5fbc5f555d173562c7325d9a939c567402e8b4f
-  data.tar.gz: cc2f7fa419c2fcb750ec70305b942336974cd7e35ad336edc38436027f74e6dd
+  metadata.gz: 754086391c9ec9e2eb623d8d6a1ead9ca9188d49fb0c391b26c4a9e36db88236
+  data.tar.gz: 6ac34e0868c8bc1748e7f572266b4223a91f676d9d7c11b22fa5a7e10586713c
 SHA512:
-  metadata.gz: 1b39af452c4d98899dd787a38ce1394b1781eaee28ab3761b46b824ec4b426f76c27d451da8ae1fb01545676dd572a19f9c9dae09839221a17a5ee807a151f72
-  data.tar.gz: c7953919abc5572b8fba09a5afdf5e32034c0bc2e4fdbca4f649f67f9ec635a10cf49888a194ce67f17afda0424becd1e42467cd9b73e2a990670fd29e2c2c50
+  metadata.gz: 839acbd5155b745948a6144a37480b770e50f01ff4daf29146e39c8fb2e36cf0f434f10313577d3f7b1efcfd039317b036d9c87f96d6c57d09a25c9da6ba5e10
+  data.tar.gz: a844de019fa10103c96e7cc7ab4f7e78ffb2cd5a7c23b28be6483c35fbb7a5cfd1b51f4a1996fa053fa33e03d701af52682c0af306d92b3f2c2c98878aa7c4c6

data/lib/rakie.rb

@@ -1,12 +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,6 +2,8 @@ module Rakie
   class Channel
     attr_accessor :delegate
 
+    DEFAULT_BUFFER_SIZE = 512 * 1024
+
     def initialize(io, delegate=nil)
       @io = io
       @read_buffer = String.new
@@ -14,7 +16,7 @@ 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
@@ -32,6 +34,7 @@ module Rakie
       end
 
       if @delegate != nil
+        Log.debug("Channel handle on_recv")
         len = @delegate.on_recv(self, @read_buffer)
 
         if len > @read_buffer.length
@@ -39,7 +42,6 @@ module Rakie
         end
 
         @read_buffer = @read_buffer[len .. -1]
-        Log.debug("Channel handle on_recv")
       end
 
       return Event::HANDLE_CONTINUED
@@ -90,10 +92,14 @@ module Rakie
       return Event::HANDLE_FINISHED
     end
 
-    def on_close(io)
+    def on_detach(io)
       begin
         io.close
 
+        if @delegate
+          @delegate.on_close(self)
+        end
+
       rescue
         Log.debug("Channel is already closed")
       end

data/lib/rakie/event.rb

@@ -50,7 +50,7 @@ module Rakie
 
         if handler != nil
           Log.debug("Event close #{new_io}")
-          handler.on_close(new_io)
+          handler.on_detach(new_io)
         end
 
         @ios.delete(new_io)
@@ -105,11 +105,11 @@ module Rakie
             result = handler.on_read(io)
 
             if result == HANDLE_FINISHED
-              @ios[io] = @ios[io] & ~READ_EVENT
+              @ios[io] &= ~READ_EVENT
               Log.debug("Event remove read #{io}")
 
             elsif result == HANDLE_FAILED
-              handler.on_close(io)
+              handler.on_detach(io)
               Log.debug("Event close #{io}")
 
               @ios.delete(io)
@@ -130,11 +130,11 @@ module Rakie
             result = handler.on_write(io)
 
             if result == HANDLE_FINISHED
-              @ios[io] = @ios[io] & ~WRITE_EVENT
+              @ios[io] &= ~WRITE_EVENT
               Log.debug("Event remove write #{io}")
 
             elsif result == HANDLE_FAILED
-              handler.on_close(io)
+              handler.on_detach(io)
               Log.debug("Event close #{io}")
 
               @ios.delete(io)
@@ -168,19 +168,38 @@ module Rakie
     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

data/lib/rakie/http_server.rb

@@ -0,0 +1,127 @@
+module Rakie
+  class HttpServer
+    class Session
+      # @return [HttpRequest]
+      attr_accessor :request
+
+      # @type [Array<HttpResponse>]
+      attr_accessor :responses
+
+      def initialize
+        @request = HttpRequest.new
+        @responses = []
+      end
+    end
+
+    attr_reader :channel, :opt
+
+    def initialize(delegate=nil)
+      @channel = TCPServerChannel.new('127.0.0.1', 10086, self)
+
+      # @type [Hash{Channel=>Session}]
+      @sessions = {}
+      @delegate = delegate
+      @opt = {}
+    end
+
+    def on_accept(channel)
+      channel.delegate = self
+      @sessions[channel] = Session.new
+      Log.debug("Rakie::HTTPServer accept client: #{channel}")
+    end
+
+    def on_recv(channel, data)
+      # Log.debug("Rakie::HTTPServer recv: #{data}")
+      session = @sessions[channel]
+
+      if session == nil
+        return 0
+      end
+
+      # @type [HttpRequest] request
+      request = session.request
+
+      if request.parse_status == ParseStatus::COMPLETE
+        request = HttpRequest.new
+        session.request = request
+      end
+
+      len = request.parse(data)
+
+      Log.debug("Rakie::HttpServer receive request: #{request.to_s}")
+
+      if request.parse_status == ParseStatus::COMPLETE
+        response = HttpResponse.new
+
+        if upgrade = request.headers["upgrade"]
+          if websocket_delegate = @opt[:websocket_delegate]
+            websocket_delegate.upgrade(request, response)
+            Log.debug("Rakie::HttpServer upgrade protocol")
+          end
+
+        elsif @delegate != nil
+          @delegate.handle(request, response)
+
+        else
+          response.headers["content-type"] = HttpMIME::HTML
+          response.content = "<html><body><h1>Rakie!</h1></body></html>"
+        end
+        
+        if header_connection = request.headers["connection"]
+          response.headers["connection"] = header_connection
+        end
+
+        if response.content.length > 0
+          response.headers["content-length"] = response.content.length
+        end
+
+        response.headers["server"] = Rakie.full_version_s
+        session.responses << response
+        response_data = response.to_s
+
+        Log.debug("Rakie::HttpServer response: #{response_data}")
+
+        channel.write(response_data) # Response data
+
+      elsif request.parse_status == ParseStatus::ERROR
+        channel.close
+        @sessions.delete(channel)
+
+        Log.debug("Rakie::HttpServer: Illegal request")
+        return len
+      end
+
+      return len
+    end
+
+    def on_send(channel)
+      session = @sessions[channel]
+      # @type [HttpRequest]
+      last_response = session.responses.shift
+
+      if last_response
+        if connect_status = last_response.headers["connection"]
+          if connect_status.downcase == "close"
+            Log.debug("Rakie::HttpServer: send finish and close channel")
+            channel.close
+            @sessions.delete(channel)
+          end
+        end
+
+        if upgrade = last_response.headers["upgrade"]
+          websocket_delegate = @opt[:websocket_delegate]
+
+          if websocket_delegate
+            websocket_delegate.on_accept(channel)
+            @sessions.delete(channel)
+            return
+          end
+
+          Log.debug("Rakie::HttpServer: no websocket delegate and close channel")
+          channel.close
+          @sessions.delete(channel)
+        end
+      end
+    end
+  end
+end

data/lib/rakie/log.rb

@@ -0,0 +1,96 @@
+module Rakie
+  class Log
+    attr_accessor :out, :level
+
+    @instance = nil
+
+    LEVEL_INFO = 0
+    LEVEL_ERROR = 1
+    LEVEL_DEBUG = 2
+
+    def initialize
+      @level = Rakie.current_mode == Rakie::MODE_DEV ? LEVEL_DEBUG : LEVEL_ERROR
+      @out = STDOUT
+    end
+
+    def level_text(level=nil)
+      unless level
+        level = @level
+      end
+
+      case level
+      when LEVEL_INFO
+        return "INFO"
+
+      when LEVEL_ERROR
+        return "ERROR"
+
+      when LEVEL_DEBUG
+        return "DEBUG"
+      end
+    end
+
+    def level_info?
+      @level >= LEVEL_INFO
+    end
+
+    def level_error?
+      @level >= LEVEL_ERROR
+    end
+
+    def level_debug?
+      @level >= LEVEL_DEBUG
+    end
+
+    def self.instance
+      @instance ||= Log.new
+    end
+
+    def self.info(message, who=nil)
+      unless self.instance.level_info?
+        return
+      end
+
+      if who
+        message = "#{who}: #{message}"
+      end
+
+      level = self.instance.level_text(LEVEL_INFO)
+      self.instance.out.write("[#{Time.now.to_s}][#{level}] #{message}\n")
+    end
+
+    def self.error(message, who=nil)
+      unless self.instance.level_error?
+        return
+      end
+
+      if who
+        message = "#{who}: #{message}"
+      end
+
+      level = self.instance.level_text(LEVEL_ERROR)
+      self.instance.out.write("[#{Time.now.to_s}][#{level}] #{message}\n")
+    end
+
+    def self.debug(message, who=nil)
+      unless self.instance.level_debug?
+        return
+      end
+
+      if who
+        message = "#{who}: #{message}"
+      end
+
+      level = self.instance.level_text(LEVEL_DEBUG)
+      self.instance.out.print("[#{Time.now.to_s}][#{level}] #{message}\n")
+    end
+
+    def self.level
+      self.instance.level
+    end
+
+    def self.level=(level)
+      self.instance.level = level
+    end
+  end
+end

data/lib/rakie/proto.rb

@@ -0,0 +1,63 @@
+module Rakie
+  class ParseStatus
+    ERROR = -1
+    CONTINUE = 0
+    PENDING = 1
+    COMPLETE = 2
+  end
+
+  module Proto
+    PARSE_BEGIN = 0
+
+    # @return [Integer]
+    def parse_status
+      @parse_status ||= ParseStatus::CONTINUE
+    end
+
+    # @return [Integer]
+    def parse_state
+      @parse_state ||= PARSE_BEGIN
+    end
+
+    # @param [Integer] state
+    def parse_state=(state)
+      @parse_state = state
+      # puts("Set state: #{@parse_state}")
+    end
+
+    # @return [Integer]
+    def parse_offset
+      @parse_offset ||= 0
+    end
+
+    # @param [Integer] offset
+    def parse_offset=(offset)
+      @parse_offset = offset
+    end
+
+    # @param [String] source
+    def parse(source)
+      status = ParseStatus::CONTINUE
+      
+      while status == ParseStatus::CONTINUE
+        status = self.deserialize(source)
+      end
+
+      if status == ParseStatus::PENDING
+        status = ParseStatus::CONTINUE
+      end
+
+      offset = @parse_offset
+      @parse_status = status
+      @parse_offset = 0
+
+      return offset
+    end
+
+    # @param [Object] object
+    # @return [String]
+    def to_s
+      self.serialize
+    end
+  end
+end

data/lib/rakie/tcp_channel.rb

@@ -1,8 +1,24 @@
 module Rakie
   class TCPChannel < Channel
-    def initialize(ip, port, delegate=nil)
-      @io = TCPSocket.new(ip, port)
-      super(@io, delegate)
+    LOCAL_HOST = '127.0.0.1'
+
+    # @param host [String]
+    # @param port [Integer]
+    # @param delegate [Object]
+    # @param socket [Socket]
+    # @overload initialize(host, port, delegate)
+    # @overload initialize(host, port)
+    # @overload initialize(host, port, delegate, socket)
+    def initialize(host=LOCAL_HOST, port=3001, delegate=nil, socket=nil)
+      if socket == nil
+        socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
+        socket.connect(Socket.pack_sockaddr_in(port, host))
+      end
+
+      @port = port
+      @host = host
+
+      super(socket, delegate)
     end
   end
 end

data/lib/rakie/tcp_server_channel.rb

@@ -1,25 +1,41 @@
 module Rakie
-  class TCPServerChannel < Channel
-    def initialize(ip, port=nil, delegate=nil)
-      io = nil
+  class TCPServerChannel < TCPChannel
+    # @param host [String]
+    # @param port [Integer]
+    # @param delegate [Object]
+    # @overload initialize(host, port, delegate)
+    # @overload initialize(host, port)
+    # @overload initialize(port)
+    def initialize(host=LOCAL_HOST, port=3001, delegate=nil)
+      socket = nil
       
       if port == nil
-        port = ip
-        io = TCPServer.new(ip)
-
-      else
-        io = TCPServer.new(ip, port)
+        port = host
+        host = LOCAL_HOST
       end
       
+      socket = Socket.new(Socket::AF_INET, Socket::SOCK_STREAM)
+      socket.setsockopt(Socket::SOL_SOCKET, Socket::SO_REUSEADDR, 1)
+      socket.bind(Socket.pack_sockaddr_in(port, host))
+      socket.listen(255)
+
       @clients = []
 
-      super(io, delegate)
+      super(host, port, delegate, socket)
     end
 
+    # @param io [Socket]
     def on_read(io)
       begin
-        client_io, = io.accept_nonblock
-        channel = Channel.new(client_io)
+        ret = io.accept_nonblock
+        # @type client_io [Socket]
+        client_io = ret[0]
+        # @type client_info [Addrinfo]
+        client_info = ret[1]
+        client_name_info = client_info.getnameinfo
+        client_host = client_name_info[0]
+        client_port = client_name_info[1]
+        channel = TCPChannel.new(client_host, client_port, nil, client_io)
 
         if @delegate != nil
           Log.debug("TCPServerChannel has delegate")

data/lib/rakie/version.rb

@@ -0,0 +1,11 @@
+module Rakie
+  VERSION = [0, 0, 5]
+
+  def self.version_s
+    VERSION.join('.')
+  end
+
+  def self.full_version_s
+    "#{NAME} v#{self.version_s}"
+  end
+end

data/lib/rakie/websocket.rb

@@ -0,0 +1,137 @@
+module Rakie
+  class Websocket
+    attr_accessor :delegate, :client_side
+    attr_reader :channel
+
+    # @param [Rakie::TCPChannel] channel
+    def initialize(delegate=nil, channel=nil)
+      @delegate = delegate
+
+      if channel == nil
+        channel = TCPChannel.new('127.0.0.1', 10086, self)        
+      end
+
+      @channel = channel
+
+      # @type [WebsocketMessage]
+      @recv_message = WebsocketMessage.new
+
+      # @type [Array<WebsocketMessage>]
+      @send_messages = []
+      @client_side = true
+    end
+
+    def on_recv(channel, data)
+      # Log.debug("Rakie::HTTPServer recv: #{data}")
+
+      # @type [WebsocketMessage] request
+      message = @recv_message
+
+      if message.parse_status == ParseStatus::COMPLETE
+        message = WebsocketMessage.new
+        @recv_message = message
+      end
+
+      len = message.parse(data)
+
+      Log.debug("Rakie::Websocket receive message: #{message.to_s}")
+
+      if message.parse_status == ParseStatus::COMPLETE
+        response = WebsocketMessage.new
+
+        if message.op_code == WebsocketMessage::OP_PING
+          response.fin = true
+          response.op_code = WebsocketMessage::OP_PONG
+          response.payload = "pong"
+
+        elsif message.op_code == WebsocketMessage::OP_PONG
+          response.fin = true
+          response.op_code = WebsocketMessage::OP_PING
+          response.payload = "ping"
+
+        elsif @delegate
+          @delegate.on_message(self, message.payload)
+          return len
+
+        else
+          response.fin = true
+          response.op_code = WebsocketMessage::OP_TEXT
+          response.payload = "Rakie!"
+        end
+        
+        response_data = response.to_s
+
+        Log.debug("Rakie::Websocket response: #{response_data}")
+
+        channel.write(response_data) # Response data
+
+      elsif message.parse_status == ParseStatus::ERROR
+        channel.close
+
+        Log.debug("Rakie::Websocket: Illegal message")
+        return len
+      end
+
+      return len
+    end
+
+    def on_send(channel)
+      # @type [WebsocketMessage]
+      last_message = @send_messages.shift
+
+      if last_message
+        if last_message.op_code == WebsocketMessage::OP_CLOSE
+          Log.debug("Rakie::Websocket: send finish and close channel")
+          channel.close
+        end
+      end
+    end
+
+    def on_close(channel)
+      if @delegate
+        @delegate.on_disconnect(self)
+      end
+    end
+
+    def send(message, is_binary=false)
+      ws_message = WebsocketMessage.new
+      ws_message.fin = true
+      ws_message.op_code = WebsocketMessage::OP_TEXT
+      ws_message.payload = message
+
+      if is_binary
+        ws_message.op_code = WebsocketMessage::OP_BIN
+      end
+
+      if @client_side
+        ws_message.mask = true
+        ws_message.refresh_masking
+      end
+
+      send_message = ws_message.to_s
+
+      Log.debug("Rakie::Websocket send: #{send_message}")
+
+      @channel.write(send_message) # Response data
+    end
+
+    def close
+      ws_message = WebsocketMessage.new
+      ws_message.fin = true
+      ws_message.op_code = WebsocketMessage::OP_CLOSE
+
+      if @client_side
+        ws_message.mask = true
+        ws_message.refresh_masking
+      end
+
+      ws_message.payload = "close"
+
+      send_message = ws_message.to_s
+
+      Log.debug("Rakie::Websocket send close: #{send_message}")
+
+      @channel.write(send_message) # Response data
+    end
+  end
+end

data/lib/rakie/websocket_proto.rb

@@ -0,0 +1,286 @@
+module Rakie
+  class WebsocketBasicMessage
+    include Proto
+
+    FLAG_FIN = 1 << 7
+
+    OP_CONTINUE = 0x0
+    OP_TEXT = 0x1
+    OP_BIN = 0x2
+    OP_CLOSE = 0x8
+    OP_PING = 0x9
+    OP_PONG = 0xA
+
+    FLAG_MASK = 1 << 7
+
+    PARSE_OPERATION = PARSE_BEGIN
+    PARSE_LEN = 1
+    PARSE_EXT_LEN = 2
+    PARSE_MASKING = 3
+    PARSE_PAYLOAD = 4
+
+    attr_accessor :op_code, :mask, :length, :payload
+    attr_writer :fin
+
+    def initialize
+      @fin = false
+      @op_code = 0x0
+      @mask = false
+      @masking = []
+      @length = 0
+      @long_ext = false
+      @payload = ''
+    end
+
+    def fin?
+      @fin
+    end
+
+    # @param [String] source
+    def deserialize(source)
+      current_state = parse_state
+
+      case current_state
+      when PARSE_OPERATION
+        return parse_source_operation(source)
+
+      when PARSE_LEN
+        return parse_source_len(source)
+
+      when PARSE_EXT_LEN
+        return parse_source_ext_len(source)
+
+      when PARSE_MASKING
+        return parse_source_masking(source)
+
+      when PARSE_PAYLOAD
+        return parse_source_payload(source)
+      end
+    end
+
+    def serialize
+      data = ''
+
+      data += pack_source_operation
+      data += pack_source_len
+
+      if @mask
+        data += pack_source_masking
+        data += pack_source_masked_payload
+
+        return data
+      end
+
+      data += @payload
+
+      return data
+    end
+  end
+  
+  class WebsocketMessage < WebsocketBasicMessage
+    # @param [String] source
+    def parse_source_operation(source)
+      offset = parse_offset
+
+      if source.length >= 1 + offset
+        byte = source[offset]
+        data = byte.unpack('C')[0]
+
+        if data & FLAG_FIN > 0
+          @fin = true
+        end
+
+        i = 3
+        code = 0x0
+
+        while i >= 0
+          code |= data & (1 << i)
+          i -= 1
+        end
+
+        @op_code = code
+
+        self.parse_state = PARSE_LEN
+        self.parse_offset = offset + 1
+
+        Log.debug("Rakie::WebsocketMessage parse source operation ok")
+        return ParseStatus::CONTINUE
+      end
+
+      return ParseStatus::PENDING
+    end
+
+    # @param [String] source
+    def parse_source_len(source)
+      offset = parse_offset
+
+      if source.length >= 1 + offset
+        byte = source[offset]
+        data = byte.unpack('C')[0]
+
+        if data & FLAG_MASK > 0
+          @mask = true
+        end
+
+        len = data & ~FLAG_MASK
+
+        Log.debug("Rakie::WebsocketMessage len: #{len}")
+
+        if len <= 125
+          @length = len
+
+          if @mask
+            self.parse_state = PARSE_MASKING
+            self.parse_offset = offset + 1
+
+            Log.debug("Rakie::WebsocketMessage parse source len ok")
+            return ParseStatus::CONTINUE
+          end
+
+          self.parse_state = PARSE_PAYLOAD
+          self.parse_offset = offset + 1
+
+          Log.debug("Rakie::WebsocketMessage parse source len ok")
+          return ParseStatus::CONTINUE
+        end
+
+        if len == 127
+          @long_ext = true
+        end
+
+        self.parse_state = PARSE_EXT_LEN
+        self.parse_offset = offset + 1
+
+        Log.debug("Rakie::WebsocketMessage parse source len ok")
+        return ParseStatus::CONTINUE
+      end
+
+      return ParseStatus::PENDING
+    end
+
+    # @param [String] source
+    def parse_source_ext_len(source)
+      offset = parse_offset
+      ext_len_size = 2
+      byte_format = 'S'
+
+      if @long_ext
+        ext_len_size = 8
+        byte_format = 'Q'
+      end
+
+      if source.length >= ext_len_size + offset
+        bytes = source[offset .. (offset + ext_len_size - 1)]
+        @length = bytes.unpack(byte_format + '>')[0]
+
+        if @mask
+          self.parse_state = PARSE_MASKING
+          self.parse_offset = offset + ext_len_size
+
+          Log.debug("Rakie::WebsocketMessage parse source ext len ok")
+          return ParseStatus::CONTINUE
+        end
+
+        self.parse_state = PARSE_PAYLOAD
+        self.parse_offset = offset + ext_len_size
+
+        Log.debug("Rakie::WebsocketMessage parse source ext len ok")
+        return ParseStatus::CONTINUE
+      end
+
+      return ParseStatus::PENDING
+    end
+
+    # @param [String] source
+    def parse_source_masking(source)
+      offset = parse_offset
+
+      if source.length >= 4 + offset
+        bytes = source[offset .. (offset + 4 - 1)]
+        @masking = bytes.unpack('C*')
+
+        self.parse_state = PARSE_PAYLOAD
+        self.parse_offset = offset + 4
+
+        Log.debug("Rakie::WebsocketMessage parse source masking ok")
+        return ParseStatus::CONTINUE
+      end
+
+      return ParseStatus::PENDING
+    end
+
+    # @param [String] source
+    def parse_source_payload(source)
+      offset = parse_offset
+
+      if source.length >= @length + offset
+        bytes = source[offset .. (offset + @length - 1)]
+
+        if @mask
+          bytes_list = bytes.unpack('C*')
+          masking = @masking
+          bytes_list_unmasked = bytes_list.map.with_index { |b, i| b ^ masking[i % 4] }
+
+          @payload = bytes_list_unmasked.pack('C*')
+
+          self.parse_state = PARSE_OPERATION
+          self.parse_offset = offset + @length
+
+          Log.debug("Rakie::WebsocketMessage parse source masked payload ok")
+          return ParseStatus::COMPLETE
+        end
+
+        @payload = bytes
+
+        self.parse_state = PARSE_OPERATION
+        self.parse_offset = offset + @length
+
+        Log.debug("Rakie::WebsocketMessage parse source payload ok")
+        return ParseStatus::COMPLETE
+      end
+
+      return ParseStatus::PENDING
+    end
+
+    def pack_source_operation
+      fin_bit = @fin ? 1 : 0
+      return [(fin_bit << 7) + @op_code].pack('C')
+    end
+
+    def pack_source_len
+      mask_bit = @mask ? 1 : 0
+
+      if @payload.length < 126
+        return [(mask_bit << 7) + @payload.length].pack('C')
+
+      elsif @payload.length < 65536
+        return [(mask_bit << 7) + 126, @payload.length].pack('CS>')
+      end
+
+      return [(mask_bit << 7) + 127, @payload.length].pack('CQ>')
+    end
+
+    def pack_source_masking
+      return @masking.pack('C*')
+    end
+
+    def pack_source_masked_payload
+      masking = @masking
+
+      if masking.empty?
+        return ''
+      end
+
+      bytes_list = @payload.unpack('C*')
+      bytes_list_masked = bytes_list.map.with_index { |b, i| b ^ masking[i % 4] }
+      
+      return bytes_list_masked.pack('C*')
+    end
+
+    def refresh_masking
+      masking = []
+      4.times { masking << rand(1 .. 255) }
+      @masking = masking
+    end
+  end
+end

data/lib/rakie/websocket_server.rb

@@ -0,0 +1,83 @@
+module Rakie
+  class WebsocketServer < Websocket
+    # @param [Rakie::HttpServer] http_server
+    def initialize(delegate=nil, http_server=nil)
+      @delegate = delegate
+
+      if http_server == nil
+        http_server = HttpServer.new('127.0.0.1', 10086, self)
+      end
+
+      http_server.opt[:websocket_delegate] = self
+      @channel = http_server.channel
+
+      # @type [Array<WebsocketClient>]
+      @clients = {}
+    end
+
+    def on_accept(channel)
+      ws_client = Websocket.new(@delegate, channel)
+      ws_client.client_side = false
+
+      channel.delegate = self
+
+      if @delegate
+        @delegate.on_connect(ws_client)
+        return
+      end
+
+      @clients[channel] = ws_client
+      Log.debug("Rakie::WebsocketServer accept client: #{ws_client}")
+    end
+
+    # @param [HttpRequest] request
+    # @param [HttpResponse] response
+    # @return bool
+    def upgrade(request, response)
+      if websocket_key = request.headers["sec-websocket-key"]
+        digest_key = Digest::SHA1.base64digest(websocket_key + '258EAFA5-E914-47DA-95CA-C5AB0DC85B11')
+
+        response.head.status = 101
+        response.head.message = 'Switching Protocols'
+        response.headers["connection"] = "upgrade"
+        response.headers["upgrade"] = "websocket"
+        response.headers["sec-websocket-accept"] = digest_key
+      end
+    end
+
+    def on_recv(channel, data)
+      client = @clients[channel]
+
+      if client
+        client.on_recv(channel, data)
+      end
+    end
+
+    def on_send(channel)
+      client = @clients[channel]
+
+      if client
+        client.on_send(channel)
+      end
+    end
+
+    def on_close(channel)
+      client = @clients[channel]
+
+      if client
+        client.on_close(channel)
+      end
+    end
+
+    def send(message, is_binary=false); end
+
+    def close; end
+
+    def clients
+      @clients.values
+    end
+  end
+end
+
+require "digest"
+require "base64"

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rakie
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
 platform: ruby
 authors:
 - Jakit Liang
@@ -20,9 +20,18 @@ files:
 - lib/rakie.rb
 - lib/rakie/channel.rb
 - lib/rakie/event.rb
+- lib/rakie/http.rb
+- lib/rakie/http_proto.rb
+- lib/rakie/http_server.rb
+- lib/rakie/log.rb
+- lib/rakie/proto.rb
 - lib/rakie/simple_server.rb
 - lib/rakie/tcp_channel.rb
 - lib/rakie/tcp_server_channel.rb
+- lib/rakie/version.rb
+- lib/rakie/websocket.rb
+- lib/rakie/websocket_proto.rb
+- lib/rakie/websocket_server.rb
 - test/test_rakie.rb
 homepage: https://github.com/Jakitto/rakie
 licenses: