phoenix_rails 0.0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 7709aaa6258a7487078052fdbe24809e9890152f
+  data.tar.gz: 9b210022272c81b6f95dc80d6bd1e26a754dcc0d
+SHA512:
+  metadata.gz: a272113710ee384f2b5b478ce85b2a5994ac36b9f39bf808ba052630c7aa4ea3c5e10a943a430173a4a9c6c03b191144d3d79fdc4cf07093d32f24772d88dd2e
+  data.tar.gz: b05cc1b45a2afee0b327925bba1b9191383c46f053ed5983089f951ad675d3321436464b7dc3e9f02cd958a20b6462e4d24c1567a9f7e573afe535d7166ef49f

data/lib/phoenix_rails/channel.rb

@@ -0,0 +1,115 @@
+require 'openssl'
+require 'multi_json'
+
+module PhoenixRails
+  # Trigger events on Channels
+  class Channel
+    attr_reader :name
+    INVALID_CHANNEL_REGEX = /[^A-Za-z0-9_\-=@,.;]/
+    def initialize(base_url, name, client = PhoenixRails)
+      @uri = base_url.dup
+      if PhoenixRails::Channel::INVALID_CHANNEL_REGEX.match(name)
+        raise PhoenixRails::Error, "Illegal channel name '#{name}'"
+      end
+      @uri.path = @uri.path + "/channels/#{name}/"
+      @name = name
+      @client = client
+    end
+
+    # Trigger event
+    def trigger!(event_name, data, socket_id = nil)
+      params = {}
+      if socket_id
+        validate_socket_id(socket_id)
+        params[:socket_id] = socket_id
+      end
+      @client.trigger(name, event_name, data, params)
+    end
+
+    # Trigger event, catching and logging any errors.
+    def trigger(event_name, data, socket_id = nil)
+      trigger!(event_name, data, socket_id)
+    rescue PhoenixRails::Error => e
+      PhoenixRails.logger.error("#{e.message} (#{e.class})")
+      PhoenixRails.logger.debug(e.backtrace.join("\n"))
+    end
+
+    # Request users for a presence channel
+    # Only works on presence channels (see: http://PhoenixRails.com/docs/client_api_guide/client_presence_channels and https://PhoenixRails.com/docs/rest_api)
+    #
+    # @example Response
+    #   [{"id"=>"4"}]
+    #
+    # @return [Hash] Array of user hashes for this channel
+    # @raise [PhoenixRails::Error] on invalid PhoenixRails response - see the error message for more details
+    # @raise [PhoenixRails::HTTPError] on any error raised inside Net::HTTP - the original error is available in the original_error attribute
+    #
+    def users
+      @client.get("/channels/#{name}/users")[:users]
+    end
+
+    # Compute authentication string required as part of the authentication
+    # endpoint response. Generally the authenticate method should be used in
+    # preference to this one
+    #
+    # @param socket_id [String] Each PhoenixRails socket connection receives a
+    #   unique socket_id. This is sent from phoenix.js to your server when
+    #   channel authentication is required.
+    # @param custom_string [String] Allows signing additional data
+    # @return [String]
+    #
+    def authentication_string(socket_id, custom_string = nil)
+      validate_socket_id(socket_id)
+
+      unless custom_string.nil? || custom_string.kind_of?(String)
+        raise Error, 'Custom argument must be a string'
+      end
+
+      string_to_sign = [socket_id, name, custom_string].
+        compact.map(&:to_s).join(':')
+      PhoenixRails.logger.debug "Signing #{string_to_sign}"
+      token = @client.authentication_token
+      digest = OpenSSL::Digest::SHA256.new
+      signature = OpenSSL::HMAC.hexdigest(digest, token.secret, string_to_sign)
+
+      return "#{token.key}:#{signature}"
+    end
+
+    # Generate the expected response for an authentication endpoint.
+    #
+    # @example Private channels
+    #   render :json => PhoenixRails['private-my_channel'].authenticate(params[:socket_id])
+    #
+    # @example Presence channels
+    #   render :json => PhoenixRails['private-my_channel'].authenticate(params[:socket_id], {
+    #     :user_id => current_user.id, # => required
+    #     :user_info => { # => optional - for example
+    #       :name => current_user.name,
+    #       :email => current_user.email
+    #     }
+    #   })
+    #
+    # @param socket_id [String]
+    # @param custom_data [Hash] used for example by private channels
+    #
+    # @return [Hash]
+    #
+    # @private Custom data is sent to server as JSON-encoded string
+    #
+    def authenticate(socket_id, custom_data = nil)
+      custom_data = MultiJson.encode(custom_data) if custom_data
+      auth = authentication_string(socket_id, custom_data)
+      r = {:auth => auth}
+      r[:channel_data] = custom_data if custom_data
+      r
+    end
+
+    private
+
+    def validate_socket_id(socket_id)
+      unless socket_id && /\A\d+\.\d+\z/.match(socket_id)
+        raise PhoenixRails::Error, "Invalid socket ID #{socket_id.inspect}"
+      end
+    end
+  end
+end

data/lib/phoenix_rails/client.rb

@@ -0,0 +1,124 @@
+ire 'signature'
+
+module PhoenixRails
+  class Client
+    attr_accessor :scheme, :host, :port, :app_id, :key, :secret
+    attr_writer :connect_timeout, :send_timeout, :receive_timeout, :keep_alive_timeout
+
+
+    def initialize(options = {})
+      options = {
+        :scheme => 'http',
+        :host => 'api.phoenixapp.com',
+        :port => 80,
+      }.merge(options)
+      @scheme, @host, @port, @app_id, @key, @secret = options.values_at(
+        :scheme, :host, :port, :app_id, :key, :secret
+      )
+
+      # Default timeouts
+      @connect_timeout = 5
+      @send_timeout = 5
+      @receive_timeout = 5
+      @keep_alive_timeout = 30
+    end
+
+    def url=(url)
+      uri = URI.parse(url)
+      @scheme = uri.scheme
+      @app_id = uri.path.split('/').last
+      @key    = uri.user
+      @secret = uri.password
+      @host   = uri.host
+      @port   = uri.port
+    end
+
+    def encrypted=(boolean)
+      @scheme = boolean ? 'https' : 'http'
+      # Configure port if it hasn't already been configured
+      @port = boolean ? 443 : 80
+    end
+
+    def encrypted?
+      @scheme == 'https'
+    end
+
+    def timeout=(value)
+      @connect_timeout, @send_timeout, @receive_timeout = value, value, value
+    end
+
+    ## INTERACE WITH THE API ##
+
+    def resource(path)
+      Resource.new(self, path)
+    end
+
+    def get(path, params = {})
+      Resource.new(self, path).get(params)
+    end
+
+    def post(path, params = {})
+      Resource.new(self, path).post(params)
+    end
+
+    def channel(channel_name)
+      raise ConfigurationError, 'Missing client configuration: please check that key, secret and app_id are configured.' unless configured?
+      Channel.new(url, channel_name, self)
+    end
+
+    alias :[] :channel
+
+    def channels(params = {})
+      get('/channels', params)
+    end
+
+    def trigger(channels, event_name, data, params = {})
+      post('/events', trigger_params(channels, event_name, data, params))
+    end
+
+    # @private Construct a net/http http client
+    def http_client
+      @client ||= begin
+        require 'httpclient'
+
+        HTTPClient.new.tap do |c|
+          c.connect_timeout = @connect_timeout
+          c.send_timeout = @send_timeout
+          c.receive_timeout = @receive_timeout
+          c.keep_alive_timeout = @keep_alive_timeout
+        end
+      end
+    end
+
+    private
+
+    def trigger_params(channels, event_name, data, params)
+      channels = Array(channels).map(&:to_s)
+      raise PhoenixRails::Error, "Too many channels (#{channels.length}), max 10" if channels.length > 10
+
+      case data
+        when String
+          encoded_data =  data
+        else
+          begin
+            encoded_data = MultiJson.encode(data)
+          rescue MultiJson::DecodeError => e
+            PhoenixRails.logger.error("Could not convert #{data.inspect} into JSON")
+            raise e
+          end
+      end
+
+      params.merge({
+        :name => event_name,
+        :channels => channels,
+        :data => encoded_data
+      })
+    end
+
+    def configured?
+      host && scheme && key && secret && app_id
+    end
+
+  end
+end
+

data/lib/phoenix_rails/request.rb

@@ -0,0 +1,65 @@
+require 'signature'
+require 'digest/md5'
+require 'multi_json'
+
+module PhoenixRails
+  class Request
+    attr_reader :body, :params
+
+    def initialize(client, verb, uri, params, body = nil)
+      @client, @verb, @uri = client, verb, uri
+      @head = {}
+
+      @body = body
+      if body
+        params[:body_md5] = Digest::MD5.hexdigest(body)
+        @head['Content-Type'] = 'application/json'
+      end
+
+      request = Signature::Request.new(verb.to_s.upcase, uri.path, params)
+      request.sign(client.authentication_token)
+      @params = request.signed_params
+    end
+
+    def send
+      http = @client.http_client
+
+      begin
+        response = http.request(@verb, @uri, @params, @body, @head)
+      rescue HTTPClient::BadResponseError, HTTPClient::TimeoutError,
+        SocketError, Errno::ECONNREFUSED => e
+        error = PhoenixRails::HTTPError.new("#{e.message} (#{e.class})")
+        error.original_error = e
+        raise error
+      end
+
+      body = response.body ? response.body.chomp : nil
+
+      return handle_response(response.code.to_i, body)
+    end
+
+    private
+
+    def handle_response(status_code, body)
+      case status_code
+        when 200
+          return symbolize_first_level(MultiJson.decode(body))
+        when 400
+          raise Error, "Bad request: #{body}"
+        when 401
+          raise AuthenticationError, body
+        when 404
+          raise Error, "404 Not found (#{@uri.path})"
+        else
+          raise Error, "Unknown error (status code #{status_code}): #{body}"
+      end
+    end
+
+    def symbolize_first_level(hash)
+      hash.inject({}) do |result, (key, value)|
+        result[key.to_sym] = value
+        result
+      end
+    end
+  end
+end

data/lib/phoenix_rails/resource.rb

@@ -0,0 +1,27 @@
+module PhoenixRails
+  class Resource
+    def initialize(client, path)
+      @client = client
+      @path = path
+    end
+
+    def get(params)
+      create_request(:get, params).send
+    end
+
+    def post(params)
+      body = MultiJson.encode(params)
+      create_request(:post, {}, body).send
+    end
+
+    private
+
+    def create_request(verb, params, body = nil)
+      Request.new(@client, verb, url, params, body)
+    end
+
+    def url
+      @_url ||= @client.url(@path)
+    end
+  end
+end

data/lib/phoenix_rails.rb

@@ -0,0 +1,41 @@
+class PhoenixRails
+  class Error < RuntimeError; end
+  class AuthenticationError < Error; end
+  class ConfigurationError < Error; end
+  class HTTPError < Error; attr_accessor :original_error; end
+
+  class << self
+    extend Forwardable
+
+    def_delegators :default_client, :scheme, :host, :port, :app_id, :key, :secret
+    def_delegators :default_client, :scheme=, :host=, :port=, :app_id=, :key=, :secret=
+
+    def_delegators :default_client, :authentication_token, :url
+    def_delegators :default_client, :encrypted=, :url=
+    def_delegators :default_client, :timeout=, :connect_timeout=, :send_timeout=, :receive_timeout=, :keep_alive_timeout=
+
+    def_delegators :default_client, :get, :post
+    def_delegators :default_client, :channels, :trigger
+    def_delegators :default_client, :channel, :[]
+
+    def logger
+      @logger ||= begin
+        log = Logger.new($stdout)
+        log.level = Logger::INFO
+        log
+      end
+    end
+
+    def default_client
+      @default_client ||= PhoenixRails::Client.new
+    end
+  end
+
+  if ENV['PHOENIX_RAILS_URL']
+    self.url = ENV['PHOENIX_RAILS_URL']
+  end
+end
+
+require 'pusher/channel'
+require 'pusher/request'
+require 'pusher/resource'

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: phoenix_rails
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- Nguyen Le
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2017-04-22 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: httpclient
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.7'
+- !ruby/object:Gem::Dependency
+  name: multi_json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.0'
+description: Gem for pushing event to a Phoenix server for realtime
+email: nathanle89@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/phoenix_rails.rb
+- lib/phoenix_rails/channel.rb
+- lib/phoenix_rails/client.rb
+- lib/phoenix_rails/request.rb
+- lib/phoenix_rails/resource.rb
+homepage: http://rubygems.org/gems/phoenix_rails
+licenses:
+- MIT
+metadata: {}
+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.5.1
+signing_key: 
+specification_version: 4
+summary: Rails gem for Phoenix integration
+test_files: []