web_socket_rb 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: eb1f89b03d703f0ccb4d4993b3b291ea198c9ab1
+  data.tar.gz: 55820c722b44c2a238fdea8c859df4804cf9859d
+SHA512:
+  metadata.gz: 8703dd1ab0f52f1c2b58b5360f3a6a32675e761106fd3d99e5a04793a9da18482a751ecc34cf17e1b6ca433ae6886f4c115594b8de28531362208761b11e1a27
+  data.tar.gz: 5ac78d00af0af664721ba5a11c5111aaa34176b386e1b4e41f3f0e8b38436f531ac7eb88eebcc534816af435ed6c22852692bcab37875ee44c032e004cfc9158

data/.gitignore

@@ -0,0 +1,10 @@
+/.bundle/
+/.yardoc
+/Gemfile.lock
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/
+/.idea/

data/.rspec

@@ -0,0 +1,2 @@
+--format documentation
+--color

data/.ruby-gemset

@@ -0,0 +1 @@
+web_socket_rb

data/.ruby-version

@@ -0,0 +1 @@
+ruby-2.2.3

data/.travis.yml

@@ -0,0 +1,4 @@
+language: ruby
+rvm:
+  - 2.2.3
+before_install: gem install bundler -v 1.11.2

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,49 @@
+# Contributor Code of Conduct
+
+As contributors and maintainers of this project, and in the interest of
+fostering an open and welcoming community, we pledge to respect all people who
+contribute through reporting issues, posting feature requests, updating
+documentation, submitting pull requests or patches, and other activities.
+
+We are committed to making participation in this project a harassment-free
+experience for everyone, regardless of level of experience, gender, gender
+identity and expression, sexual orientation, disability, personal appearance,
+body size, race, ethnicity, age, religion, or nationality.
+
+Examples of unacceptable behavior by participants include:
+
+* The use of sexualized language or imagery
+* Personal attacks
+* Trolling or insulting/derogatory comments
+* Public or private harassment
+* Publishing other's private information, such as physical or electronic
+  addresses, without explicit permission
+* Other unethical or unprofessional conduct
+
+Project maintainers have the right and responsibility to remove, edit, or
+reject comments, commits, code, wiki edits, issues, and other contributions
+that are not aligned to this Code of Conduct, or to ban temporarily or
+permanently any contributor for other behaviors that they deem inappropriate,
+threatening, offensive, or harmful.
+
+By adopting this Code of Conduct, project maintainers commit themselves to
+fairly and consistently applying these principles to every aspect of managing
+this project. Project maintainers who do not follow or enforce the Code of
+Conduct may be permanently removed from the project team.
+
+This code of conduct applies both within project spaces and in public spaces
+when an individual is representing the project or its community.
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported by contacting a project maintainer at karol.bajko@rst-it.com. All
+complaints will be reviewed and investigated and will result in a response that
+is deemed necessary and appropriate to the circumstances. Maintainers are
+obligated to maintain confidentiality with regard to the reporter of an
+incident.
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 1.3.0, available at
+[http://contributor-covenant.org/version/1/3/0/][version]
+
+[homepage]: http://contributor-covenant.org
+[version]: http://contributor-covenant.org/version/1/3/0/

data/Gemfile

@@ -0,0 +1,4 @@
+source 'https://rubygems.org'
+
+# Specify your gem's dependencies in web_socket_rb.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2016 Karol Bajko
+
+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,41 @@
+# WebSocketRb
+
+Welcome to your new gem! In this directory, you'll find the files you need to be able to package up your Ruby library into a gem. Put your Ruby code in the file `lib/web_socket_rb`. To experiment with that code, run `bin/console` for an interactive prompt.
+
+TODO: Delete this and the text above, and describe your gem
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'web_socket_rb'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install web_socket_rb
+
+## Usage
+
+TODO: Write usage instructions here
+
+## Development
+
+After checking out the repo, run `bin/setup` to install dependencies. Then, run `rake spec` to run the tests. You can also run `bin/console` for an interactive prompt that will allow you to experiment.
+
+To install this gem onto your local machine, run `bundle exec rake install`. To release a new version, update the version number in `version.rb`, and then run `bundle exec rake release`, which will create a git tag for the version, push git commits and tags, and push the `.gem` file to [rubygems.org](https://rubygems.org).
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/[USERNAME]/web_socket_rb. This project is intended to be a safe, welcoming space for collaboration, and contributors are expected to adhere to the [Contributor Covenant](http://contributor-covenant.org) code of conduct.
+
+
+## License
+
+The gem is available as open source under the terms of the [MIT License](http://opensource.org/licenses/MIT).
+

data/Rakefile

@@ -0,0 +1,6 @@
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+RSpec::Core::RakeTask.new(:spec)
+
+task default: :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'bundler/setup'
+require 'web_socket_rb'
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require 'irb'
+IRB.start

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/examples/client/index.html

@@ -0,0 +1,37 @@
+<html>
+<head>
+	<title>Prosty chat</title>
+  <meta charset="UTF-8">
+  <script src="../../js/websocketrb_client.js"></script>
+  <script language="javascript">
+    // Initiate websocket server connection
+    var websocketServer = new WebSocketRbClient("ws://localhost:9292");
+
+    // New chat message
+    websocketServer.onmessage('chat', function(message){
+      var messagesListDiv = document.getElementById("messages-list");
+      var newHtml = "<p>" + message + "</p>";
+      messagesListDiv.insertAdjacentHTML('beforeend', newHtml);
+    });
+
+    // Outgoing messages
+    function sendMessage() {
+      var messageField = document.getElementById("message");
+      websocketServer.send('chat', messageField.value);
+      messageField.value = '';
+    }
+
+    websocketServer.connect();
+
+  </script>
+</head>
+	<body>
+		<h1>Chat anonimowy</h1>
+		<p>To jest bardzo prosty system do komunikacji</p>
+		<h2>Wiadomości</h2>
+		<input type="text" id="message">
+		<button onclick="sendMessage()">Wyślij wiadomość</button>
+		<div id="messages-list"></div>
+	</body>
+</html>
+

data/examples/server/server.rb

@@ -0,0 +1,26 @@
+require 'web_socket_rb'
+
+WebSocketApp = WebSocketRb::App.new
+
+# Define endpoints
+WebSocketApp.routes do
+  config.port = 9292
+
+  # New connection
+  init_connection do
+    broadcast_message('chat', 'Hello!')
+  end
+
+  # Close some connection
+  close_connection do
+    broadcast_message('chat', 'Good bye')
+  end
+
+  # Listen for every new incoming message
+  subscribe 'chat' do |msg|
+    broadcast_message('chat', msg)
+  end
+end
+
+
+WebSocketApp.run

data/js/websocketrb_client.js

@@ -0,0 +1,43 @@
+/**
+ * Created by Karol Bajko
+ * Client library for WebSocketRb
+ */
+
+var WebSocketRbClient = (function (url, protocols) {
+
+    var url = url;
+    var protocols = protocols;
+    var websocket = null;
+    var callbacks = {};
+
+    this.send = function (destination, message) {
+        websocket.send(JSON.stringify({destination: destination, message: message}));
+        return this;
+    };
+
+    this.close = function (code, reason) {
+        websocket.close(code, reason);
+        return this;
+    };
+
+    this.onmessage = function (destination, callback) {
+        callbacks[destination] = callbacks[destination] || [];
+        callbacks[destination].push(callback)
+    };
+
+    this.connect = function () {
+        websocket = new WebSocket(url, protocols);
+
+        websocket.onmessage = function (event) {
+            var incomingData = JSON.parse(event.data);
+            var destination = incomingData.destination;
+            var message = incomingData.message;
+
+            var chain = callbacks[destination];
+            if (typeof chain == 'undefined') return;
+            for (var i = 0; i < chain.length; i++) {
+                chain[i](message)
+            }
+        }
+    }
+});

data/lib/web_socket_rb.rb

@@ -0,0 +1,27 @@
+require 'web_socket_rb/version'
+require 'web_socket_rb/server'
+require 'web_socket_rb/routes'
+
+module WebSocketRb
+  class App
+    @logger = Logger.new(STDOUT)
+
+    def initialize
+      @routes = WebSocketRb::Routes.new
+      @server = WebSocketRb::Server.new(@routes)
+    end
+
+    def routes(&block)
+      @routes.instance_eval(&block)
+    end
+
+    # Run WebSocketRb server
+    def run
+      @server.run
+    end
+
+    class << self
+      attr_reader :logger
+    end
+  end
+end

data/lib/web_socket_rb/context/sandbox.rb

@@ -0,0 +1,29 @@
+require 'web_socket_rb/service/build_text_frame_service'
+
+# This class provides methods available inside of blocks executed in routes
+module WebSocketRb
+  module Context
+    class Sandbox
+      def initialize(frames_sender)
+        @frames_sender = frames_sender
+      end
+
+      # Method to get count of current connections
+      def connections_size
+        @frames_sender.connections.size
+      end
+
+      # Method to send message to client
+      def send_message(destination, message)
+        frame = Service::BuildTextFrameService.new(destination, message).run
+        @frames_sender.frame_to_send(frame)
+      end
+
+      # Method to broadcast message to all clients
+      def broadcast_message(destination, message)
+        frame = Service::BuildTextFrameService.new(destination, message).run
+        @frames_sender.frame_to_broadcast(frame)
+      end
+    end
+  end
+end

data/lib/web_socket_rb/error/handshake_error.rb

@@ -0,0 +1,17 @@
+module WebSocketRb
+  module Error
+    class HandshakeError < StandardError
+      def initialize(msg)
+        App.logger.error('Handshake') { msg }
+      end
+
+      def messages(conn)
+        conn.puts('HTTP/1.1 400 Bad Request')
+        conn.puts('Upgrade: websocket')
+        conn.puts('Connection: Upgrade')
+        conn.puts('Sec-WebSocket-Version: 13')
+        conn.puts('Sec-WebSocket-Protocol: json')
+      end
+    end
+  end
+end

data/lib/web_socket_rb/error/wrong_frame_error.rb

@@ -0,0 +1,9 @@
+module WebSocketRb
+  module Error
+    class WrongFrameError < StandardError
+      def initialize(msg)
+        App.logger.error('Frame') { msg }
+      end
+    end
+  end
+end

data/lib/web_socket_rb/protocol/frames_handler.rb

@@ -0,0 +1,78 @@
+require 'web_socket_rb/context/sandbox'
+require 'web_socket_rb/service/frames_sender'
+require 'web_socket_rb/service/read_frame_service'
+require 'web_socket_rb/service/build_ping_frame_service'
+require 'web_socket_rb/service/build_pong_frame_service'
+require 'web_socket_rb/service/build_close_frame_service'
+require 'web_socket_rb/error/wrong_frame_error'
+
+module WebSocketRb
+  module Protocol
+    class FramesHandler
+      def initialize(connections, connection, routes, frames_sender, sandbox)
+        @connections = connections
+        @conn          = connection
+        @routes        = routes
+        @frames_sender = frames_sender
+        @sandbox       = sandbox
+        @threads       = []
+      end
+
+      # Run reading and sending frames
+      def run
+        @threads << Thread.new { verify_status }
+        @threads << Thread.new { process_incoming_frames }
+        @threads.each(&:join)
+      end
+
+      private
+
+      # Send PING frame every 10 seconds to verify connection
+      def verify_status
+        loop do
+          frame = Service::BuildPingFrameService.new.run
+          @frames_sender.frame_to_send(frame)
+          sleep(10)
+        end
+      end
+
+      # Read incoming frames
+      def process_incoming_frames
+        loop do
+          frame = Service::ReadFrameService.new(@conn).run
+          process_incoming_frame(frame) unless frame.nil?
+        end
+      end
+
+      # Process incoming frame
+      def process_incoming_frame(frame)
+        if frame.ping?
+
+          # Send PONG frame if requested PING frame
+          App.logger.info('Frames handler') { 'Replying for PING request' }
+          pong_frame = Service::BuildPongFrameService.new(frame).run
+          @frames_sender.frame_to_send(pong_frame)
+
+        elsif frame.close?
+
+          # Send CLOSE frame if requested CLOSE frame
+          App.logger.info('Frames handler') { 'Replying for CLOSE request' }
+          close_frame = Service::BuildCloseFrameService.new(frame).run
+          @frames_sender.frame_to_send(close_frame)
+          @threads.each(&:exit)
+
+        elsif frame.pong?
+          # Do nothing
+        elsif frame.text? || frame.binary?
+
+          # Call subscribe block
+          App.logger.info('Frames handler') { 'Processing frame' }
+          subscribe_block = @routes.subscribes[frame.destination]
+          App.logger.info('Frames handler') { frame.message }
+          Thread.new { @sandbox.instance_exec(frame.message, &subscribe_block) }
+
+        end
+      end
+    end
+  end
+end

data/lib/web_socket_rb/protocol/handshake.rb

@@ -0,0 +1,59 @@
+require 'web_socket_rb/error/handshake_error'
+require 'web_socket_rb/wrapper/handshake_request'
+require 'digest'
+
+module WebSocketRb
+  module Protocol
+    class Handshake
+      MAGIC_KEY = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11'.freeze
+
+      def initialize(conn)
+        @conn = conn
+      end
+
+      # Generate a proper handshake response based on request
+      def run
+        validate_request
+        generate_proper_response
+        @conn
+      end
+
+      private
+
+      # Read incoming data from socket and convert it to handshake request
+      def request
+        @request ||= Wrapper::HandshakeRequest.new(@conn)
+      end
+
+      # Validate incoming request - is it a WebSocket upgrade request?
+      def validate_request
+        App.logger.info('Handshake') { 'Verification started' }
+        raise Error::HandshakeError, 'It is not an upgrade request' unless request.upgrade?
+        App.logger.info('Handshake') { 'Valid upgrade request' }
+        raise Error::HandshakeError, 'Not valid protocol version.' unless request.valid_version?
+        App.logger.info('Handshake') { 'Valid protocol version' }
+        raise Error::HandshakeError, 'Not valid sub-protocol. Only JSON available.' unless request.valid_protocol?
+        App.logger.info('Handshake') { 'Valid sub-protocol request' }
+        App.logger.info('Handshake') { 'Verification passed' }
+      end
+
+      # Generate a proper response based on request
+      def generate_proper_response
+        App.logger.info('Handshake') { 'Send accept response' }
+        @conn.puts('HTTP/1.1 101 Switching Protocols')
+        @conn.puts('Upgrade: websocket')
+        @conn.puts('Connection: Upgrade')
+        @conn.puts("Sec-WebSocket-Accept: #{calculate_key(request.key)}")
+        # @conn.puts("Sec-WebSocket-Protocol: #{Wrapper::HandshakeRequest::PROTOCOL}")
+        @conn.puts('')
+        App.logger.info('Handshake') { 'Finished sending accept response' }
+      end
+
+      # Calculate handshake key
+      def calculate_key(key)
+        raise ArgumentError, 'Key must be a String' unless key.is_a?(String)
+        ::Digest::SHA1.base64digest(key.strip + MAGIC_KEY)
+      end
+    end
+  end
+end

data/lib/web_socket_rb/routes.rb

@@ -0,0 +1,27 @@
+# Class defines methods available in routes section to configure WebSocket server
+module WebSocketRb
+  class Routes
+    attr_reader :config, :subscribes, :init_connection_code, :close_connection_code
+
+    def initialize
+      @subscribes = Hash.new([])
+      @config     = OpenStruct.new(port: '9292')
+    end
+
+    # Define method to subscribe incoming messages
+    def subscribe(name, &block)
+      raise ArgumentError, 'Invalid name' unless name.is_a?(String)
+      @subscribes[name] = block
+    end
+
+    # Execute block of code while initiation new connection
+    def init_connection(&block)
+      @init_connection_code = block
+    end
+
+    # Execute this block of code when connection is closed
+    def close_connection(&block)
+      @close_connection_code = block
+    end
+  end
+end

data/lib/web_socket_rb/server.rb

@@ -0,0 +1,47 @@
+require 'web_socket_rb/protocol/handshake'
+require 'web_socket_rb/protocol/frames_handler'
+require 'web_socket_rb/error/handshake_error'
+require 'socket'
+require 'logger'
+
+module WebSocketRb
+  class Server
+    def initialize(routes)
+      @routes      = routes
+      @connections = []
+      @mutex       = Mutex.new
+    end
+
+    # Run each request in separate thread
+    def run
+      hostname = 'localhost'
+      port     = @routes.config.port || 9292
+      @socket  = TCPServer.new(hostname, port)
+      App.logger.info('Server') { "Started '#{hostname}' on port #{port}" }
+      loop do
+        Thread.start(@socket.accept) do |conn|
+          @mutex.synchronize { @connections << conn }
+          App.logger.info('Server') { 'New incoming connection' }
+          begin
+            Protocol::Handshake.new(conn).run
+            @frames_sender = Service::FramesSender.new(@connections, conn)
+            @sandbox       = Context::Sandbox.new(@frames_sender)
+            init_connection_code = @routes.init_connection_code
+            @sandbox.instance_eval(&init_connection_code) if init_connection_code.is_a?(Proc)
+            Protocol::FramesHandler.new(@connections, conn, @routes, @frames_sender, @sandbox).run
+          rescue Error::HandshakeError => e
+            e.messages(conn)
+          rescue => e
+            App.logger.error('Server') { e.message }
+          ensure
+            conn.close
+            @mutex.synchronize { @connections.delete(conn) }
+            close_block = @routes.close_connection_code
+            @sandbox.instance_eval(&close_block) if close_block.is_a?(Proc)
+            App.logger.info('Server') { 'Connection closed' }
+          end
+        end
+      end
+    end
+  end
+end

data/lib/web_socket_rb/service/build_close_frame_service.rb

@@ -0,0 +1,16 @@
+require 'web_socket_rb/wrapper/frame_close'
+
+module WebSocketRb
+  module Service
+    class BuildCloseFrameService
+      def initialize(close_frame)
+        @close_frame = close_frame
+      end
+
+      # Every PONG frame should have
+      def run
+        WebSocketRb::Wrapper::FrameClose.new
+      end
+    end
+  end
+end

data/lib/web_socket_rb/service/build_ping_frame_service.rb

@@ -0,0 +1,11 @@
+require 'web_socket_rb/wrapper/frame_ping'
+
+module WebSocketRb
+  module Service
+    class BuildPingFrameService
+      def run
+        WebSocketRb::Wrapper::FramePing.new
+      end
+    end
+  end
+end

data/lib/web_socket_rb/service/build_pong_frame_service.rb

@@ -0,0 +1,19 @@
+require 'web_socket_rb/wrapper/frame_pong'
+
+# Create PONG frame based of PING request.
+module WebSocketRb
+  module Service
+    class BuildPongFrameService
+      def initialize(ping_frame)
+        @ping_frame = ping_frame
+      end
+
+      # Every PONG frame should have
+      def run
+        pong_frame              = WebSocketRb::Wrapper::FramePong.new
+        pong_frame.payload_data = @ping_frame.payload_data
+        pong_frame
+      end
+    end
+  end
+end

data/lib/web_socket_rb/service/build_text_frame_service.rb

@@ -0,0 +1,17 @@
+require 'web_socket_rb/wrapper/frame_text'
+
+module WebSocketRb
+  module Service
+    class BuildTextFrameService
+      def initialize(destination, message)
+        @destination = destination
+        @message     = message
+      end
+
+      def run
+        payload_data = JSON.generate(destination: @destination, message: @message)
+        WebSocketRb::Wrapper::FrameText.new(payload_data)
+      end
+    end
+  end
+end

data/lib/web_socket_rb/service/frames_sender.rb

@@ -0,0 +1,47 @@
+module WebSocketRb
+  module Service
+    class FramesSender
+      attr_reader :connections
+
+      def initialize(connections, connection)
+        @connections         = connections
+        @connection          = connection
+        @frames_to_send      = []
+        @frames_to_broadcast = []
+        Thread.new do
+          loop do
+            frame = @frames_to_send.shift
+            send_frame(frame) unless frame.nil?
+            frame = @frames_to_broadcast.shift
+            broadcast_frame(frame) unless frame.nil?
+          end
+        end
+      end
+
+      # Method to send frame in current connection
+      def frame_to_send(frame)
+        @frames_to_send << frame
+      end
+
+      # Method to send frame in all connections
+      def frame_to_broadcast(frame)
+        @frames_to_broadcast << frame
+      end
+
+      private
+
+      # Broadcast message through current connection
+      def send_frame(frame)
+        @connection.write(frame.to_bytes)
+        Thread.close if frame.close?
+      end
+
+      # Broadcast message through all connections
+      def broadcast_frame(frame)
+        @connections.each do |conn|
+          conn.write(frame.to_bytes)
+        end
+      end
+    end
+  end
+end

data/lib/web_socket_rb/service/read_frame_service.rb

@@ -0,0 +1,89 @@
+require 'web_socket_rb/wrapper/frame_base'
+
+# Service reads socket and returns readed frame.
+module WebSocketRb
+  module Service
+    class ReadFrameService
+      def initialize(conn)
+        @conn  = conn
+        @frame = WebSocketRb::Wrapper::FrameBase.new
+      end
+
+      # Read socket and return new frame
+      def run
+        # 1st byte
+        read_fin_rsv_opcode
+        # 2nd byte
+        read_mask_payload_len
+        # Optionally: 3rd - 10th byte
+        read_ext_payload_len
+        # Optionally: Masking-key
+        read_masking_key
+        # Payload data
+        read_payload_data
+        # Return frame
+        @frame
+      rescue Error
+        nil
+      end
+
+      private
+
+      def read_fin_rsv_opcode
+        byte = @conn.read(1)
+        raise Error if byte.nil?
+        byte          = byte.unpack('C*').first
+        @frame.fin    = byte & '10000000'.to_i(2) > 0
+        @frame.rsv1   = byte & '01000000'.to_i(2) > 0
+        @frame.rsv2   = byte & '00100000'.to_i(2) > 0
+        @frame.rsv3   = byte & '00010000'.to_i(2) > 0
+        @frame.opcode = byte & '00001111'.to_i(2)
+      end
+
+      def read_mask_payload_len
+        byte = @conn.read(1)
+        raise Error if byte.nil?
+        byte               = byte.unpack('C*').first
+        @frame.mask        = byte & '10000000'.to_i(2) > 0
+        @frame.payload_len = (byte & '01111111'.to_i(2)).to_i
+      end
+
+      def read_ext_payload_len
+        if @frame.payload_len == 126
+          bytes = @conn.read(2)
+          raise Error if bytes.nil?
+          @frame.payload_len = bytes.unpack('S')
+        elsif @frame.payload_len == 127
+          bytes = @conn.read(8)
+          raise Error if bytes.nil?
+          @frame.payload_len = bytes.unpack('Q')
+        end
+      end
+
+      def read_masking_key
+        if @frame.mask
+          bytes = @conn.read(4)
+          raise Error if bytes.nil?
+          @frame.masking_key = bytes.unpack('C*')
+        end
+      end
+
+      def read_payload_data
+        @frame.payload_data = @conn.read(@frame.payload_len)
+        raise Error if @frame.payload_data.nil? && @frame.payload_len > 0
+        @frame.payload_data = @frame.payload_data.unpack('C*').each_slice(4).map do |slice|
+          slice.zip(@frame.masking_key).map { |a, b| a ^ b }
+        end.flatten.pack('C*') if @frame.mask
+      end
+
+      def log_readed_data
+        [:fin, :rsv1, :rsv2, :rsv3, :opcode, :mask, :payload_len, :masking_key, :payload_data].each do |var|
+          App.logger.info('Frame structure') { "#{var}: #{send(var)}" }
+        end
+      end
+
+      class Error < StandardError
+      end
+    end
+  end
+end

data/lib/web_socket_rb/version.rb

@@ -0,0 +1,3 @@
+module WebSocketRb
+  VERSION = '0.1.1'.freeze
+end

data/lib/web_socket_rb/wrapper/frame_base.rb

@@ -0,0 +1,110 @@
+module WebSocketRb
+  module Wrapper
+    # Class defines base frame structure.
+    class FrameBase
+      # Constants represents type of frame
+      CONTINUATION = 0x0.to_i
+      TEXT         = 0x1.to_i
+      BINARY       = 0x2.to_i
+      CLOSE        = 0x8.to_i
+      PING         = 0x9.to_i
+      PONG         = 0xA.to_i
+
+      attr_accessor :fin, :rsv1, :rsv2, :rsv3, :opcode, :mask, :payload_len,
+                    :masking_key, :payload_data
+
+      # Method converts frame to bytes representation.
+      def to_bytes
+        bytes = ''
+        bytes << fin_rsv_opcode_to_byte
+        bytes << mask_payload_length_to_byte
+        bytes << ext_payload_len_to_byte
+        bytes << masking_key_to_byte
+        bytes << payload_data_to_byte
+        bytes
+      end
+
+      # Define methods to verify types of frame
+      [:continuation, :text, :binary, :close, :ping, :pong].each do |constant|
+        define_method "#{constant}?" do
+          opcode.eql?(self.class.const_get(constant.upcase))
+        end
+      end
+
+      # Read destination from payload data
+      def destination
+        json_payload_data = JSON.parse(payload_data)
+        json_payload_data.is_a?(Hash) ? json_payload_data['destination'] : nil
+      end
+
+      # Read message from payload data
+      def message
+        json_payload_data = JSON.parse(payload_data)
+        json_payload_data.is_a?(Hash) ? json_payload_data['message'] : nil
+      end
+
+      protected
+
+      def payload_data_to_byte
+        if mask
+          payload_data.bytes.each_slice(4).map do |slice|
+            slice.zip(masking_key.bytes).map { |a, b| a ^ b }
+          end.flatten.pack('C*')
+        else
+          payload_data.bytes.pack('C*')
+        end
+      end
+
+      def masking_key_to_byte
+        mask && masking_key ? masking_key.bytes.pack('C*') : ''
+      end
+
+      def ext_payload_len_to_byte
+        case payload_len
+        when 0..125
+          ''
+        when 126..65_535
+          [payload_len].pack('S>')
+        when 65_536..18_446_744_073_709_551_615
+          [payload_len].pack('Q>')
+        end
+      end
+
+      def mask_payload_length_to_byte
+        byte = 0
+        byte |= 1 if mask
+        byte <<= 7
+
+        case payload_len
+        when 0..125
+          byte |= payload_len
+        when 126..65_535
+          byte |= 126
+        when 65_536..18_446_744_073_709_551_615
+          byte |= 127
+        end
+
+        byte.chr
+      end
+
+      def fin_rsv_opcode_to_byte
+        byte = 0
+        byte |= 1 if fin
+
+        byte <<= 1
+        byte |= 1 if rsv1
+
+        byte <<= 1
+        byte |= 1 if rsv2
+
+        byte <<= 1
+        byte |= 1 if rsv3
+
+        byte <<= 4
+        byte |= opcode
+
+        byte.chr
+      end
+    end
+  end
+end

data/lib/web_socket_rb/wrapper/frame_close.rb

@@ -0,0 +1,12 @@
+require 'web_socket_rb/wrapper/frame_outgoing'
+
+# Class describes Closing frame
+module WebSocketRb
+  module Wrapper
+    class FrameClose < FrameOutgoing
+      def initialize
+        super(opcode: CLOSE)
+      end
+    end
+  end
+end

data/lib/web_socket_rb/wrapper/frame_outgoing.rb

@@ -0,0 +1,20 @@
+require 'web_socket_rb/wrapper/frame_base'
+
+# Class describes any sends frame. It accepts message
+module WebSocketRb
+  module Wrapper
+    class FrameOutgoing < FrameBase
+      def initialize(options = {})
+        @payload_data = options.fetch(:payload_data, '')
+        @payload_len  = @payload_data.bytes.size
+        @fin          = options.fetch(:fin, true)
+        @rsv1         = options.fetch(:rsv1, false) # No externals (false by default)
+        @rsv2         = options.fetch(:rsv2, false) # No externals (false by default)
+        @rsv3         = options.fetch(:rsv3, false) # No externals (false by default)
+        @opcode       = options.fetch(:opcode, CONTINUATION) # Type of frame (continuation by default)
+        @mask         = options.fetch(:mask, false) # Mask (false by default)
+        @masking_key  = Random.new.bytes(4) if @mask # Generate random masking key if mask
+      end
+    end
+  end
+end

data/lib/web_socket_rb/wrapper/frame_ping.rb

@@ -0,0 +1,13 @@
+require 'web_socket_rb/wrapper/frame_outgoing'
+
+# Class describes Ping frame - to verify connection status.
+module WebSocketRb
+  module Wrapper
+    class FramePing < FrameOutgoing
+      def initialize
+        rand_payload_data = Random.new.bytes(10)
+        super(opcode: PING, payload_data: rand_payload_data)
+      end
+    end
+  end
+end

data/lib/web_socket_rb/wrapper/frame_pong.rb

@@ -0,0 +1,12 @@
+require 'web_socket_rb/wrapper/frame_outgoing'
+
+# Class describes Pong frame - reply to Ping frame
+module WebSocketRb
+  module Wrapper
+    class FramePong < FrameOutgoing
+      def initialize
+        super(opcode: PONG)
+      end
+    end
+  end
+end

data/lib/web_socket_rb/wrapper/frame_text.rb

@@ -0,0 +1,13 @@
+require 'web_socket_rb/wrapper/frame_outgoing'
+require 'json'
+
+# Class describes Closing frame
+module WebSocketRb
+  module Wrapper
+    class FrameText < FrameOutgoing
+      def initialize(payload_data)
+        super(opcode: TEXT, payload_data: payload_data)
+      end
+    end
+  end
+end

data/lib/web_socket_rb/wrapper/handshake_request.rb

@@ -0,0 +1,61 @@
+# Wrapper for request to get.
+# It extracts a proper information from request header, like:
+# - requested path
+# - http protocol version
+# - list of header key-val pairs
+module WebSocketRb
+  module Wrapper
+    class HandshakeRequest
+      HTTP_HEADER = /^GET (\/[[:graph:]]*[\/[[:graph:]]]*) HTTP\/([[:digit:]]+\.[[:digit:]]+)$/ # GET /chat HTTP/1.1
+      VERSION     = 13
+      PROTOCOL    = 'json'.freeze
+
+      attr_reader :path, :version, :headers
+
+      def initialize(request)
+        @request = request
+        @headers = {}
+        @version = '1.1'
+        @path    = '/'
+
+        convert_request_to_hash
+      end
+
+      # Verify if request contains upgrade to websocket demand
+      def upgrade?
+        headers['Connection'] == 'Upgrade' && headers['Upgrade'] == 'websocket'
+      end
+
+      # Verify if request contains a valid version of websocket protocol
+      def valid_version?
+        headers['Sec-WebSocket-Version'].to_i == VERSION
+      end
+
+      # Verify if request contains a valid protocol request
+      def valid_protocol?
+        protocols = headers['Sec-WebSocket-Protocol'].to_s
+        protocols = protocols.split(',').map(&:strip)
+        protocols.empty? || protocols.include?(PROTOCOL)
+      end
+
+      def key
+        headers['Sec-WebSocket-Key'].to_s
+      end
+
+      private
+
+      # Read each line of request and store it into Hash
+      # as key-val pair of all parsed headers
+      def convert_request_to_hash
+        until (line = @request.gets.strip).empty?
+          if !!(line =~ HTTP_HEADER)
+            _, @path, @version = line.match(HTTP_HEADER).to_a
+          else
+            key, val = line.split(':', 2).map(&:strip)
+            @headers.store(key, val)
+          end
+        end
+      end
+    end
+  end
+end

data/web_socket_rb.gemspec

@@ -0,0 +1,33 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'web_socket_rb/version'
+
+Gem::Specification.new do |spec|
+  spec.name    = 'web_socket_rb'
+  spec.version = WebSocketRb::VERSION
+  spec.authors = ['Karol Bajko']
+  spec.email   = ['karol.bajko@gmail.com']
+
+  spec.summary  = 'WebSocket implementation for Ruby'
+  spec.homepage = 'https://bitbucket.org/qarol/websocketrb'
+  spec.license  = 'MIT'
+
+  # Prevent pushing this gem to RubyGems.org by setting 'allowed_push_host', or
+  # delete this section to allow pushing this gem to any host.
+  if spec.respond_to?(:metadata)
+    spec.metadata['allowed_push_host'] = 'https://rubygems.org'
+  else
+    raise 'RubyGems 2.0 or newer is required to protect against public gem pushes.'
+  end
+
+  spec.files         = `git ls-files -z`.split("\x0").reject { |f| f.match(%r{^(test|spec|features)/}) }
+  spec.bindir        = 'exe'
+  spec.executables   = spec.files.grep(%r{^exe/}) { |f| File.basename(f) }
+  spec.require_paths = ['lib']
+
+  spec.add_development_dependency 'bundler', '~> 1.11'
+  spec.add_development_dependency 'rake', '~> 10.0'
+  spec.add_development_dependency 'rspec', '~> 3.0'
+  spec.add_development_dependency 'simplecov', '~> 0.12.0'
+end

metadata

@@ -0,0 +1,139 @@
+--- !ruby/object:Gem::Specification
+name: web_socket_rb
+version: !ruby/object:Gem::Version
+  version: 0.1.1
+platform: ruby
+authors:
+- Karol Bajko
+autorequire: 
+bindir: exe
+cert_chain: []
+date: 2016-09-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bundler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.11'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '10.0'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.0'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 0.12.0
+description: 
+email:
+- karol.bajko@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- ".rspec"
+- ".ruby-gemset"
+- ".ruby-version"
+- ".travis.yml"
+- CODE_OF_CONDUCT.md
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/console
+- bin/setup
+- examples/client/index.html
+- examples/server/server.rb
+- js/websocketrb_client.js
+- lib/web_socket_rb.rb
+- lib/web_socket_rb/context/sandbox.rb
+- lib/web_socket_rb/error/handshake_error.rb
+- lib/web_socket_rb/error/wrong_frame_error.rb
+- lib/web_socket_rb/protocol/frames_handler.rb
+- lib/web_socket_rb/protocol/handshake.rb
+- lib/web_socket_rb/routes.rb
+- lib/web_socket_rb/server.rb
+- lib/web_socket_rb/service/build_close_frame_service.rb
+- lib/web_socket_rb/service/build_ping_frame_service.rb
+- lib/web_socket_rb/service/build_pong_frame_service.rb
+- lib/web_socket_rb/service/build_text_frame_service.rb
+- lib/web_socket_rb/service/frames_sender.rb
+- lib/web_socket_rb/service/read_frame_service.rb
+- lib/web_socket_rb/version.rb
+- lib/web_socket_rb/wrapper/frame_base.rb
+- lib/web_socket_rb/wrapper/frame_close.rb
+- lib/web_socket_rb/wrapper/frame_outgoing.rb
+- lib/web_socket_rb/wrapper/frame_ping.rb
+- lib/web_socket_rb/wrapper/frame_pong.rb
+- lib/web_socket_rb/wrapper/frame_text.rb
+- lib/web_socket_rb/wrapper/handshake_request.rb
+- web_socket_rb.gemspec
+homepage: https://bitbucket.org/qarol/websocketrb
+licenses:
+- MIT
+metadata:
+  allowed_push_host: https://rubygems.org
+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: []
+rubyforge_project: 
+rubygems_version: 2.4.8
+signing_key: 
+specification_version: 4
+summary: WebSocket implementation for Ruby
+test_files: []