slanger 0.4.1 → 0.4.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: abbd4b1fc22d16cd1a72b1bd647fa4f3703f580d
-  data.tar.gz: 0b6db960a6b39f26a219b8cb7cf56826b02ca111
+  metadata.gz: 5fea601e824e671ed0d87a8a5e44584d3e6a4c18
+  data.tar.gz: 64df554d024eef643d7b311afd8630e13c9a4784
 SHA512:
-  metadata.gz: 2a5cab2cc4a2672405ec12bc830dd43c0051183a68aa54c24a07426d4012c0570a5dda15b1c9a78178347137e61fc2001c3ee9ca4bd716ba3b89b601384e1882
-  data.tar.gz: a2fc49dbb668a8a343c69c852fb946faaa29d89cdadc4f50386a3b810b578bd388cdd0e93d73ad81462797825711badab9a59b91ffa7096d4e777ebb744c3f1c
+  metadata.gz: a4688a9c1191d2eb27bcedb34dbe6e492d0b01df3fb154d50bd7d20254f1495741cab833afc2f1c69538c513d7266f1d7fea298c952397c82327e518da92257d
+  data.tar.gz: 4c197dd2e23beef01734d01f7df2e9d5d21fe75908c2b61802691939de0941b6c3fc7a61dfa240bfaa373c3e95f5d4aaa495cc402c486886befe746fa07514a3

data/README.md

@@ -1,6 +1,6 @@
 # Slanger
 
-[![Build Status](https://travis-ci.org/stevegraham/slanger.svg?branch=master)](https://travis-ci.org/stevegraham/slanger)
+[![Gem Version](https://badge.fury.io/rb/slanger.svg)](http://badge.fury.io/rb/slanger) [![Build Status](https://travis-ci.org/stevegraham/slanger.svg?branch=master)](https://travis-ci.org/stevegraham/slanger)
 
 **Important! Slanger is not supposed to be included in your Gemfile. RubyGems is used as a distribution mechanism. If you include it in your app, you will likely get dependency conflicts. PRs updating dependencies for compatibility with your app will be closed. Thank you for reading and enjoy Slanger!**
 
@@ -52,6 +52,28 @@ eventual consistency, which in practise is instantaneous.
 - Ruby 2.1.2 or greater
 - Redis
 
+## Server setup
+
+Most linux distributions have by defualt a very low open files limit. In order to sustain more than 1024 ( default ) connections, you need to apply the following changes to your system:
+Add to `/etc/sysctl.conf`:
+```
+fs.file-max = 50000
+```
+Add to `/etc/security/limits.conf`:
+```
+* hard nofile 50000
+* soft nofile 50000
+* hard nproc 50000
+* soft nproc 50000
+```
+
+## Cluster load-balancing setup with Haproxy
+
+If you want to run multiple slanger instances in a cluster, one option will be to balance the connections with Haproxy.
+A basic config can be found in the folder `examples`.
+Haproxy can be also used for SSL termination, leaving slanger to not have to deal with SSL checks and so on, making it lighter.
+
+
 ## Starting the service
 
 Slanger is packaged as a Rubygem. Installing the gem makes the 'slanger' executable available. The `slanger` executable takes arguments, of which two are mandatory: `--app_key` and `--secret`. These can but do not have to be the same as the credentials you use for Pusher. They are required because Slanger performs the same HMAC signing of API requests that Pusher does.
@@ -87,6 +109,27 @@ Slanger API server listening on port 4567
 Slanger WebSocket server listening on port 8080
 ```
 
+## Ubuntu upstart script
+
+If you're using Ubuntu, you might find this upscript very helpful. The steps below will create an init script that will make slanger run at boot and restart if it fails.
+Open `/etc/init/slanger` and add:
+```
+start on started networking and runlevel [2345]
+stop on runlevel [016]
+respawn
+script
+    LANG=en_US.UTF-8 /usr/local/rvm/gems/ruby-RUBY_VERISON/wrappers/slanger --app_key KEY --secret SECRET --redis_address redis://REDIS_IP:REDIS_PORT/REDIS_DB
+end script
+```
+This example assumes you're using rvm and a custom redis configuration
+
+Then, to start / stop the service, just do
+```
+service slanger start
+service slanger stop
+```
+
+
 ## Modifying your application code to use the Slanger service
 
 Once you have a Slanger instance listening for incoming connections you need to alter you application code to use the Slanger endpoint instead of Pusher. Fortunately this is very simple, unobtrusive, easily reversable, and very painless.

data/lib/slanger/api.rb

@@ -0,0 +1,5 @@
+module Slanger
+  module Api
+    InvalidRequest = Class.new ArgumentError
+  end
+end

data/lib/slanger/api/event.rb

@@ -0,0 +1,15 @@
+module Slanger
+  module Api
+    class Event < Struct.new :name, :data, :socket_id
+      def payload(channel_id)
+        {
+          event:     name,
+          data:      data,
+          channel:   channel_id,
+          socket_id: socket_id
+        }.select { |_,v| v }.to_json
+      end
+    end
+  end
+end
+

data/lib/slanger/api/event_publisher.rb

@@ -0,0 +1,24 @@
+module Slanger
+  module Api
+    class EventPublisher < Struct.new(:channels, :event)
+      def self.publish(channels, event)
+        new(channels, event).publish
+      end
+
+      def publish
+        Array(channels).each do |c|
+          publish_event(c)
+        end
+      end
+
+      private
+
+      def publish_event(channel_id)
+        Slanger::Redis.publish(channel_id, event.payload(channel_id))
+      end
+
+    end
+  end
+end
+
+

data/lib/slanger/api/request_validation.rb

@@ -0,0 +1,103 @@
+module Slanger
+  module Api
+    class RequestValidation < Struct.new :raw_body, :raw_params, :path_info
+      def initialize(*args)
+        super(*args)
+
+        validate!
+        authenticate!
+        parse_body!
+      end
+
+      def data
+        @data ||= JSON.parse(body["data"] || params["data"])
+      end
+
+      def body
+        @body ||= validate_body!
+      end
+
+      def auth_params
+        params.except('channel_id', 'app_id')
+      end
+
+      def socket_id
+        @socket_id ||= determine_valid_socket_id
+      end
+
+      def params
+        @params ||= validate_raw_params!
+      end
+
+      def channels
+        @channels ||= Array(body["channels"] || params["channels"])
+      end
+
+      private
+
+      def validate_body!
+        @body ||= assert_valid_json!(raw_body.tap{ |s| s.force_encoding('utf-8')})
+      end
+
+      def validate!
+        raise InvalidRequest.new "no body"        unless raw_body.present?
+        raise InvalidRequest.new "invalid params" unless raw_params.is_a? Hash
+        raise InvalidRequest.new "invalid path"   unless path_info.is_a? String
+
+        determine_valid_socket_id
+        channels.each{|id| validate_channel_id!(id)}
+      end
+
+      def validate_socket_id!(socket_id)
+        validate_with_regex!(/\A\d+\.\d+\z/, socket_id, "socket_id")
+      end
+
+      def validate_channel_id!(channel_id)
+        validate_with_regex!(/\A[\w@\-;]+\z/, channel_id, "channel_id")
+      end
+
+      def validate_with_regex!(regex, value, name)
+        raise InvalidRequest, "Invalid #{name} #{value.inspect}" unless value =~ regex
+
+        value
+      end
+
+      def validate_raw_params!
+        restricted =  user_params.slice "body_md5", "auth_version", "auth_key", "auth_timestamp", "auth_signature", "app_id"
+
+        invalid_keys = restricted.keys - user_params.keys
+
+        if invalid_keys.any?
+          raise Slanger::InvalidRequest.new "Invalid params: #{invalid_keys}"
+        end
+
+        restricted
+      end
+
+      def authenticate!
+        # Raises Signature::AuthenticationError if request does not authenticate.
+        Signature::Request.new('POST', path_info, auth_params).
+          authenticate { |key| Signature::Token.new key, Slanger::Config.secret }
+      end
+
+      def parse_body!
+        assert_valid_json!(raw_body)
+      end
+
+      def assert_valid_json!(string)
+        JSON.parse(string)
+      rescue JSON::ParserError
+        raise Slanger::InvalidRequest.new("Invalid request body: #{raw_body}")
+      end
+
+      def determine_valid_socket_id
+        return validate_socket_id!(body["socket_id"])   if body["socket_id"]
+        return validate_socket_id!(params["socket_id"]) if params["socket_id"]
+      end
+
+      def user_params
+        raw_params.reject{|k,_| %w(splat captures).include?(k)}
+      end
+    end
+  end
+end

data/lib/slanger/api/server.rb

@@ -0,0 +1,56 @@
+# encoding: utf-8
+require 'sinatra/base'
+require 'signature'
+require 'json'
+require 'active_support/core_ext/hash'
+require 'eventmachine'
+require 'em-hiredis'
+require 'rack'
+require 'fiber'
+require 'rack/fiber_pool'
+
+module Slanger
+  module Api
+    class Server < Sinatra::Base
+      use Rack::FiberPool
+      set :raise_errors, lambda { false }
+      set :show_exceptions, false
+
+      error(Signature::AuthenticationError) { |e| halt 401, "401 UNAUTHORIZED" }
+      error(Slanger::Api::InvalidRequest)   { |c| halt 400, "400 Bad Request" }
+
+      before do
+        valid_request
+      end
+
+      post '/apps/:app_id/events' do
+        socket_id = valid_request.socket_id
+        body = valid_request.body
+
+        event = Slanger::Api::Event.new(body["name"], body["data"], socket_id)
+        EventPublisher.publish(valid_request.channels, event)
+
+        status 202
+        return {}.to_json
+      end
+
+      post '/apps/:app_id/channels/:channel_id/events' do
+        params = valid_request.params
+
+        event = Event.new(params["name"], valid_request.body, valid_request.socket_id)
+        EventPublisher.publish(valid_request.channels, event)
+
+        status 202
+        return {}.to_json
+      end
+
+      def valid_request
+        @valid_request ||=
+          begin
+            request_body ||= request.body.read.tap{|s| s.force_encoding("utf-8")}
+            RequestValidation.new(request_body, params, env["PATH_INFO"])
+          end
+      end
+    end
+  end
+end

data/lib/slanger/channel.rb

@@ -5,21 +5,33 @@
 # EM channel.
 #
 
-require 'glamazon'
 require 'eventmachine'
 require 'forwardable'
 
 module Slanger
   class Channel
-    include Glamazon::Base
     extend  Forwardable
 
     def_delegators :channel, :push
+    attr_reader :channel_id
 
     class << self
       def from channel_id
-        klass = channel_id[/^presence-/] ? PresenceChannel : Channel
-        klass.find_or_create_by_channel_id channel_id
+        klass = channel_id[/\Apresence-/] ? PresenceChannel : Channel
+
+        klass.lookup(channel_id) || klass.create(channel_id: channel_id)
+      end
+
+      def lookup(channel_id)
+        all.detect { |o| o.channel_id == channel_id }
+      end
+
+      def create(params = {})
+        new(params).tap { |r| all << r }
+      end
+
+      def all
+        @all ||= []
       end
 
       def unsubscribe channel_id, subscription_id
@@ -32,7 +44,7 @@ module Slanger
     end
 
     def initialize(attrs)
-      super
+      @channel_id = attrs.with_indifferent_access[:channel_id]
       Slanger::Redis.subscribe channel_id
     end
 
@@ -69,11 +81,11 @@ module Slanger
     # Send an event received from Redis to the EventMachine channel
     # which will send it to subscribed clients.
     def dispatch(message, channel)
-      push(message.to_json) unless channel =~ /^slanger:/
+      push(message.to_json) unless channel =~ /\Aslanger:/
     end
 
     def authenticated?
-      channel_id =~ /^private-/ || channel_id =~ /^presence-/
+      channel_id =~ /\Aprivate-/ || channel_id =~ /\Apresence-/
     end
   end
 end

data/lib/slanger/connection.rb

@@ -25,7 +25,8 @@ module Slanger
     end
 
     def establish
-      @socket_id = SecureRandom.uuid
+      @socket_id = "%d.%d" % [Process.pid, SecureRandom.random_number(10 ** 6)]
+
       send_payload nil, 'pusher:connection_established', {
         socket_id: @socket_id,
         activity_timeout: Slanger::Config.activity_timeout

data/lib/slanger/handler.rb

@@ -28,9 +28,9 @@ module Slanger
 
       msg['data'] = JSON.parse(msg['data']) if msg['data'].is_a? String
 
-      event = msg['event'].gsub(/^pusher:/, 'pusher_')
+      event = msg['event'].gsub(/\Apusher:/, 'pusher_')
 
-      if event =~ /^client-/
+      if event =~ /\Aclient-/
         msg['socket_id'] = connection.socket_id
         Channel.send_client_message msg
       elsif respond_to? event, true
@@ -106,7 +106,7 @@ module Slanger
     end
 
     def subscription_klass channel_id
-      klass = channel_id.match(/^(private|presence)-/) do |match|
+      klass = channel_id.match(/\A(private|presence)-/) do |match|
         Slanger.const_get "#{match[1]}_subscription".classify
       end
 

data/lib/slanger/presence_channel.rb

@@ -5,7 +5,6 @@
 # EM channel. Keeps data on the subscribers to send it to clients.
 #
 
-require 'glamazon'
 require 'eventmachine'
 require 'forwardable'
 require 'fiber'
@@ -16,7 +15,7 @@ module Slanger
 
     # Send an event received from Redis to the EventMachine channel
     def dispatch(message, channel)
-      if channel =~ /^slanger:/
+      if channel =~ /\Aslanger:/
         # Messages received from the Redis channel slanger:*  carry info on
         # subscriptions. Update our subscribers accordingly.
         update_subscribers message

data/lib/slanger/service.rb

@@ -6,7 +6,7 @@ module Slanger
     def run
       Slanger::Config[:require].each { |f| require f }
       Thin::Logging.silent = true
-      Rack::Handler::Thin.run Slanger::ApiServer, Host: Slanger::Config.api_host, Port: Slanger::Config.api_port
+      Rack::Handler::Thin.run Slanger::Api::Server, Host: Slanger::Config.api_host, Port: Slanger::Config.api_port
       Slanger::WebSocketServer.run
     end
 

data/lib/slanger/version.rb

@@ -1,3 +1,3 @@
 module Slanger
-  VERSION = '0.4.1'
+  VERSION = '0.4.2'
 end

data/slanger.rb

@@ -16,4 +16,8 @@ File.tap do |f|
   Dir[f.expand_path(f.join(f.dirname(__FILE__),'lib', 'slanger', '*.rb'))].each do |file|
     Slanger.autoload File.basename(file, '.rb').camelize, file
   end
+
+  Dir[f.expand_path(f.join(f.dirname(__FILE__),'lib', 'slanger', 'api', '*.rb'))].each do |file|
+    Slanger::Api.autoload File.basename(file, '.rb').camelize, file
+  end
 end

data/spec/have_attributes.rb

@@ -0,0 +1,64 @@
+module SlangerHelperMethods
+  class HaveAttributes
+    attr_reader :messages, :attributes
+    def initialize attributes
+      @attributes = attributes
+    end
+
+    CHECKS = %w(first_event last_event last_data )
+
+    def matches?(messages)
+      @messages = messages
+      @failures = []
+
+      check_connection_established if attributes[:connection_established]
+      check_id_present             if attributes[:id_present]
+
+      CHECKS.each { |a| attributes[a.to_sym] ?  check(a) : true }
+
+      @failures.empty?
+    end
+
+    def check message
+      send(message) == attributes[message.to_sym] or @failures << message
+    end
+
+    def failure_message
+      @failures.map {|f| "expected #{f}: to equal #{attributes[f]} but got #{send(f)}"}.join "\n"
+    end
+
+    private
+
+    def check_connection_established
+      if first_event != 'pusher:connection_established'
+        @failures << :connection_established
+      end
+    end
+
+    def check_id_present
+      if messages.first['data']['socket_id'] == nil
+        @failures << :id_present
+      end
+    end
+
+    def first_event
+      messages.first['event']
+    end
+
+    def last_event
+      messages.last['event']
+    end
+
+    def last_data
+      messages.last['data']
+    end
+
+    def count
+      messages.length
+    end
+  end
+
+  def have_attributes attributes
+    HaveAttributes.new attributes
+  end
+end