edmond-danthes 2.1.0

data/defaults.reek

@@ -0,0 +1,11 @@
+---
+NestedIterators:
+  max_allowed_nesting: 2
+UtilityFunction:
+  enabled: false
+IrresponsibleModule:
+  enabled: false
+DuplicateMethodCall:
+  max_calls: 5
+FeatureEnvy:
+  enabled: false

data/edmond-danthes.gemspec

@@ -0,0 +1,30 @@
+# -*- encoding: utf-8 -*-
+$LOAD_PATH.unshift File.expand_path('../lib', __FILE__)
+require 'danthes/version'
+Gem::Specification.new do |s|
+  s.name        = 'edmond-danthes'
+  s.version     = Danthes::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.author      = ['Alexander Simonov', 'Dmitry Zuev']
+  s.email       = ['alex@simonov.me', 'mail@dmitryzuev.com']
+  s.homepage    = 'https://github.com/dmitryzuev/edmond-danthes'
+  s.summary     = 'Private pub/sub messaging through Faye.'
+  s.description = 'Private pub/sub messaging in Rails through Faye. More Faye features supported. Based on PrivatePub.'
+  s.files         = `git ls-files`.split($OUTPUT_RECORD_SEPARATOR)
+  s.test_files    = s.files.grep(%r{^(test|spec|features)/})
+  s.require_paths = ['lib']
+  s.add_dependency 'faye',      '>= 1.0.1'
+  s.add_dependency 'faye-redis'
+  s.add_dependency 'yajl-ruby', '>= 1.2.0'
+
+  s.add_development_dependency 'rake'
+  s.add_development_dependency 'guard'
+  s.add_development_dependency 'guard-coffeescript'
+  s.add_development_dependency 'jasmine', '>= 2.0.0'
+  s.add_development_dependency 'rspec', '>= 3.0.0'
+  s.add_development_dependency 'rspec-mocks', '>= 3.0.0'
+  s.add_development_dependency 'webmock'
+  s.add_development_dependency 'coveralls'
+  s.add_development_dependency 'therubyracer'
+  s.add_development_dependency 'rails'
+end

data/lib/danthes.rb

@@ -0,0 +1,123 @@
+require 'digest/sha1'
+require 'net/http'
+require 'net/https'
+require 'yajl/json_gem'
+require 'erb'
+
+require 'danthes/faye_extension'
+
+module Danthes
+  class Error < StandardError; end
+
+  class << self
+    attr_reader :config
+    attr_accessor :env
+
+    # List of accepted options in config file
+    ACCEPTED_KEYS = %w(adapter server secret_token mount signature_expiration timeout)
+
+    # List of accepted options in redis config file
+    REDIS_ACCEPTED_KEYS = %w(host port password database namespace socket)
+
+    # Default options
+    DEFAULT_OPTIONS = { mount: '/faye', timeout: 60, extensions: [FayeExtension.new] }
+
+    # Resets the configuration to the default
+    # Set environment
+    def startup
+      @config = DEFAULT_OPTIONS.dup
+      @env = if defined? ::Rails
+               ::Rails.env
+             else
+               ENV['RAILS_ENV'] || ENV['RACK_ENV'] || 'development'
+             end
+    end
+
+    # Loads the configuration from a given YAML file
+    def load_config(filename)
+      yaml = ::YAML.load(::ERB.new(::File.read(filename)).result)[env]
+      fail ArgumentError, "The #{env} environment does not exist in #{filename}" if yaml.nil?
+      yaml.each do |key, val|
+        config[key.to_sym] = val if ACCEPTED_KEYS.include?(key)
+      end
+    end
+
+    # Loads the options from a given YAML file
+    def load_redis_config(filename)
+      require 'faye/redis'
+      yaml = ::YAML.load(::ERB.new(::File.read(filename)).result)[env]
+      # default redis options
+      options = { type: Faye::Redis, host: 'localhost', port: 6379 }
+      yaml.each do |key, val|
+        options[key.to_sym] = val if REDIS_ACCEPTED_KEYS.include?(key)
+      end
+      config[:engine] = options
+    end
+
+    # Publish the given data to a specific channel. This ends up sending
+    # a Net::HTTP POST request to the Faye server.
+    def publish_to(channel, data)
+      publish_message(message(channel, data))
+    end
+
+    # Sends the given message hash to the Faye server using Net::HTTP.
+    def publish_message(message)
+      fail Error, 'No server specified, ensure danthes.yml was loaded properly.' unless config[:server]
+      url = URI.parse(server_url)
+
+      form = ::Net::HTTP::Post.new(url.path.empty? ? '/' : url.path)
+      form.set_form_data(message: message.to_json)
+
+      http = ::Net::HTTP.new(url.host, url.port)
+      http.use_ssl = url.scheme == 'https'
+      http.start { |h| h.request(form) }
+    end
+
+    # Returns a message hash for sending to Faye
+    def message(channel, data)
+      message = { channel: channel,
+                  data: { channel: channel },
+                  ext: { danthes_token: config[:secret_token] }
+                }
+      if data.is_a? String
+        message[:data][:eval] = data
+      else
+        message[:data][:data] = data
+      end
+      message
+    end
+
+    def server_url
+      [config[:server], config[:mount].gsub(/^\//, '')].join('/')
+    end
+
+    # Returns a subscription hash to pass to the PrivatePub.sign call in JavaScript.
+    # Any options passed are merged to the hash.
+    def subscription(options = {})
+      sub = { server: server_url, timestamp: (Time.now.to_f * 1000).round }.merge(options)
+      sub[:signature] = ::Digest::SHA1.hexdigest([config[:secret_token],
+                                                sub[:channel],
+                                                sub[:timestamp]].join)
+      sub
+    end
+
+    # Determine if the signature has expired given a timestamp.
+    def signature_expired?(timestamp)
+      return false unless config[:signature_expiration]
+      timestamp < ((Time.now.to_f - config[:signature_expiration]) * 1000).round
+    end
+
+    # Returns the Faye Rack application.
+    def faye_app
+      rack_config = {}
+      [:engine, :mount, :ping, :timeout, :extensions, :websocket_extensions ].each do |k|
+        rack_config[k] = config[k] if config[k]
+      end
+      ::Faye::RackAdapter.new(rack_config)
+    end
+  end
+
+  startup
+end
+
+require 'danthes/engine' if defined? ::Rails

data/lib/danthes/engine.rb

@@ -0,0 +1,16 @@
+require 'danthes/view_helpers'
+
+module Danthes
+  class Engine < Rails::Engine
+    # Loads the danthes.yml file if it exists.
+    initializer 'danthes.config' do |app|
+      path = app.root.join('config/danthes.yml')
+      ::Danthes.load_config(path) if path.exist?
+    end
+
+    # Adds the ViewHelpers into ActionView::Base
+    initializer 'danthes.view_helpers' do
+      ActionView::Base.send :include, ViewHelpers
+    end
+  end
+end

data/lib/danthes/faye_extension.rb

@@ -0,0 +1,40 @@
+module Danthes
+  # This class is an extension for the Faye::RackAdapter.
+  # It is used inside of Danthes.faye_app.
+  class FayeExtension
+    # Callback to handle incoming Faye messages. This authenticates both
+    # subscribe and publish calls.
+    def incoming(message, callback)
+      if message['channel'] == '/meta/subscribe'
+        authenticate_subscribe(message)
+      elsif message['channel'] !~ %r{^/meta/}
+        authenticate_publish(message)
+      end
+      callback.call(message)
+    end
+
+    private
+
+    # Ensure the subscription signature is correct and that it has not expired.
+    def authenticate_subscribe(message)
+      subscription = Danthes.subscription(channel: message['subscription'],
+                                          timestamp: message['ext']['danthes_timestamp'])
+      if message['ext']['danthes_signature'] != subscription[:signature]
+        message['error'] = 'Incorrect signature.'
+      elsif Danthes.signature_expired? message['ext']['danthes_timestamp'].to_i
+        message['error'] = 'Signature has expired.'
+      end
+    end
+
+    # Ensures the secret token is correct before publishing.
+    def authenticate_publish(message)
+      if Danthes.config[:secret_token].nil?
+        fail Error, 'No secret_token config set, ensure danthes.yml is loaded properly.'
+      elsif message['ext']['danthes_token'] != Danthes.config[:secret_token]
+        message['error'] = 'Incorrect token.'
+      else
+        message['ext']['danthes_token'] = nil
+      end
+    end
+  end
+end

data/lib/danthes/version.rb

@@ -0,0 +1,3 @@
+module Danthes
+  VERSION = '2.1.0'
+end

data/lib/danthes/view_helpers.rb

@@ -0,0 +1,22 @@
+module Danthes
+  module ViewHelpers
+    # Publish the given data or block to the client by sending
+    # a Net::HTTP POST request to the Faye server. If a block
+    # or string is passed in, it is evaluated as JavaScript
+    # on the client. Otherwise it will be converted to JSON
+    # for use in a JavaScript callback.
+    def publish_to(channel, data = nil, &block)
+      Danthes.publish_to(channel, data || capture(&block))
+    end
+
+    # Subscribe the client to the given channel. This generates
+    # some JavaScript calling Danthes.sign with the subscription
+    # options.
+    def subscribe_to(channel, opts = {})
+      js_tag = opts.delete(:include_js_tag){ true }
+      subscription = Danthes.subscription(channel: channel)
+      content = raw("if (typeof Danthes != 'undefined') { Danthes.sign(#{subscription.to_json}) }")
+      js_tag ? content_tag('script', content, type: 'text/javascript') : content
+    end
+  end
+end

data/lib/generators/danthes/install_generator.rb

@@ -0,0 +1,13 @@
+require 'generators/danthes_generator'
+
+module Danthes
+  module Generators
+    class InstallGenerator < Base
+      desc 'Create sample config file and add rackup file'
+      def copy_files
+        template 'danthes.yml', 'config/danthes.yml'
+        copy_file 'danthes.ru', 'danthes.ru'
+      end
+    end
+  end
+end

data/lib/generators/danthes/redis_install_generator.rb

@@ -0,0 +1,17 @@
+require 'generators/danthes_generator'
+
+module Danthes
+  module Generators
+    class RedisInstallGenerator < Base
+      desc 'Create sample redis config file and add faye-redis gem to Gemfile'
+
+      def copy_files
+        template 'danthes_redis.yml', 'config/danthes_redis.yml'
+      end
+
+      def add_redis_gem
+        add_gem 'faye-redis'
+      end
+    end
+  end
+end

data/lib/generators/danthes_generator.rb

@@ -0,0 +1,24 @@
+require 'rails/generators/base'
+
+module Danthes
+  module Generators
+    class Base < Rails::Generators::Base
+      def self.source_root
+        File.dirname(__FILE__) + '/templates'
+      end
+
+      def self.banner
+        "rails generate danthes:#{generator_name}"
+      end
+
+      private
+
+      def add_gem(name, options = {})
+        gemfile_path = File.join(destination_root, 'Gemfile')
+        gemfile_content = File.read(gemfile_path)
+        File.open(gemfile_path, 'a') { |f| f.write("\n") } unless gemfile_content =~ /\n\Z/
+        gem name, options unless gemfile_content.include? name
+      end
+    end
+  end
+end

data/lib/generators/templates/danthes.ru

@@ -0,0 +1,15 @@
+# Run with: rackup danthes.ru -s thin -E production
+require "bundler/setup"
+require "yaml"
+require "faye"
+require "danthes"
+
+::Danthes.load_config(File.expand_path("../config/danthes.yml", __FILE__))
+Faye::WebSocket.load_adapter(Danthes.config[:adapter])
+
+path = File.expand_path("../config/danthes_redis.yml", __FILE__)
+if File.exist?(path)
+  ::Danthes.load_redis_config(path)
+end
+
+run ::Danthes.faye_app

data/lib/generators/templates/danthes.yml

@@ -0,0 +1,16 @@
+development:
+  adapter: thin
+  server: "http://localhost:9292"
+  secret_token: "secret"
+  mount: '/faye'
+test:
+  adapter: thin
+  server: "http://localhost:9292"
+  secret_token: "secret"
+  mount: '/faye'
+production:
+  adapter: thin
+  server: "http://faye.example.com"
+  mount: '/faye'
+  secret_token: "<%= defined?(SecureRandom) ? SecureRandom.hex(32) : ActiveSupport::SecureRandom.hex(32) %>"
+  signature_expiration: 3600 # one hour

data/lib/generators/templates/danthes_redis.yml

@@ -0,0 +1,14 @@
+development:
+  host: localhost
+  port: 6379
+  namespace: '/danthes'
+test:
+  host: localhost
+  port: 6379
+  namespace: '/danthes'
+production:
+  host: redis_host
+  port: redis_port
+  password: redis_password
+  database: redis_database
+  namespace: '/namespace'

data/spec/coffeescripts/danthesSpec.js.coffee

@@ -0,0 +1,211 @@
+describe "Danthes", ->
+  window.Faye = undefined
+  pub = undefined
+
+  signToChannel = (channel, addOptions = {}) ->
+    sub = {callback: jasmine.createSpy(), errback: jasmine.createSpy()}
+    faye = {subscribe: jasmine.createSpy().and.returnValue(sub)}
+    spyOn(pub, 'faye').and.callFake (callback) ->
+      callback(faye)
+    options = {server: "server", channel: "#{channel}", timestamp: 1234567890, signature: '1234567890'}
+    options['connect'] = addOptions['connect'] if addOptions['connect']?
+    options['error'] = addOptions['error'] if addOptions['error']?
+    pub.sign(options)
+    return [faye, options]
+
+  beforeEach ->
+    pub = window.Danthes
+    pub.reset()
+    script = document.getElementById('faye-connection-script')
+    if script?
+      script.parentNode.removeChild(script)
+
+  it "not adds a subscription callback without signing", ->
+    expect(pub.subscribe("hello", "callback")).toBe(false)
+    expect(pub.subscriptions).toEqual({})
+
+  it "adds a subscription callback", ->
+    signToChannel('hello')
+    pub.subscribe("hello", "callback")
+    expect(pub.subscriptions["hello"]['callback']).toEqual("callback")
+
+  it "has a fayeExtension which adds matching subscription signature and timestamp to outgoing message", ->
+    called = false
+    message = {channel: "/meta/subscribe", subscription: "hello"}
+    pub.subscriptions['hello'] = {}
+    pub.subscriptions['hello']['opts'] = {signature: "abcd", timestamp: "1234"}
+    pub.fayeExtension.outgoing message, (message) ->
+      expect(message.ext.danthes_signature).toEqual("abcd")
+      expect(message.ext.danthes_timestamp).toEqual("1234")
+      called = true
+    expect(called).toBeTruthy()
+
+  it "evaluates javascript in message response", ->
+    pub.handleResponse(eval: 'this.subscriptions.foo = "bar"')
+    expect(pub.subscriptions.foo).toEqual("bar")
+
+  it "triggers callback matching message channel in response", ->
+    called = false
+    signToChannel('test')
+    pub.subscribe "test", (data, channel) ->
+      expect(data).toEqual("abcd")
+      expect(channel).toEqual("test")
+      called = true
+    pub.handleResponse(channel: "test", data: "abcd")
+    expect(called).toBeTruthy()
+
+  it "triggers faye callback function immediately when fayeClient is available", ->
+    called = false
+    pub.fayeClient = "faye"
+    pub.faye (faye) ->
+      expect(faye).toEqual("faye")
+      called = true
+    expect(called).toBeTruthy()
+
+  it "adds fayeCallback when client and server aren't available", ->
+    pub.faye("callback")
+    expect(pub.fayeCallbacks[0]).toEqual("callback")
+
+  it "adds a script tag loading faye js when the server is present", ->
+    client = {addExtension: jasmine.createSpy()}
+    callback = jasmine.createSpy()
+    pub.server = "path/to/faye"
+    pub.faye(callback)
+    expect(pub.fayeCallbacks[0]).toEqual(callback)
+    script = document.getElementById('faye-connection-script')
+    expect(script).toBeDefined()
+    expect(script.type).toEqual("text/javascript")
+    expect(script.src).toMatch("path/to/faye/client.js")
+
+  it "adds a signed channel to subscribe later", ->
+    pub.fayeClient = 'string'
+    [faye, options] = signToChannel('somechannel')
+    expect(faye.subscribe).not.toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.activated).toBeUndefined()
+    expect(pub.subscriptions.somechannel).toBeDefined()
+    expect(pub.subscriptions.somechannel.opts.signature).toEqual('1234567890')
+    expect(pub.subscriptions.somechannel.opts.timestamp).toEqual(1234567890)
+    expect(pub.subscriptions.somechannel.activated).toBeUndefined()
+
+  it "adds a faye subscription with response handler when sign with connect option", ->
+    pub.fayeClient = 'string'
+    [faye, options] = signToChannel('somechannel', {'connect': jasmine.createSpy()})
+    expect(faye.subscribe).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.activated).toBeDefined()
+
+  it "adds a faye subscription with response handler when sign with error option", ->
+    pub.fayeClient = 'string'
+    [faye, options] = signToChannel('somechannel', {'error': jasmine.createSpy()})
+    expect(faye.subscribe).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.activated).toBeDefined()
+
+  it "adds a faye subscription with response handler when first time subscribing", ->
+    pub.fayeClient = 'string'
+    [faye, options] = signToChannel('somechannel')
+    pub.subscribe('somechannel', ->)
+    expect(faye.subscribe).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.activated).toBeDefined()
+
+  it "connects to faye server, adds extension, and executes callbacks", ->
+    callback = jasmine.createSpy()
+    client = {addExtension: jasmine.createSpy()}
+    window.Faye = {}
+    window.Faye.Client = (server) ->
+      expect(server).toEqual("server")
+      return client
+    pub.server = "server"
+    pub.fayeCallbacks.push(callback)
+    spyOn(pub, 'fayeExtension')
+    pub.connectToFaye()
+    expect(pub.fayeClient).toEqual(client)
+    expect(client.addExtension).toHaveBeenCalledWith(pub.fayeExtension)
+    expect(callback).toHaveBeenCalledWith(client)
+
+  it "adds transport to disables", ->
+    expect(pub.disableTransport('websocket')).toBeTruthy()
+    expect(pub.disables).toEqual(['websocket'])
+
+  it "adds transport to disables only one time", ->
+    pub.disableTransport('websocket')
+    pub.disableTransport('websocket')
+    expect(pub.disables).toEqual(['websocket'])
+
+  it "returns false if not accepted transport wants to be disabled", ->
+    expect(pub.disableTransport('websocket123')).toBeUndefined()
+    expect(pub.disables).toEqual([])
+
+  it "connects to faye server, and executes disable once", ->
+    callback = jasmine.createSpy()
+    client = {addExtension: jasmine.createSpy(), disable: jasmine.createSpy()}
+    window.Faye = {}
+    window.Faye.Client = (server) -> client
+    pub.server = "server"
+    pub.disableTransport('websocket')
+    pub.connectToFaye()
+    expect(client.disable).toHaveBeenCalledWith('websocket')
+
+  it "connects to faye server, and executes disable once", ->
+    callback = jasmine.createSpy()
+    client = {addExtension: jasmine.createSpy(), disable: jasmine.createSpy()}
+    window.Faye = {}
+    window.Faye.Client = (server) -> client
+    pub.server = "server"
+    pub.disableTransport('websocket')
+    pub.disableTransport('long-polling')
+    pub.connectToFaye()
+    expect(client.disable).toHaveBeenCalledWith('websocket')
+    expect(client.disable).toHaveBeenCalledWith('long-polling')
+
+  it "adds subscription faye object into channel object", ->
+    sub = {callback: jasmine.createSpy(), errback: jasmine.createSpy()}
+    pub.fayeClient = {subscribe: jasmine.createSpy().and.returnValue(sub)}
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    pub.subscribe("somechannel", jasmine.createSpy())
+    expect(sub.callback).toHaveBeenCalled()
+    expect(sub.errback).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.sub).toEqual(sub)
+
+  it "adds subscription faye object into channel object and call connect callback after connection", ->
+    sub =
+      callback: (f) ->
+        f()
+      errback: jasmine.createSpy()
+    pub.fayeClient = {subscribe: jasmine.createSpy().and.returnValue(sub)}
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    connectSpy = jasmine.createSpy()
+    pub.subscribe('somechannel', jasmine.createSpy(), connect: connectSpy)
+    expect(connectSpy).toHaveBeenCalledWith(sub)
+
+  it "adds subscription faye object into channel object and call error callback after connection", ->
+    sub =
+      callback: jasmine.createSpy()
+      errback: (f) ->
+        f('error')
+    pub.fayeClient = {subscribe: jasmine.createSpy().and.returnValue(sub)}
+    erroSpy = jasmine.createSpy()
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    pub.subscribe("somechannel", jasmine.createSpy(), error: erroSpy)
+    expect(erroSpy).toHaveBeenCalledWith(sub, 'error')
+
+  it "removes subscription to the channel", ->
+    sub = {callback: jasmine.createSpy(), errback: jasmine.createSpy(), cancel: jasmine.createSpy()}
+    pub.fayeClient = {subscribe: jasmine.createSpy().and.returnValue(sub)}
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    pub.subscribe('somechannel', jasmine.createSpy())
+    pub.unsubscribe('somechannel')
+    expect(sub.cancel).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.sub).toBeUndefined()
+
+  it "removes all subscription to the channels", ->
+    sub = {callback: jasmine.createSpy(), errback: jasmine.createSpy(), cancel: jasmine.createSpy()}
+    pub.fayeClient = {subscribe: jasmine.createSpy().and.returnValue(sub)}
+    options = {server: "server", channel: 'somechannel'}
+    pub.sign(options)
+    pub.subscribe "somechannel", jasmine.createSpy()
+    pub.unsubscribeAll()
+    expect(sub.cancel).toHaveBeenCalled()
+    expect(pub.subscriptions.somechannel.sub).toBeUndefined()