kalebr-pusher 0.6.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0f501a6e7ae0150b3488b530dff35f2414706c28
+  data.tar.gz: b5d894b0e0c269434b2edad9eb0c6de3b60909e3
+SHA512:
+  metadata.gz: 2fb04dd4ef2724efa44103e5964a70ad265a3f9688d488c16410eabb972d1cf14d6f8fa1a2fb409d8c73e8b76ec272e0319741cfbd6bf4314105a285d3b610e7
+  data.tar.gz: dba884b83725ddb7827a4847a018f19b4e9aaa7ba501eb240c830a9a76fc2529e96b11ab36bea90d604fdf15c27fc9a4a1108adc1685e63dff4076db7f9163e6

data/README.md

@@ -0,0 +1,66 @@
+# How to use it
+
+## Requirements
+
+- 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
+```
+
+```bash
+$ kalerbr-pusher --app_key 765ec374ae0a69f4ce44 --secret your-pusher-secret
+```
+
+If all went to plan you should see the following output to STDOUT
+
+
+
+kalebr-pusher API server listening on port 4567
+kalebr-pusher WebSocket server listening on port 8080
+
+
+## Modifying your application code to use the Kalebr service
+
+
+
+```ruby
+...
+
+Pusher.host   = 'kalebr.example.com'
+Pusher.port   = 4567
+```
+
+You will also need to do the same to the Pusher JavaScript client in your client side JavaScript, e.g
+
+```html
+<script type="text/javascript">
+  var pusher = new Pusher('#{Pusher.key}', {
+    wsHost: "0.0.0.0",
+    wsPort: "8080",
+    wssPort: "8080",
+    enabledTransports: ['ws', 'flash']
+  });
+</script>
+```
+
+Of course you could proxy all requests to `ws.example.com` to port 8080 of your kalerbr-pusher node and `api.example.com` to port 4567 of your kalerbr-pusher node for example, that way you would only need to set the host property of the Pusher client.
+
+# Author
+
+- Nilanga Saluwadana
+
+
+&copy; 2016  

data/bin/kalebr-pusher

@@ -0,0 +1,152 @@
+#!/usr/bin/env ruby
+# encoding: utf-8
+
+require 'optparse'
+require 'eventmachine'
+require 'yaml'
+require 'active_support/core_ext/hash'
+
+options = {}
+
+
+OptionParser.new do |opts|
+  opts.on '-h', '--help', 'Display this screen' do
+    puts opts
+    exit
+  end
+
+  opts.on '-k', '--app_key APP_KEY', "Pusher application key. This parameter is required on command line or in optional config file." do |k|
+    options[:app_key] = k
+  end
+
+  opts.on '-s', '--secret SECRET', "Pusher application secret. This parameter is required on command line or in optional config file." do |k|
+    options[:secret] = k
+  end
+
+  opts.on '-C', '--config_file FILE', "Path to Yaml file that can contain all configuration options, including required ones." do |k|
+    options[:config_file] = k
+  end
+
+  opts.on '-r', '--redis_address URL', "Address to bind to (Default: redis://127.0.0.1:6379/0)" do |h|
+    options[:redis_address] = h
+  end
+
+  opts.on '-a', '--api_host HOST', "API service address (Default: 0.0.0.0:4567)" do |p|
+    options[:api_host], options[:api_port] = p.split(':')
+  end
+
+  opts.on '-w', '--websocket_host HOST', "WebSocket service address (Default: 0.0.0.0:8080)" do |p|
+    options[:websocket_host], options[:websocket_port] = p.split(':')
+  end
+
+  opts.on '-i', '--require FILE', "Require a file before starting pusher" do |p|
+    options[:require] ||= []
+    options[:require] << p
+  end
+
+  opts.on '-p', '--private_key_file FILE', "Private key file for SSL transport" do |p|
+    options[:tls_options] ||= {}
+    options[:tls_options][:private_key_file] = p
+  end
+
+  opts.on '-b', '--webhook_url URL', "Callback URL for webhooks" do |p|
+    options[:webhook_url] = p
+  end
+
+  opts.on '-c', '--cert_file FILE', "Certificate file for SSL transport" do |p|
+    options[:tls_options] ||= {}
+    options[:tls_options][:cert_chain_file] = p
+  end
+
+  opts.on "-v", "--[no-]verbose", "Run verbosely" do |v|
+    options[:debug] = v
+  end
+
+  opts.on "-t" "--activity_timeout", "Activity (ping-pong) Timeout" do |t|
+    options[:activity_timeout] = t
+  end
+
+  opts.on '--pid_file PIDFILE', "The Kalebr-pusher process ID file name." do |k|
+    options[:pid_file] = k
+  end
+
+  opts.parse!
+
+  if options[:config_file] and File.exists? options[:config_file]
+    config_file_contents = YAML::load(File.open(options[:config_file]))
+    options.reverse_merge! config_file_contents.deep_symbolize_keys!
+  end
+
+  %w<app_key secret>.each do |parameter|
+    unless options[parameter.to_sym]
+      puts "--#{parameter} STRING is a required argument. Use your Pusher #{parameter}.\n"
+      puts opts
+      exit
+    end
+  end
+
+end
+
+
+
+if options[:tls_options]
+  [:cert_chain_file, :private_key_file].each do |param|
+    raise RuntimeError.new "Both --cert_file and --private_key_file need to be specified" unless options[:tls_options][param]
+    raise RuntimeError.new "--#{param} does not exist at `#{options[:tls_options][param]}`" unless File.exists? options[:tls_options][param]
+  end
+end
+
+STDOUT.sync = true
+
+case
+when EM.epoll?  then EM.epoll
+when EM.kqueue? then EM.kqueue
+end
+
+EM.run do
+  File.tap { |f| require f.expand_path(f.join(f.dirname(__FILE__),'..', 'pusher.rb')) }
+  Slanger::Config.load options
+
+  # Write PID to file
+  unless options[:pid_file].nil?
+    File.open(options[:pid_file], 'w') { |f| f.puts Process.pid }
+  end
+
+  Slanger::Service.run
+
+  puts "\n"
+  puts "\n"
+  puts "\n"
+
+  puts "     PPPPPPPPPPPPPPPPP                                   hhhhhhh\n"                                                   
+  puts "     P::::::::::::::::P                                  h:::::h\n"                                                   
+  puts "     P::::::PPPPPP:::::P                                 h:::::h\n"                                                   
+  puts "     PP:::::P     P:::::P                                h:::::h\n"                                                   
+  puts "       P::::P     P:::::uuuuuu    uuuuuu     ssssssssss  h::::h hhhhh          eeeeeeeeeeee   rrrrr   rrrrrrrrr\n"   
+  puts "       P::::P     P:::::u::::u    u::::u   ss::::::::::s h::::hh:::::hhh     ee::::::::::::ee r::::rrr:::::::::r\n"  
+  puts "       P::::PPPPPP:::::Pu::::u    u::::u ss:::::::::::::sh::::::::::::::hh  e::::::eeeee:::::er:::::::::::::::::r\n" 
+  puts "       P:::::::::::::PP u::::u    u::::u s::::::ssss:::::h:::::::hhh::::::he::::::e     e:::::rr::::::rrrrr::::::r\n"
+  puts "       P::::PPPPPPPPP   u::::u    u::::u  s:::::s  ssssssh::::::h   h::::::e:::::::eeeee::::::er:::::r     r:::::r\n"
+  puts "       P::::P           u::::u    u::::u    s::::::s     h:::::h     h:::::e:::::::::::::::::e r:::::r     rrrrrrr\n"
+  puts "       P::::P           u::::u    u::::u       s::::::s  h:::::h     h:::::e::::::eeeeeeeeeee  r:::::r\n"            
+  puts "       P::::P           u:::::uuuu:::::u ssssss   s:::::sh:::::h     h:::::e:::::::e           r:::::r\n"            
+  puts "     PP::::::PP         u:::::::::::::::us:::::ssss::::::h:::::h     h:::::e::::::::e          r:::::r\n"            
+  puts "     P::::::::P          u:::::::::::::::s::::::::::::::sh:::::h     h:::::he::::::::eeeeeeee  r:::::r \n"           
+  puts "     P::::::::P           uu::::::::uu:::us:::::::::::ss h:::::h     h:::::h ee:::::::::::::e  r:::::r\n"            
+  puts "     PPPPPPPPPP             uuuuuuuu  uuuu sssssssssss   hhhhhhh     hhhhhhh   eeeeeeeeeeeeee  rrrrrrr\n" 
+  puts "\n"
+  puts "\n"
+
+  puts "Running Kalebr-pusher v.#{Slanger::VERSION}"
+  puts "\n"
+
+  puts "Kalebr-pusher API server listening on port #{Slanger::Config.api_port}"
+  puts "Kalebr-pusher WebSocket server listening on port #{Slanger::Config.websocket_port}"
+end
+
+
+                                                                                                                                                                                                                   
+                                                                                                                                                                                                          
+           
+                                                                                                    
+                                                                                                   

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,17 @@
+require 'oj'
+
+module Slanger
+  module Api
+    class Event < Struct.new :name, :data, :socket_id
+      def payload(channel_id)
+        Oj.dump({
+          event:     name,
+          data:      data,
+          channel:   channel_id,
+          socket_id: socket_id
+        }.select { |_,v| v }, mode: :compat)
+      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,105 @@
+require 'oj'
+
+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 ||= Oj.load(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@\-;_.=,]{1,164}\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)
+        Oj.load(string)
+      rescue Oj::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,57 @@
+# 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'
+require 'oj'
+
+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 Oj.dump({}, mode: :compat)
+      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 Oj.dump({}, mode: :compat)
+      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

@@ -0,0 +1,106 @@
+# Channel class.
+#
+# Uses an EventMachine channel to let clients interact with the
+# Pusher channel. Relay events received from Redis into the
+# EM channel.
+#
+
+require 'eventmachine'
+require 'forwardable'
+require 'oj'
+
+module Slanger
+  class Channel
+    extend  Forwardable
+
+    def_delegators :channel, :push
+    attr_reader :channel_id
+
+    class << self
+      def from 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
+        from(channel_id).try :unsubscribe, subscription_id
+      end
+
+      def send_client_message msg
+        from(msg['channel']).try :send_client_message, msg
+      end
+    end
+
+    def initialize(attrs)
+      @channel_id = attrs.with_indifferent_access[:channel_id]
+      Slanger::Redis.subscribe channel_id
+    end
+
+    def channel
+      @channel ||= EM::Channel.new
+    end
+
+    def subscribe *a, &blk
+      Slanger::Redis.hincrby('channel_subscriber_count', channel_id, 1).
+        callback do |value|
+          Slanger::Webhook.post name: 'channel_occupied', channel: channel_id if value == 1
+        end
+
+      channel.subscribe *a, &blk
+    end
+
+    def unsubscribe *a, &blk
+      Slanger::Redis.hincrby('channel_subscriber_count', channel_id, -1).
+        callback do |value|
+          Slanger::Webhook.post name: 'channel_vacated', channel: channel_id if value == 0
+        end
+
+      channel.unsubscribe *a, &blk
+    end
+
+
+    # Send a client event to the EventMachine channel.
+    # Only events to channels requiring authentication (private or presence)
+    # are accepted. Public channels only get events from the API.
+    def send_client_message(message)
+      Slanger::Redis.publish(message['channel'], Oj.dump(message, mode: :compat)) if authenticated?
+    end
+
+    # Send an event received from Redis to the EventMachine channel
+    # which will send it to subscribed clients.
+    def dispatch(message, channel)
+      push(Oj.dump(message, mode: :compat)) unless channel =~ /\Aslanger:/
+
+      perform_client_webhook!(message)
+    end
+
+    def authenticated?
+      channel_id =~ /\Aprivate-/ || channel_id =~ /\Apresence-/
+    end
+
+    private
+
+    def perform_client_webhook!(message)
+      if (message['event'].start_with?('client-')) then
+
+        event = message.merge({'name' => 'client_event'})
+        event['data'] = Oj.dump(event['data'])
+
+        Slanger::Webhook.post(event)
+      end
+    end
+  end
+end