webmate 0.1.0

data/lib/webmate/route_helpers/routes_collection.rb

@@ -0,0 +1,273 @@
+module Webmate
+  class RoutesCollection
+    TRANSPORTS = [:ws, :http]
+
+    attr_reader :routes
+
+    def initialize
+      @routes = {}
+      @resource_scope = []
+      
+      enable_websockets_support
+    end
+
+    def define_routes(&block)
+      instance_eval(&block)
+    end
+
+    # get info about matched route
+    #   method    - GET/POST/PUT/PATCH/DELETE
+    #   transport - HTTP / WS [ HTTPS / WSS ]
+    #   path      - /projects/123/tasks
+    #
+    def match(method, transport, path)
+      routes = get_routes(method, transport)
+      routes.each do |route|
+        if info = route.match(path)
+          return info
+        end
+      end
+      nil
+    end
+
+    def get_routes(method, transport)
+      @routes[method] ||= {}
+      @routes[method][transport] || []
+    end
+
+    private
+
+    # if websockets enabled, we should add specific http routes
+    #   - for handshake          [ get session id ]
+    #   - for connection opening [ switch protocol from http to ws ]
+    def enable_websockets_support
+      namespace = configatron.websockets.namespace
+      namespace = 'api' if namespace.blank? # || not working with configatron
+
+      route_options = { method: 'GET', transport: ['HTTP'], action: 'websocket' }
+
+      # handshake
+      add_route(Webmate::Route.new(route_options.merge(
+        path: "/#{namespace}/:version_id",
+        responder: Webmate::SocketIO::Actions::Handshake,
+      )))
+
+      # transport connection
+      add_route(Webmate::Route.new(route_options.merge(
+        transport: ["WS"],
+        path: "/#{namespace}/:version_id/websocket/:session_id",
+        responder: Webmate::SocketIO::Actions::Connection,
+        action: 'open'
+      )))
+    end
+
+    # we store routes in following structure
+    # { method:
+    #     transport: [ routes ]
+    # route - valid object of Webmate::Route class
+    def add_route(route)
+      # add route to specific node of routes hash
+      @routes[route.method.to_s.upcase] ||= {}
+      route.transport.each do |transport|
+        (@routes[route.method.to_s.upcase][transport.to_s.upcase] ||= []).push(route)
+      end
+    end
+
+    # define methods for separate routes
+    #   get '/path', to: , transport: ,
+    # or 
+    #   resources :projects
+    #     member do
+    #       get 'read_formatted'
+    %w[get post put delete patch].each do |method_name|
+      define_method method_name.to_sym do |path, options = {}|
+        route_options = process_options(options)
+
+        # process case inside resources/collection or resources/member block
+        if is_member_scope? or is_collection_scope?
+          route_options[:responder] ||= get_responder_from_scope
+          route_options[:action] ||= path
+          route_options[:path] ||= "#{path_prefix}/#{path}"
+        else
+          route_options[:path] = path || '/'
+        end
+        route_options[:method] = method_name.to_sym
+
+        add_route(Webmate::Route.new(route_options))
+      end
+    end
+
+    # available options are
+    # transport: [:http, :ws] or any single transport
+    # responder can be specified
+    #   action: some_action
+    #   responder: SomeResponder or 'some/responder/api/v1'
+    # or with to: param
+    #   to: 'responder_name#action_name'
+    def process_options(raw_options)
+      options = {}
+      options[:transport] = normalized_transport_option(raw_options[:transport])
+
+      if responder_with_action = raw_options[:to]
+        # extract action & responder from :to
+        responder_name, action = responder_with_action.split('#')
+        options[:responder] = "#{responder_name}_responder".classify.constantize
+        options[:action] = action
+      else
+        # use action & responder options
+        options[:responder] = raw_options[:responder]
+        options[:action] = raw_options[:action]
+      end
+
+      options
+    end
+
+    # resource :name, options, &block
+    #  can register following methods
+    #     get 'name'        => read_all
+    #     get 'name/:id'    => read
+    #     post 'name'       => create
+    #     put 'name/:id'    => update
+    #     delete 'name/:id' => destroy
+    #
+    # examples
+    #   resources :projects, transport: :http, only: [:read, :read_all, :update, :delete, :create]
+    #
+    def resources(*resources, &block)
+      options = resources.last.is_a?(Hash) ? resources.pop : {}
+      actions = normalized_action_option(options.delete(:only))
+
+      resources.each do |resource_name|
+        responder = (options[:responder] || "#{resource_name}_responder").classify
+        route_args = { responder: responder, transport: options[:transport] }
+
+        [:read, :read_all, :update, :delete, :create].each do |action_name|
+          if actions.include?(action_name)
+            self.send "define_resource_#{action_name}_method", resource_name.to_s, route_args
+          end
+        end
+
+        nested_resources_eval(resource_name, &block) if block_given?
+      end
+    end
+
+    # should process blocks inside other resource
+    #   and correctly set prefix of resources-parents
+    #   resourcesprojects do
+    #     resources :tasks
+    #   end
+    def nested_resources_eval(resource_name, &block)
+      @resource_scope.push({
+        resource: resource_name,
+        resource_id: "#{resource_name.to_s.singularize}_id".to_sym
+      })
+      yield block
+    ensure
+      @resource_scope.pop
+    end
+
+    def path_prefix
+      prefix = ''
+      @resource_scope.each do |scope|
+        prefix << "/#{scope[:resource]}"
+        prefix << "/:#{scope[:resource_id]}" unless scope[:collection]
+      end
+      prefix
+    end
+
+    def get_responder_from_scope
+      responder_name = @resource_scope.last[:resource]
+      "#{responder_name}_responder".classify.constantize
+    end
+
+    # methods below designed to set actions on member/collection
+    # inside resource definition block
+    #
+    # "projects/do_on_collection"
+    # "projects/:project_id/do_on_member"
+    #
+    # can be designed as
+    # example
+    # resources :projects do
+    #   collection do
+    #     get 'do_on_collection'
+    #   end
+    #
+    #   member do
+    #     get "do_on_member"
+    #   end 
+    #   prefix /resource_name/resource_id
+    def member(&block)
+      return if @resource_scope.blank?
+      @resource_scope.last[:member] = true
+      yield block
+    ensure
+      @resource_scope.last[:member] = false
+    end
+
+    # prefix /resource_name
+    def collection(&block)
+      return if @resource_scope.blank?
+      @resource_scope.last[:collection] = true
+      yield block
+    ensure
+      @resource_scope.last[:collection] = false
+    end
+
+    # track definition inside collection block
+    # collection do
+    #   path 'code', options
+    def is_collection_scope?
+      @resource_scope.present? && @resource_scope.last[:collection]
+    end
+
+    # track definition inside member block
+    # collection do
+    #   path 'code', options
+    def is_member_scope?
+      @resource_scope.present? && @resource_scope.last[:member]
+    end
+
+
+    # helper methods
+    # normalize_transport_option 
+    #   returns array of requested transports, but available ones only
+    def normalized_transport_option(transport = nil)
+      return TRANSPORTS.dup if transport.blank?
+      transport = [transport] unless transport.is_a?(Array)
+
+      transport.map{|t| t.to_s.downcase.to_sym} & TRANSPORTS
+    end
+
+    # methods list
+    #   combination from available
+    #   [:read, :read_all, :update, :delete, :create]
+    def normalized_action_option(methods = nil)
+      default_methods = [:read, :read_all, :update, :delete, :create]
+      return default_methods if methods.blank?
+      methods = [methods] unless methods.is_a?(Array)
+
+      methods.map{|m| m.to_s.downcase.to_sym} & default_methods
+    end
+
+    def define_resource_read_all_method(resource_name, route_args) 
+      get "#{path_prefix}/#{resource_name}", route_args.merge(action: :read_all)
+    end
+
+    def define_resource_read_method(resource_name, route_args)
+      get "#{path_prefix}/#{resource_name}/:#{resource_name.singularize}_id", route_args.merge(action: :read)
+    end
+
+    def define_resource_create_method(resource_name, route_args)
+      post "#{path_prefix}/#{resource_name}", route_args.merge(action: :create)
+    end
+
+    def define_resource_update_method(resource_name, route_args)
+      put "#{path_prefix}/#{resource_name}/:#{resource_name.singularize}_id", route_args.merge(action: :update)
+    end
+
+    def define_resource_delete_method(resource_name, route_args)
+      delete "#{path_prefix}/#{resource_name}/:#{resource_name.singularize}_id", route_args.merge(action: :delete)
+    end
+  end
+end

data/lib/webmate/socket.io/actions/connection.rb

@@ -0,0 +1,14 @@
+module Webmate
+  module SocketIO
+    module Actions
+      class Connection
+        def initialize(*args)
+        end
+
+        def respond(base)
+          puts "this case should be process directly in Webmate::Application"
+        end
+      end
+    end
+  end
+end

data/lib/webmate/socket.io/actions/handshake.rb

@@ -0,0 +1,34 @@
+module Webmate
+  module SocketIO
+    module Actions
+      class Handshake
+        def initialize(options = {})
+          @session_id = generate_session_id
+
+          default_options = {
+            transports: %w{websocket},
+            heartbeat_timeout: 300,
+            closing_timeout: 300
+          }
+          @settings = OpenStruct.new(default_options.merge(options))
+        end
+
+        def respond
+          body = [
+            @session_id,
+            @settings.heartbeat_timeout,
+            @settings.closing_timeout,
+            @settings.transports.join(',')
+          ]
+          Webmate::Responders::Response.new(body.join(':'))
+        end
+
+        private
+
+        def generate_session_id
+          SecureRandom.hex
+        end
+      end
+    end
+  end
+end

data/lib/webmate/socket.io/packets/ack.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Ack < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'ack'
+  end
+end

data/lib/webmate/socket.io/packets/base.rb

@@ -0,0 +1,156 @@
+module Webmate
+  module SocketIO
+    module Packets
+      class Base
+        cattr_accessor :current_id
+
+        attr_writer :packet_id, :packet_endpoint
+
+        # the same order, as in socket io packet.packets
+        PACKETS_TYPES = %W{
+          disconnect
+          connect
+          heartbeat
+          message
+          json
+          event
+          ack
+          error
+          noop
+        }
+
+        def initialize(packet_data = {})
+          @packet_data  = packet_data.with_indifferent_access
+        end
+
+        # packet should be created by socket.io spec 
+        #[message type] ':' [message id ('+')] ':' [message endpoint] (':' [message data]) 
+        # and webmate spec
+        # message_data = {
+        #   method: GET/POST/...
+        #   path: '/projects'
+        #   params: {}
+        #   metadata: { data should be returned back with answer }
+        # }
+        def self.parse(packet)
+          # last element is encoded json array, so there can be many ':'
+          packet_type_id, packet_id, packet_endpoint, json_data = packet.split(':', 4)
+
+          packet_data = (Yajl::Parser.parse(json_data) || {}).with_indifferent_access
+
+          if packet_data[:params].is_a?(String)
+            packet_data[:params] = Yajl::Parser.parse(packet_data[:params])
+          end
+
+          if packet_data[:metadata].is_a?(String)
+            packet_data[:metadata] = Yajl::Parser.parse(packet_data[:metadata])
+          end
+
+          packet = OpenStruct.new(
+            path: packet_data[:path],
+            method: packet_data[:method],
+            params: packet_data[:params] || {},
+            metadata: packet_data[:metadata] || {},
+            packet_id: packet_id,
+            packet_endpoint: packet_endpoint
+          )
+
+          packet
+        end
+
+        # convert response from Responders::Base to socket io message
+        # 
+        def self.build_response_packet(response)
+          new(self.prepare_packet_data(response))
+        end
+
+        def self.prepare_packet_data(response)
+          packet_data = {
+            action:   response.action,
+            body:     response.data,
+            path:     response.path,
+            params:   response.params,
+            metadata: response.metadata
+          }
+        end
+
+        # socket io spec
+        #[message type] ':' [message id ('+')] ':' [message endpoint] (':' [message data]) 
+        def to_packet
+          data = {
+            action: action,
+            request: { 
+              path:     path, 
+              metadata: metadata
+            },
+            response: {
+              body: body,
+              status: status || 200
+            }
+          }
+          encoded_data = Yajl::Encoder.new.encode(data)
+          [
+            packet_type_id,
+            packet_id,
+            packet_endpoint,
+            encoded_data
+          ].join(':')
+        end
+
+        def packet_type_id
+          PACKETS_TYPES.index(self.packet_type)
+        end
+
+        def packet_endpoint
+          @packet_endpoint ||= ''
+        end
+
+        def packet_data
+          (@packet_data || {})
+        end
+
+        def metadata
+          packet_data[:metadata]
+        end
+
+        def path
+          packet_data[:path]
+        end
+
+        def action
+          packet_data[:action]
+        end
+
+        def params
+          packet_data[:params]
+        end
+
+        def body
+          packet_data[:body]
+        end
+
+        def status
+          packet_data[:status]
+        end
+
+        def packet_id
+          @id ||= generate_packet_id
+        end
+
+        # update counter
+        def packet_id=(new_packet_id)
+          self.class.current_id = new_packet_id
+          @id ||= generate_packet_id
+        end
+
+        # unique packet id
+        # didn't find any influence for now, 
+        # uniqueness not matter
+        def generate_packet_id
+          self.class.current_id ||= 0
+          self.class.current_id += 1
+        end
+      end
+    end
+  end
+end

data/lib/webmate/socket.io/packets/connect.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Connect < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'connect'
+  end
+end

data/lib/webmate/socket.io/packets/disconnect.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Disconnect < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'disconnect'
+  end
+end

data/lib/webmate/socket.io/packets/error.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Error < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'error'
+  end
+end

data/lib/webmate/socket.io/packets/event.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Event < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'event'
+  end
+end

data/lib/webmate/socket.io/packets/heartbeat.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Heartbeat < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'heartbeat'
+  end
+end

data/lib/webmate/socket.io/packets/json.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Json < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'json'
+  end
+end

data/lib/webmate/socket.io/packets/message.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Message < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'message'
+  end
+end

data/lib/webmate/socket.io/packets/noop.rb

@@ -0,0 +1,5 @@
+class Webmate::SocketIO::Packets::Noop < Webmate::SocketIO::Packets::Base
+  def packet_type
+    'noop'
+  end
+end

data/lib/webmate/support/em_mongoid.rb

@@ -0,0 +1,53 @@
+# TODO: this is needed to use latest mongoid with moped, but it doesn't work at this moment
+
+begin
+  require "moped"
+rescue LoadError => error
+  raise "Missing EM-Synchrony dependency: gem install moped"
+end
+
+module Moped
+  class TimeoutHandler
+    def self.timeout(op_timeout, &block)
+      f = Fiber.current
+      timer = EM::Timer.new(op_timeout) { f.resume(nil) }
+      res = block.call
+      timer.cancel
+      res
+    end
+  end
+  module Sockets
+    module Connectable
+      module ClassMethods
+        def connect(host, port, timeout)
+          TimeoutHandler.timeout(timeout) do
+            sock = new(host, port)
+            #sock.set_encoding('binary')
+            #sock.setsockopt(Socket::IPPROTO_TCP, Socket::TCP_NODELAY, 1)
+            sock
+          end
+        end
+      end
+    end
+
+    class EM_TCP < ::EventMachine::Synchrony::TCPSocket
+      include Connectable
+
+      def connection_completed
+        @opening = false
+        @in_req.succeed(self) if @in_req
+      end
+    end
+    Mutex = ::EventMachine::Synchrony::Thread::Mutex
+    ConditionVariable = ::EventMachine::Synchrony::Thread::ConditionVariable
+  end
+  class Connection
+    def connect
+      @sock = if !!options[:ssl]
+        Sockets::SSL.connect(host, port, timeout)
+      else
+        Sockets::EM_TCP.connect(host, port, timeout)
+      end
+    end
+  end
+end

data/lib/webmate/version.rb

@@ -0,0 +1,3 @@
+module Webmate
+  VERSION = '0.1.0'
+end

data/lib/webmate/views/scope.rb

@@ -0,0 +1,25 @@
+module Webmate::Views
+  class Scope
+    include Sinatra::Cookies
+    include Webmate::Sprockets::Helpers
+
+    def initialize(responder)
+      @responder = responder
+    end
+
+    def user_websocket_token
+    end
+
+    def javascript_client_configs
+      %Q{<script type="text/javascript">
+        if (!window.Webmate) {window.Webmate = {}};
+        window.Webmate.websocketsPort = #{configatron.websockets.port};
+        window.Webmate.websocketsEnabled = #{configatron.websockets.enabled ? 'true' : 'false'};
+      </script>}
+    end
+
+    def user_websocket_token_tag
+      %Q{<meta content="#{user_websocket_token}" name="websocket-token" />}
+    end
+  end
+end

data/lib/webmate/websockets.rb

@@ -0,0 +1,50 @@
+module Webmate
+  class Websockets
+    class << self
+      def subscribe(session_id, request, &block)
+        user_id = request.env['warden'].user.id
+
+        request.websocket do |websocket|
+          # subscribe user to redis channel
+          subscribe_to_personal_channel(user_id, websocket)
+
+          websocket.onopen do
+            websocket.send(Webmate::SocketIO::Packets::Connect.new.to_packet)
+            warn("Socket connection opened for session_id: #{session_id}")
+          end
+
+          websocket.onmessage do |message|
+            response = block.call(Webmate::SocketIO::Packets::Base.parse(message))
+            if response
+              packet = Webmate::SocketIO::Packets::Message.build_response_packet(response)
+              websocket.send(packet.to_packet)
+            else
+              warn("empty response for #{message.inspect}")
+            end
+          end
+
+          websocket.onclose do
+            warn("Socket connection closed '#{session_id}'")
+          end
+        end
+      end
+
+      def subscribe_to_personal_channel(user_id, websocket)
+        channel_name = Webmate::Application.get_channel_name_for(user_id)
+
+        subscriber = EM::Hiredis.connect.pubsub
+        subscriber.subscribe(channel_name)
+        warn("user has been subscribed to channel '#{channel_name}'")
+
+        subscriber.on(:message) do |channel, message_data|
+          response_data = Webmate::Application.restore(message_data)
+          packet = Webmate::SocketIO::Packets::Message.new(response_data)
+
+          websocket.send(packet.to_packet)
+        end
+
+        subscriber
+      end
+    end
+  end
+end