restcomm-ruby 1.2.0

data/lib/restcomm-ruby/rest/utils.rb

@@ -0,0 +1,49 @@
+module Restcomm
+  module REST
+    module Utils
+
+      def restify(something)
+        return key_map(something, :restify) if something.is_a?  Hash
+        string = something.to_s
+        string.split('_').map do |string_part|
+          string_part[0,1].capitalize + string_part[1..-1]
+        end.join
+      end
+
+      def derestify(something)
+        return key_map(something, :derestify) if something.is_a?  Hash
+        string = something.to_s
+        string = string[0,1].downcase + string[1..-1]
+        string.gsub(/[A-Z][a-z]*/) { |s| "_#{s.downcase}" }
+      end
+
+      protected
+
+      def resource(*resources)
+        custom_resource_names = { sms: 'SMS', sip: 'SIP' }
+        resources.each do |r|
+          resource = restify r
+          relative_path = custom_resource_names.fetch(r, resource)
+          path = "#{@path}/#{relative_path}"
+          enclosing_module = if @submodule == nil
+            Restcomm::REST
+          else
+            Restcomm::REST.const_get(@submodule)
+          end
+          resource_class = enclosing_module.const_get resource
+          instance_variable_set("@#{r}", resource_class.new(path, @client))
+        end
+        self.class.instance_eval { attr_reader *resources }
+      end
+
+      private
+
+      def key_map(something, method)
+        something = something.to_a.flat_map do |pair|
+          [send(method, pair[0]).to_sym, pair[1]]
+        end
+        Hash[*something]
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/task_router/capability.rb

@@ -0,0 +1,87 @@
+module Restcomm
+  module TaskRouter
+    class Capability
+
+      TASK_ROUTER_BASE_URL = 'https://taskrouter.restcomm.com'
+      TASK_ROUTER_VERSION = 'v1'
+      TASK_ROUTER_WEBSOCKET_BASE_URL = 'https://event-bridge.restcomm.com/v1/wschannels'
+
+      REQUIRED = {required: true}
+      OPTIONAL = {required: false}
+
+      def initialize(account_sid, auth_token, workspace_sid, worker_sid)
+        @account_sid = account_sid
+        @auth_token = auth_token
+        @workspace_sid = workspace_sid
+        @worker_sid = worker_sid
+        @policies = []
+        allow_websocket_requests
+        allow_activity_list_fetch
+      end
+
+      def workspace_url
+        "#{TASK_ROUTER_BASE_URL}/#{TASK_ROUTER_VERSION}/Workspaces/#{@workspace_sid}"
+      end
+
+      def worker_url
+        "#{workspace_url}/Workers/#{@worker_sid}"
+      end
+
+      def allow_worker_activity_updates
+        add_policy(worker_url, "POST", nil, {ActivitySid: REQUIRED})
+      end
+
+      def allow_worker_fetch_attributes
+        add_policy(worker_url, "GET")
+      end
+
+      def allow_task_reservation_updates
+        task_url = "#{workspace_url}/Tasks/**"
+        add_policy(task_url, "POST", nil, {ReservationStatus: REQUIRED})
+      end
+
+      def add_policy(url, method, query_filters = nil, post_filters = nil, allowed = true)
+        policy = {
+          url: url,
+          method: method,
+          query_filter: query_filters || {},
+          post_filter: post_filters || {},
+          allow: allowed
+        }
+
+        @policies.push(policy)
+      end
+
+      def generate_token(ttl = 3600)
+        payload = {
+          iss: @account_sid,
+          exp: (Time.now.to_i + ttl),
+          version: @version,
+          friendly_name: @worker_sid,
+          policies: @policies,
+          account_sid: @account_sid,
+          worker_sid: @worker_sid,
+          channel: @worker_sid,
+          workspace_sid: @workspace_sid
+        }
+
+        JWT.encode payload, @auth_token
+      end
+
+      protected
+
+      def allow_websocket_requests
+        worker_url = "#{TASK_ROUTER_WEBSOCKET_BASE_URL}/#{@account_sid}/#{@worker_sid}"
+        ['GET', 'POST'].each do |meth|
+          add_policy(worker_url, meth)
+        end
+      end
+
+      def allow_activity_list_fetch
+        url = "#{workspace_url}/Activities"
+        add_policy(url, 'GET')
+      end
+
+    end
+  end
+end

data/lib/restcomm-ruby/twiml/response.rb

@@ -0,0 +1,16 @@
+module Restcomm
+  module RCML
+    class Response
+
+      attr_reader :text
+      alias_method :to_xml , :text
+
+      def initialize(&block)
+        xml = Builder::XmlMarkup.new
+        xml.instruct!
+        @text = xml.Response &block
+      end
+
+    end
+  end
+end

data/lib/restcomm-ruby/util.rb

@@ -0,0 +1,15 @@
+module Restcomm
+  module Util
+    def url_encode(hash)
+      hash.to_a.map {|p| p.map {|e| CGI.escape get_string(e)}.join '='}.join '&'
+    end
+
+    def get_string(obj)
+      if obj.respond_to?(:strftime)
+        obj.strftime('%Y-%m-%d')
+      else
+        obj.to_s
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/util/capability.rb

@@ -0,0 +1,64 @@
+module Restcomm
+  module Util
+    class Capability
+
+      include Restcomm::Util
+
+      def initialize(account_sid = nil, auth_token = nil)
+        @account_sid = account_sid || Restcomm.account_sid
+        @auth_token = auth_token || Restcomm.auth_token
+        if @account_sid.nil? || @auth_token.nil?
+          raise ArgumentError, 'Account SID and auth token are required'
+        end
+        @capabilities = []
+      end
+
+      def allow_client_incoming(client_name)
+        @client_name = client_name # stash for use in outgoing
+        scope_params = { 'clientName' => client_name }
+        @capabilities << scope_uri_for('client', 'incoming', scope_params)
+      end
+
+      def allow_client_outgoing(app_sid, params = {})
+        @allow_client_outgoing = true
+        @outgoing_scope_params = { 'appSid' => app_sid }
+        unless params.empty?
+          @outgoing_scope_params['appParams'] = url_encode params
+        end
+      end
+
+      def allow_event_stream(filters = {})
+        scope_params = { 'path' => '/2010-04-01/Events' }
+        scope_params['params'] = filters unless filters.empty?
+        @capabilities << scope_uri_for('stream', 'subscribe', scope_params)
+      end
+
+      def scope_uri_for(service, privilege, params = {})
+        scope_uri = "scope:#{service}:#{privilege}"
+        scope_uri << "?#{url_encode(params)}" unless params.empty?
+      end
+
+      def generate(ttl = 3600)
+
+        capabilities = @capabilities.clone # we need a local copy to work on
+
+        # build the outgoing scope lazily so that we can use @client_name
+        if @allow_client_outgoing
+          params = @outgoing_scope_params
+          params.merge!('clientName' => @client_name) if @client_name
+          capabilities << scope_uri_for('client', 'outgoing', params)
+        end
+
+        payload = {
+          'scope' => capabilities.join(' '),
+          'iss' => @account_sid,
+          'exp' => (Time.now.to_i + ttl),
+        }
+
+        JWT.encode payload, @auth_token
+
+      end
+
+    end
+  end
+end

data/lib/restcomm-ruby/util/configuration.rb

@@ -0,0 +1,7 @@
+module Restcomm
+  module Util
+    class Configuration
+      attr_accessor :account_sid, :auth_token
+    end
+  end
+end

data/lib/restcomm-ruby/util/request_validator.rb

@@ -0,0 +1,37 @@
+module Restcomm
+  module Util
+    class RequestValidator
+
+      def initialize(auth_token = nil)
+        @auth_token = auth_token || Restcomm.auth_token
+        raise ArgumentError, 'Auth token is required' if @auth_token.nil?
+      end
+
+      def validate(url, params, signature)
+        expected = build_signature_for url, params
+        secure_compare(expected, signature)
+      end
+
+      def build_signature_for(url, params)
+        data = url + params.sort.join
+        digest = OpenSSL::Digest.new('sha1')
+        Base64.encode64(OpenSSL::HMAC.digest(digest, @auth_token, data)).strip
+      end
+
+      private
+
+      # Compares two strings in constant time to avoid timing attacks.
+      # Borrowed from ActiveSupport::MessageVerifier.
+      # https://github.com/rails/rails/blob/master/activesupport/lib/active_support/message_verifier.rb
+      def secure_compare(a, b)
+        return false unless a.bytesize == b.bytesize
+
+        l = a.unpack("C#{a.bytesize}")
+
+        res = 0
+        b.each_byte { |byte| res |= byte ^ l.shift }
+        res == 0
+      end
+    end
+  end
+end

data/lib/restcomm-ruby/version.rb

@@ -0,0 +1,3 @@
+module Restcomm
+  VERSION = '1.2.0'
+end

data/restcomm-ruby.gemspec

@@ -0,0 +1,34 @@
+# coding: utf-8
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'restcomm-ruby/version'
+
+Gem::Specification.new do |spec|
+  spec.name          = 'restcomm-ruby'
+  spec.version       = Restcomm::VERSION
+  spec.authors       = ['Andrew Benton']
+  spec.email         = ['andrew@twilio.com']
+  spec.summary       = 'A simple library for communicating with the Restcomm REST API, building RCML, and generating Restcomm Client Capability Tokens'
+  spec.description   = 'A simple library for communicating with the Restcomm REST API, building RCML, and generating Restcomm Client Capability Tokens'
+  spec.homepage      = 'http://github.com/restcomm/restcomm-ruby'
+  spec.license       = 'MIT'
+
+  spec.files         = `git ls-files -z`.split("\x0")
+  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
+  spec.test_files    = spec.files.grep(%r{^(test|spec|features)/})
+  spec.require_paths = ['lib']
+  spec.required_ruby_version = '>= 1.9.3'
+  spec.extra_rdoc_files = ['README.md', 'LICENSE.md']
+  spec.rdoc_options = ['--line-numbers', '--inline-source', '--title', 'restcomm-ruby', '--main', 'README.md']
+
+  spec.add_dependency('multi_json', '>= 1.3.0')
+  spec.add_dependency('builder', '>= 2.1.2')
+  spec.add_dependency('jwt', '~> 1.0')
+  spec.add_dependency('jruby-openssl') if RUBY_PLATFORM == 'java'
+  # Workaround for RBX <= 2.2.1, should be fixed in next version
+  spec.add_dependency('rubysl') if defined?(RUBY_ENGINE) && RUBY_ENGINE == 'rbx'
+
+  spec.add_development_dependency 'bundler', '~> 1.5'
+  spec.extra_rdoc_files = ['README.md', 'LICENSE.md']
+  spec.rdoc_options = ['--line-numbers', '--inline-source', '--title', 'restcomm-ruby', '--main', 'README.md']
+end

data/spec/rack/twilio_webhook_authentication_spec.rb

@@ -0,0 +1,110 @@
+require 'spec_helper'
+require 'rack/mock'
+
+describe Rack::RestcommWebhookAuthentication do
+  before do
+    @app = lambda {|env| [200, {'Content-Type' => 'text/plain'}, ['Hello']] }
+  end
+
+  describe 'new' do
+    it 'should initialize with an app, auth token and a path' do
+      expect {
+        Rack::RestcommWebhookAuthentication.new(@app, 'ABC', /\/voice/)
+      }.not_to raise_error
+    end
+
+    it 'should initialize with an app, auth token and paths' do
+      expect {
+        Rack::RestcommWebhookAuthentication.new(@app, 'ABC', /\/voice/, /\/sms/)
+      }.not_to raise_error
+    end
+
+    it 'should initialize with an app, dynamic token and paths' do
+      expect {
+        Rack::RestcommWebhookAuthentication.new(@app, nil, /\/voice/, /\/sms/)
+      }.not_to raise_error
+    end
+  end
+
+  describe 'calling against one path with dynamic auth token' do
+    it 'should allow a request through if it validates' do
+      auth_token = 'qwerty'
+      account_sid = 12345
+      expect_any_instance_of(Rack::Request).to receive(:post?).and_return(true)
+      expect_any_instance_of(Rack::Request).to receive(:POST).and_return({'AccountSid' => account_sid})
+      @middleware = Rack::RestcommWebhookAuthentication.new(@app, nil, /\/voice/) { |asid| auth_token}
+      request_validator = double('RequestValidator')
+      expect(Restcomm::Util::RequestValidator).to receive(:new).with(auth_token).and_return(request_validator)
+      expect(request_validator).to receive(:validate).and_return(true)
+      request = Rack::MockRequest.env_for('/voice')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+  end
+
+  describe 'calling against one path' do
+    before do
+      @middleware = Rack::RestcommWebhookAuthentication.new(
+        @app, 'ABC', /\/voice/
+      )
+    end
+
+    it 'should not intercept when the path doesn\'t match' do
+      expect(Restcomm::Util::RequestValidator).to_not receive(:validate)
+      request = Rack::MockRequest.env_for('/sms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'should allow a request through if it validates' do
+      expect_any_instance_of(Restcomm::Util::RequestValidator).to(
+        receive(:validate).and_return(true)
+      )
+      request = Rack::MockRequest.env_for('/voice')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'should short circuit a request to 403 if it does not validate' do
+      expect_any_instance_of(Restcomm::Util::RequestValidator).to(
+        receive(:validate).and_return(false)
+      )
+      request = Rack::MockRequest.env_for('/voice')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(403)
+    end
+  end
+
+  describe 'calling against many paths' do
+    before do
+      @middleware = Rack::RestcommWebhookAuthentication.new(
+        @app, 'ABC', /\/voice/, /\/sms/
+      )
+    end
+
+    it 'should not intercept when the path doesn\'t match' do
+      expect(Restcomm::Util::RequestValidator).to_not receive(:validate)
+      request = Rack::MockRequest.env_for('icesms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'shold allow a request through if it validates' do
+      expect_any_instance_of(Restcomm::Util::RequestValidator).to(
+        receive(:validate).and_return(true)
+      )
+      request = Rack::MockRequest.env_for('/sms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(200)
+    end
+
+    it 'should short circuit a request to 403 if it does not validate' do
+      expect_any_instance_of(Restcomm::Util::RequestValidator).to(
+        receive(:validate).and_return(false)
+      )
+      request = Rack::MockRequest.env_for('/sms')
+      status, headers, body = @middleware.call(request)
+      expect(status).to be(403)
+    end
+  end
+end

data/spec/rest/account_spec.rb

@@ -0,0 +1,89 @@
+require 'spec_helper'
+
+describe Restcomm::REST::Account do
+
+  before do
+    @account = Restcomm::REST::Account.new('someUri', 'someClient')
+  end
+
+  it 'sets up incoming phone numbers resources object' do
+    expect(@account).to respond_to(:incoming_phone_numbers)
+    expect(@account.incoming_phone_numbers.instance_variable_get('@path')).to(
+      eq('someUri/IncomingPhoneNumbers')
+    )
+  end
+
+  it 'sets up an available phone numbers resources object' do
+    expect(@account).to respond_to(:available_phone_numbers)
+    expect(@account.available_phone_numbers.instance_variable_get('@path')).to(
+      eq('someUri/AvailablePhoneNumbers')
+    )
+  end
+
+  it 'sets up an outgoing caller ids resources object' do
+    expect(@account).to respond_to(:outgoing_caller_ids)
+    expect(@account.outgoing_caller_ids.instance_variable_get('@path')).to eq(
+      'someUri/OutgoingCallerIds'
+    )
+  end
+
+  it 'sets up a calls resources object' do
+    expect(@account).to respond_to(:calls)
+    expect(@account.calls.instance_variable_get('@path')).to eq('someUri/Calls')
+  end
+
+  it 'sets up a conferences resources object' do
+    expect(@account).to respond_to(:conferences)
+    expect(@account.conferences.instance_variable_get('@path')).to eq(
+      'someUri/Conferences'
+    )
+  end
+
+  it 'sets up a queues resources object' do
+    expect(@account).to respond_to(:queues)
+    expect(@account.queues.instance_variable_get('@path')).to eq(
+      'someUri/Queues'
+    )
+  end
+
+  it 'sets up a sms resource object' do
+    expect(@account).to respond_to(:sms)
+    expect(@account.sms.instance_variable_get('@path')).to eq('someUri/SMS')
+  end
+
+  it 'sets up a recordings resources object' do
+    expect(@account).to respond_to(:recordings)
+    expect(@account.recordings.instance_variable_get('@path')).to eq(
+      'someUri/Recordings'
+    )
+  end
+
+  it 'sets up a transcriptions resources object' do
+    expect(@account).to respond_to(:transcriptions)
+    expect(@account.transcriptions.instance_variable_get('@path')).to eq(
+      'someUri/Transcriptions'
+    )
+  end
+
+  it 'sets up a notifications resources object' do
+    expect(@account).to respond_to(:notifications)
+    expect(@account.notifications.instance_variable_get('@path')).to eq(
+      'someUri/Notifications'
+    )
+  end
+
+  it 'sets up a tokens resources object' do
+    expect(@account).to respond_to(:tokens)
+    expect(@account.tokens.instance_variable_get('@path')).to eq(
+      'someUri/Tokens'
+    )
+  end
+
+  it 'sets up an addresses resources object' do
+    expect(@account).to respond_to(:addresses)
+    expect(@account.addresses.instance_variable_get('@path')).to eq(
+      'someUri/Addresses'
+    )
+  end
+
+end