whoosh-ruby 0.1.0 → 0.1.2

data/lib/rack/twilio_webhook_authentication.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require 'rack/media_type'
+
+module Rack
+  # Middleware that authenticates webhooks from Twilio using the request
+  # validator.
+  #
+  # The middleware takes an auth token with which to set up the request
+  # validator and any number of paths. When a path matches the incoming request
+  # path, the request will be checked for authentication.
+  #
+  # Example:
+  #
+  # require 'rack'
+  # use Rack::TwilioWebhookAuthentication, ENV['AUTH_TOKEN'], /\/messages/
+  #
+  # The above appends this middleware to the stack, using an auth token saved in
+  # the ENV and only against paths that match /\/messages/. If the request
+  # validates then it gets passed on to the action as normal. If the request
+  # doesn't validate then the middleware responds immediately with a 403 status.
+
+  class TwilioWebhookAuthentication
+    # Rack's FORM_DATA_MEDIA_TYPES can be modified to taste, so we're slightly
+    # more conservative in what we consider form data.
+    FORM_URLENCODED_MEDIA_TYPE = Rack::MediaType.type('application/x-www-form-urlencoded')
+
+    def initialize(app, auth_token, *paths, &auth_token_lookup)
+      @app = app
+      @auth_token = auth_token
+      define_singleton_method(:get_auth_token, auth_token_lookup) if block_given?
+      @path_regex = Regexp.union(paths)
+    end
+
+    def call(env)
+      return @app.call(env) unless env['PATH_INFO'].match(@path_regex)
+      request = Rack::Request.new(env)
+      original_url = request.url
+      params = extract_params!(request)
+      auth_token = @auth_token || get_auth_token(params['AccountSid'])
+      validator = Twilio::Security::RequestValidator.new(auth_token)
+      signature = env['HTTP_X_TWILIO_SIGNATURE'] || ''
+      if validator.validate(original_url, params, signature)
+        @app.call(env)
+      else
+        [
+          403,
+          { 'Content-Type' => 'text/plain' },
+          ['Twilio Request Validation Failed.']
+        ]
+      end
+    end
+
+    # Extract the params from the the request that we can use to determine the
+    # signature. This _may_ modify the passed in request since it may read/rewind
+    # the body.
+    def extract_params!(request)
+      return {} unless request.post?
+
+      if request.media_type == FORM_URLENCODED_MEDIA_TYPE
+        request.POST
+      else
+        request.body.rewind
+        body = request.body.read
+        request.body.rewind
+        body
+      end
+    end
+
+    private :extract_params!
+  end
+end

data/lib/twilio-ruby/base/client_base.rb

@@ -0,0 +1,124 @@
+module Twilio
+  module REST
+    class ClientBase
+      # rubocop:disable Style/ClassVars
+      @@default_region = 'us1'
+      # rubocop:enable Style/ClassVars
+
+      attr_accessor :http_client, :username, :password, :account_sid, :auth_token, :region, :edge, :logger,
+                    :user_agent_extensions
+
+      # rubocop:disable Metrics/ParameterLists
+      def initialize(username = nil, password = nil, account_sid = nil, region = nil, http_client = nil, logger = nil,
+                     user_agent_extensions = nil)
+        @username = username || Twilio.account_sid
+        @password = password || Twilio.auth_token
+        @region = region || Twilio.region
+        @edge = Twilio.edge
+        @account_sid = account_sid || @username
+        @auth_token = @password
+        @auth = [@username, @password]
+        @http_client = http_client || Twilio.http_client || Twilio::HTTP::Client.new
+        @logger = logger || Twilio.logger
+        @user_agent_extensions = user_agent_extensions || []
+      end
+      # rubocop:enable Metrics/ParameterLists
+
+      ##
+      # Makes a request to the Twilio API using the configured http client
+      # Authentication information is automatically added if none is provided
+      # rubocop:disable Lint/ShadowedArgument
+      def request(host, port, method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil) # rubocop:disable Metrics/MethodLength
+        auth ||= @auth
+        headers = generate_headers(method)
+        uri = build_uri(uri)
+
+        if @logger
+          @logger.debug('--BEGIN Twilio API Request--')
+          @logger.debug("Request Method: <#{method}>")
+
+          headers.each do |key, value|
+            @logger.debug("#{key}:#{value}") unless key.downcase == 'authorization'
+          end
+
+          url = URI(uri)
+          @logger.debug("Host:#{url.host}")
+          @logger.debug("Path:#{url.path}")
+          @logger.debug("Query:#{url.query}")
+          @logger.debug("Request Params:#{params}")
+        end
+
+        response = @http_client.request(
+          host,
+          port,
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if @logger
+          @logger.debug("Response Status Code:#{response.status_code}")
+          @logger.debug("Response Headers:#{response.headers}")
+          @logger.debug('--END TWILIO API REQUEST--')
+        end
+
+        response
+      end
+      # rubocop:enable Lint/ShadowedArgument
+
+      ##
+      # Build the final request uri
+      def build_uri(uri)
+        return uri if @region.nil? && @edge.nil?
+
+        parsed_url = URI(uri)
+        pieces = parsed_url.host.split('.')
+        product = pieces[0]
+        domain = pieces[-2, 2]
+        new_edge = @edge
+        new_region = @region
+
+        case pieces.length
+        when 4
+          new_region ||= pieces[1]
+        when 5
+          new_edge ||= pieces[1]
+          new_region ||= pieces[2]
+        end
+
+        new_region = @@default_region if !new_edge.nil? && new_region.nil?
+
+        parsed_url.host = [product, new_edge, new_region, domain].reject(&:nil?).join('.')
+        parsed_url.to_s
+      end
+
+      ##
+      # Validate the new SSL certificate for the Twilio API
+      def validate_ssl_certificate
+        response = request('api.whoosh.totogidemos.com', '8443', 'GET', 'https://api.whoosh.totogidemos.com:8443/.json')
+        return unless response.status_code < 200 || response.status_code >= 300
+
+        raise RestError.new 'Unexpected response from certificate endpoint', response
+      end
+
+      def generate_headers(method)
+        ruby_config = RbConfig::CONFIG
+        headers = {}
+        headers['User-Agent'] =
+          "twilio-ruby/#{Twilio::VERSION} (#{ruby_config['host_os']} #{ruby_config['host_cpu']}) Ruby/#{RUBY_VERSION}"
+        headers['Accept-Charset'] = 'utf-8'
+
+        user_agent_extensions.each { |extension| headers['User-Agent'] += " #{extension}" }
+
+        headers['Content-Type'] = 'application/x-www-form-urlencoded' if method == 'POST' && !headers['Content-Type']
+
+        headers['Accept'] = 'application/json' unless headers['Accept']
+        headers
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/request.rb

@@ -0,0 +1,41 @@
+# frozen_string_literal: true
+
+module Twilio
+  class Request
+    attr_reader :host, :port, :method, :url, :params, :data, :headers, :auth, :timeout
+
+    def initialize(host, port, method, url, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+      @host = host
+      @port = port
+      @url = url
+      @method = method
+      @params = params
+      @data = data
+      @headers = headers
+      @auth = auth
+      @timeout = timeout
+    end
+
+    def to_s
+      auth = @auth.nil? ? '' : '(' + @auth.join(',') + ')'
+
+      params = ''
+      unless @params.nil? || @params.empty?
+        params = '?' + @params.each.map { |key, value| "#{CGI.escape(key)}=#{CGI.escape(value)}" }.join('&')
+      end
+
+      headers = ''
+      unless @headers.nil? || @headers.empty?
+        headers = "\n" + @headers.each.map { |key, value| "-H \"#{key}\": \"#{value}\"" }.join("\n")
+      end
+
+      data = ''
+      unless @data.nil? || @data.empty?
+        data = @method.equal?('GET') ? "\n -G" : "\n"
+        data += @data.each.map { |key, value| "-d \"#{key}\"=\"#{value}\"" }.join("\n")
+      end
+
+      "#{auth} #{@method} #{@url}#{params}#{data}#{headers}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/response.rb

@@ -0,0 +1,18 @@
+# frozen_string_literal: true
+
+module Twilio
+  class Response
+    attr_accessor :status_code, :body, :headers
+
+    def initialize(status_code, body, headers: nil)
+      @status_code = status_code
+      body = '{}' if !body || body.empty?
+      @body = JSON.parse(body)
+      @headers = !headers ? {} : headers.to_hash
+    end
+
+    def to_s
+      "[#{status_code}] #{body}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/domain.rb

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class Domain
+      attr_reader :client
+
+      def initialize(client)
+        @client = client
+        @host = nil
+        @base_url = nil
+        @port = nil
+      end
+
+      def absolute_url(uri)
+        "#{@base_url.chomp('/')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = uri.match(/^http/) ? uri : absolute_url(uri)
+
+        @client.request(
+          @base_url,
+          @port,
+          method,
+          url,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/error.rb

@@ -0,0 +1,39 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class TwilioError < StandardError
+    end
+
+    class RestError < TwilioError
+      attr_reader :message, :response, :code, :status_code, :details, :more_info, :error_message
+
+      def initialize(message, response)
+        @status_code = response.status_code
+        @code = response.body.fetch('code', @status_code)
+        @details = response.body.fetch('details', nil)
+        @error_message = response.body.fetch('message', nil)
+        @more_info = response.body.fetch('more_info', nil)
+        @message = format_message(message)
+        @response = response
+      end
+
+      def to_s
+        message
+      end
+
+      private
+
+      def format_message(initial_message)
+        message = "[HTTP #{status_code}] #{code} : #{initial_message}"
+        message += "\n#{error_message}" if error_message
+        message += "\n#{details}" if details
+        message += "\n#{more_info}" if more_info
+        message + "\n\n"
+      end
+    end
+
+    class ObsoleteError < StandardError
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/helper.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    def url_join(left, right)
+      left = left.sub(/\/+$/, '').sub(/^\/+/, '')
+      right = right.sub(/\/+$/, '').sub(/^\/+/, '')
+      "#{left}/#{right}"
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/obsolete_client.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class ObsoleteClient
+      def initialize(*)
+        raise ObsoleteError, "#{self.class} has been removed from this version of the library. "\
+                             'Please refer to current documentation for guidance.'
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/page.rb

@@ -0,0 +1,103 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    # Page Base Class
+    class Page
+      include Enumerable
+
+      META_KEYS = [
+        'end',
+        'first_page_uri',
+        'next_page_uri',
+        'last_page_uri',
+        'page',
+        'page_size',
+        'previous_page_uri',
+        'total',
+        'num_pages',
+        'start',
+        'uri'
+      ].freeze
+
+      def initialize(version, response)
+        payload = process_response(response)
+
+        @version = version
+        @payload = payload
+        @solution = {}
+        @records = load_page(payload)
+      end
+
+      def process_response(response)
+        if response.status_code != 200
+          raise Twilio::REST::RestError.new('Unable to fetch page', response)
+        end
+
+        response.body
+      end
+
+      def load_page(payload)
+        if payload['meta'] && payload['meta']['key']
+          return payload[payload['meta']['key']]
+        else
+          keys = payload.keys
+          key = keys - META_KEYS
+          return payload[key.first] if key.size == 1
+        end
+
+        raise Twilio::REST::TwilioError, 'Page Records can not be deserialized'
+      end
+
+      def previous_page_url
+        if @payload['meta'] && @payload['meta']['previous_page_url']
+          return @version.domain.absolute_url(URI.parse(@payload['meta']['previous_page_url']).request_uri)
+        elsif @payload['previous_page_uri']
+          return @version.domain.absolute_url(@payload['previous_page_uri'])
+        end
+
+        nil
+      end
+
+      def next_page_url
+        if @payload['meta'] && @payload['meta']['next_page_url']
+          return @version.domain.absolute_url(URI.parse(@payload['meta']['next_page_url']).request_uri)
+        elsif @payload['next_page_uri']
+          return @version.domain.absolute_url(@payload['next_page_uri'])
+        end
+
+        nil
+      end
+
+      def get_instance(payload)
+        raise Twilio::REST::TwilioError, 'Page.get_instance() must be implemented in the derived class'
+      end
+
+      def previous_page
+        return nil unless previous_page_url
+
+        response = @version.domain.request('GET', previous_page_url)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def next_page
+        return nil unless next_page_url
+
+        response = @version.domain.request('GET', next_page_url)
+
+        self.class.new(@version, response, @solution)
+      end
+
+      def each
+        @records.each do |record|
+          yield get_instance(record)
+        end
+      end
+
+      def to_s
+        '#<Page>'
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/resource.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class ListResource
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceContext
+      def initialize(version)
+        @version = version
+      end
+    end
+
+    class InstanceResource
+      def initialize(version)
+        @version = version
+      end
+    end
+  end
+end

data/lib/twilio-ruby/framework/rest/version.rb

@@ -0,0 +1,153 @@
+# frozen_string_literal: true
+
+module Twilio
+  module REST
+    class Version
+      attr_accessor :domain
+
+      class RecordStream
+        include Enumerable
+
+        def initialize(page, limit: nil, page_limit: nil)
+          @page = page
+          @limit = limit
+          @page_limit = page_limit
+        end
+
+        def each
+          current_record = 0
+          current_page = 1
+
+          while @page
+            @page.each do |record|
+              yield record
+              current_record += 1
+              return nil if @limit && @limit <= current_record
+            end
+
+            return nil if @page_limit && @page_limit <= current_page
+
+            @page = @page.next_page
+            current_page += 1
+          end
+        end
+      end
+
+      def initialize(domain)
+        @domain = domain
+        @version = nil
+      end
+
+      def absolute_url(uri)
+        @domain.absolute_url(relative_uri(uri))
+      end
+
+      def relative_uri(uri)
+        "#{@version.chomp('/').gsub(/^\//, '')}/#{uri.chomp('/').gsub(/^\//, '')}"
+      end
+
+      def request(method, uri, params = {}, data = {}, headers = {}, auth = nil, timeout = nil)
+        url = relative_uri(uri)
+        params = params.delete_if { |_k, v| v.nil? }
+        data = data
+        @domain.request(method, url, params, data, headers, auth, timeout)
+      end
+
+      def exception(response, header)
+        Twilio::REST::RestError.new(header, response)
+      end
+
+      def fetch(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        # Note that 3XX response codes are allowed for fetches.
+        if response.status_code < 200 || response.status_code >= 400
+          raise exception(response, 'Unable to fetch record')
+        end
+
+        response.body
+      end
+
+      def update(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to update record')
+        end
+
+        response.body
+      end
+
+      def delete(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to delete record')
+        end
+
+        response.status_code == 204
+      end
+
+      def read_limits(limit = nil, page_size = nil)
+        unless limit.nil? || page_size
+          page_size = limit
+        end
+
+        {
+          limit: limit || nil,
+          page_size: page_size || nil
+        }
+      end
+
+      def page(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        request(
+          method,
+          uri,
+          params,
+          data,
+          headers,
+          auth,
+          timeout
+        )
+      end
+
+      def stream(page, limit: nil, page_limit: nil)
+        RecordStream.new(page, limit: limit, page_limit: page_limit)
+      end
+
+      def create(method, uri, params: {}, data: {}, headers: {}, auth: nil, timeout: nil)
+        response = request(method, uri, params, data, headers, auth, timeout)
+
+        if response.status_code < 200 || response.status_code >= 300
+          raise exception(response, 'Unable to create record')
+        end
+
+        response.body
+      end
+    end
+  end
+end