twilio-ruby 5.0.0.rc21 → 5.0.0.rc22

data/lib/twilio-ruby/jwt/client_capability.rb

@@ -0,0 +1,98 @@
+module Twilio
+  module JWT
+    class ClientCapability < BaseJWT
+      attr_accessor :account_sid,
+                    :auth_token,
+                    :client_name,
+                    :scopes
+
+      def initialize(account_sid, auth_token, scopes: [], nbf: nil, ttl: 3600, valid_until: nil)
+        super(secret_key: auth_token, issuer: account_sid, nbf: nbf, ttl: ttl, valid_until: valid_until)
+        @account_sid = account_sid
+        @auth_token = auth_token
+        @client_name = nil
+        @scopes = scopes
+      end
+
+      def add_scope(scope)
+        @scopes.push(scope)
+      end
+
+      def to_s
+        self.to_jwt
+      end
+
+      protected
+      def _generate_payload
+
+        scope = ''
+        unless @scopes.empty?
+          scope = @scopes.map {|scope| scope._generate_payload}.join(' ')
+        end
+
+        payload = {
+            scope: scope
+        }
+
+        payload
+      end
+    end
+
+    module Scope
+      def _generate_payload
+        raise 'Not Implemented'
+      end
+    end
+
+    class IncomingClientScope
+      include Scope
+
+      def initialize(client_name)
+        @client_name = client_name
+      end
+
+      def _generate_payload
+        "scope:client:incoming?clientName" + CGI.escape("=#{@client_name}")
+      end
+
+    end
+
+    class OutgoingClientScope
+      include Scope
+
+      def initialize(application_sid, client_name = nil, params = {})
+        @application_sid = application_sid
+        @client_name = client_name
+        @params = params
+      end
+
+      def _generate_payload
+        prefix = "scope:client:outgoing"
+        application_sid = "appSid=#{@application_sid}"
+        unless @client_name.nil?
+          client_name = "clientName=#{@client_name}"
+        end
+        unless @params.empty?
+          params = "appParams=" + @params.map {|k, v| "#{k}=#{v}"}.join('&')
+        end
+
+        suffix = CGI.escape([application_sid, client_name, params].compact.join('&'))
+
+        [prefix, suffix].join('?')
+      end
+    end
+
+    class EventStreamScope
+      include Scope
+
+      def initialize(filters = {})
+        @filters = filters
+        @filters[:path] = '/2010-04-01/Events'
+      end
+
+      def _generate_payload
+        "scope:stream:subscribe?" + CGI.escape(@filters.map {|k, v| "#{k}=#{v}"}.join('&'))
+      end
+    end
+  end
+end

data/lib/twilio-ruby/jwt/jwt.rb

@@ -0,0 +1,56 @@
+module Twilio
+  module JWT
+    class BaseJWT
+      # valid_until overrides ttl if specified
+      def initialize(secret_key: nil, issuer: nil, subject: nil, nbf: nil, ttl: 3600, valid_until: nil)
+        if secret_key.nil?
+          raise ArgumentError, 'JWT does not have a signing key'
+        end
+
+        @secret_key = secret_key
+        @issuer = issuer
+        @subject = subject
+        @algorithm = 'HS256'
+        @nbf = nbf
+        @ttl = ttl
+        @valid_until = valid_until
+      end
+
+      def _generate_headers
+        {}
+      end
+
+      def _generate_payload
+        fail NotImplementedError
+      end
+
+      def headers
+        headers = self._generate_headers.clone()
+        headers[:typ] = 'JWT'
+        headers[:alg] = @algorithm
+        headers
+      end
+
+      def payload
+        payload = self._generate_payload.clone()
+
+        payload[:iss] = @issuer
+        payload[:nbf] = @nbf || Time.now.to_i
+
+        if @valid_until.nil?
+          payload[:exp] = Time.now.to_i + @ttl
+        else
+          payload[:exp] = @valid_until
+        end
+
+        payload[:sub] = @subject unless @subject.nil?
+        payload
+      end
+
+      def to_jwt
+        ::JWT.encode self.payload, @secret_key, @algorithm, self.headers
+      end
+
+    end
+  end
+end

data/lib/twilio-ruby/jwt/task_router.rb

@@ -1,202 +1,171 @@
 module Twilio
   module JWT
-    class TaskRouterCapability
-      TASK_ROUTER_BASE_URL = 'https://taskrouter.twilio.com'
+    class TaskRouterCapability < BaseJWT
       TASK_ROUTER_VERSION = 'v1'
-      TASK_ROUTER_WEBSOCKET_BASE_URL = 'https://event-bridge.twilio.com/v1/wschannels'
-
-      REQUIRED = {required: true}
-      OPTIONAL = {required: false}
-
-      def initialize(account_sid, auth_token, workspace_sid, channel_id)
+      def initialize(account_sid, auth_token, workspace_sid, channel_id, nbf: nil, ttl: 3600, valid_until: nil)
+        super(secret_key: auth_token,
+              issuer: account_sid,
+              nbf: nbf,
+              ttl: ttl,
+              valid_until: valid_until
+        )
         @account_sid = account_sid
         @auth_token = auth_token
-        @policies = []
-
         @workspace_sid = workspace_sid
         @channel_id = channel_id
-
-        @base_url = "#{TASK_ROUTER_BASE_URL}/#{TASK_ROUTER_VERSION}/Workspaces/#{workspace_sid}"
-
-        validate_jwt
-
-        setup_resource
-
-        allow_websocket_requests(@channel_id)
-        allow(@resource_url, 'GET')
-      end
-
-      def allow_fetch_subresources
-        allow(@resource_url + '/**', 'GET')
-      end
-
-      def allow_updates
-        allow(@resource_url, 'POST')
-      end
-
-      def allow_updates_subresources
-        allow(@resource_url + '/**', 'POST')
-      end
-
-      def allow_delete
-        allow(@resource_url, 'DELETE')
-      end
-
-      def allow_delete_subresources
-        allow(@resource_url + '/**', 'DELETE')
+        @policies = []
       end
 
-      def add_policy(url, method, allowed = true, query_filters = nil, post_filters = nil)
-        policy = {
-            url: url,
-            method: method,
-            query_filter: query_filters || {},
-            post_filter: post_filters || {},
-            allow: allowed
-        }
-
+      def add_policy(policy)
         @policies.push(policy)
       end
 
-      def allow(url, method, query_filters = nil, post_filters = nil)
-        add_policy(url, method, true, query_filters, post_filters)
+      def to_s
+        to_jwt
       end
 
-      def deny(url, method, query_filters = nil, post_filters = nil)
-        add_policy(url, method, false, query_filters, post_filters)
-      end
+      protected
+      def _generate_payload
+        Twilio::JWT::TaskRouterUtils.web_socket_policies(@account_sid, @channel_id).each {|policy| self.add_policy(policy)}
+        policies = @policies.map{ |policy| policy._generate_payload}
 
-      def generate_token(ttl = 3600)
-        task_router_attributes = {
+        payload = {
             account_sid: @account_sid,
             workspace_sid: @workspace_sid,
-            channel: @channel_id
+            channel: @channel_id,
+            version: TASK_ROUTER_VERSION,
+            friendly_name: @channel_id,
+            policies: policies
         }
 
         if @channel_id[0..1] == 'WK'
-          task_router_attributes[:worker_sid] = @channel_id
+          payload[:worker_sid] = @channel_id
         elsif @channel_id[0..1] == 'WQ'
-          task_router_attributes[:taskqueue_sid] = @channel_id
+          payload[:taskqueue_sid] = @channel_id
         end
 
-        generate_token_protected(ttl, task_router_attributes)
+        payload
       end
+    end
 
-      protected
+    class Policy
+      attr_accessor :url,
+                    :method,
+                    :allowed,
+                    :post_filters,
+                    :query_filters
 
-      def generate_token_protected(ttl = 3600, extra_attributes)
-        payload = {
-            iss: @account_sid,
-            exp: (Time.now.to_i + ttl),
-            version: TASK_ROUTER_VERSION,
-            friendly_name: @channel_id,
-            policies: @policies,
-        }
-        extra_attributes.each { |key, value|
-          payload[key] = value
-        }
-
-        ::JWT.encode payload, @auth_token
+      def initialize(url, method, allowed, post_filters={}, query_filters={})
+        @url = url
+        @method = method
+        @allowed = allowed
+        @post_filters = post_filters
+        @query_filters = query_filters
       end
 
-      def setup_resource
-        if @channel_id[0..1] == 'WS'
-          @resource_url = @base_url
-        elsif @channel_id[0..1] == 'WK'
-          @resource_url = @base_url + '/Workers/' + @channel_id
-
-          @activity_url = @base_url + '/Activities'
-          allow(@activity_url, 'GET')
+      def _generate_payload
+        policy = {
+            url: @url,
+            method: @method,
+            query_filter: @query_filters,
+            post_filter: @post_filters,
+            allow: @allowed
+        }
+        policy
+      end
 
-          @tasks_url = @base_url + '/Tasks/**'
-          allow(@tasks_url, 'GET')
+    end
 
-          @worker_reservations_url = @resource_url + '/Reservations/**'
-          allow(@worker_reservations_url, 'GET')
+    class TaskRouterUtils
+      TASK_ROUTER_VERSION = 'v1'
+      TASK_ROUTER_BASE_URL = 'https://taskrouter.twilio.com'
+      TASK_ROUTER_WEBSOCKET_BASE_URL = 'https://event-bridge.twilio.com/v1/wschannels'
 
-        elsif @channel_id[0..1] == 'WQ'
-          @resource_url = @base_url + '/TaskQueues/' + @channel_id
-        end
+      def self.workspaces
+        [TASK_ROUTER_BASE_URL, TASK_ROUTER_VERSION, 'Workspaces'].join('/')
       end
 
-      def allow_websocket_requests(channel_id)
-        worker_url = "#{TASK_ROUTER_WEBSOCKET_BASE_URL}/#{@account_sid}/#{channel_id}"
-        ['GET', 'POST'].each do |meth|
-          add_policy(worker_url, meth)
-        end
+      def self.workspace(worskspace_sid)
+        [TASK_ROUTER_BASE_URL, TASK_ROUTER_VERSION, 'Workspaces', worskspace_sid].join('/')
       end
 
-      def validate_jwt
-        if @account_sid.nil? or @account_sid[0..1] != 'AC'
-          raise "Invalid AccountSid provided #{@account_sid}"
-        end
-        if @workspace_sid.nil? or @workspace_sid[0..1] != 'WS'
-          raise "Invalid WorkspaceSid provided #{@workspace_sid}"
-        end
-        if @channel_id.nil?
-          raise 'ChannelId not provided'
-        end
-        @prefix = @channel_id[0..1]
-        if @prefix != 'WS' and @prefix != 'WK' and @prefix != 'WQ'
-          raise "Invalid ChannelId provided: #{@channel_id}"
-        end
+      def self.all_workspaces
+        [TASK_ROUTER_BASE_URL, TASK_ROUTER_VERSION, 'Workspaces', '**'].join('/')
       end
-    end
 
-    class WorkerCapability < TaskRouterCapability
+      def self.tasks(workspace_sid)
+        [self.workspace(workspace_sid), 'Tasks'].join('/')
+      end
 
-      def initialize(account_sid, auth_token, workspace_sid, worker_sid)
-        super(account_sid, auth_token, workspace_sid, worker_sid)
-        @tasks_url = @base_url + '/Tasks/**'
-        @activity_url = @base_url + '/Activities'
-        @worker_reservations_url = @resource_url + '/Reservations/**'
+      def self.task(workspace_sid, tasks_sid)
+        [self.workspace(workspace_sid), 'Tasks', tasks_sid].join('/')
+      end
 
-        allow(@activity_url, 'GET')
-        allow(@tasks_url, 'GET')
-        allow(@worker_reservations_url, 'GET')
+      def self.all_tasks(workspace_sid)
+        [self.workspace(workspace_sid), 'Tasks', '**'].join('/')
       end
 
-      def allow_activity_updates
-        allow(@resource_url, 'POST', nil, {ActivitySid: REQUIRED})
+      def self.task_queues(workspace_sid)
+        [self.workspace(workspace_sid), 'TaskQueues'].join('/')
       end
 
-      def allow_reservation_updates
-        allow(@tasks_url, 'POST', nil, nil)
-        allow(@worker_reservations_url, 'POST', nil, nil)
+      def self.task_queue(workspace_sid, taskqueue_sid)
+        [self.workspace(workspace_sid), 'TaskQueues', taskqueue_sid].join('/')
       end
 
-      protected
+      def self.all_task_queues(workspace_sid)
+        [self.workspace(workspace_sid), 'TaskQueues', '**'].join('/')
+      end
 
-      def setup_resource
-        @resource_url = @base_url + '/Workers/' + @channel_id
+      def self.activities(workspace_sid)
+        [self.workspace(workspace_sid), 'Activities'].join('/')
       end
 
-    end
+      def self.activity(workspace_sid, activity_sid)
+        [self.workspace(workspace_sid), 'Activities', activity_sid].join('/')
+      end
 
-    class WorkspaceCapability < TaskRouterCapability
+      def self.all_activities(workspace_sid)
+        [self.workspace(workspace_sid), 'Activities', '**'].join('/')
+      end
 
-      def initialize(account_sid, auth_token, workspace_sid)
-        super(account_sid, auth_token, workspace_sid, workspace_sid)
+      def self.workers(workspace_sid)
+        [self.workspace(workspace_sid), 'Workers'].join('/')
       end
 
-      protected
+      def self.worker(workspace_sid, worker_sid)
+        [self.workspace(workspace_sid), 'Workers', worker_sid].join('/')
+      end
 
-      def setup_resource
-        @resource_url = @base_url
+      def self.all_workers(workspace_sid)
+        [self.workspace(workspace_sid), 'Workers', '**'].join('/')
       end
 
-    end
+      def self.reservations(workspace_sid, worker_sid)
+        [self.worker(workspace_sid, worker_sid), 'Reservations'].join('/')
+      end
 
-    class TaskQueueCapability < TaskRouterCapability
+      def self.reservation(workspace_sid, worker_sid, reservation_sid)
+        [self.worker(workspace_sid, worker_sid), 'Reservations', reservation_sid].join('/')
+      end
 
-      def initialize(account_sid, auth_token, workspace_sid, taskqueue_sid)
-        super(account_sid, auth_token, workspace_sid, taskqueue_sid)
+      def self.all_reservations(workspace_sid, worker_sid)
+        [self.worker(workspace_sid, worker_sid), 'Reservations', '**'].join('/')
       end
 
-      protected
+      def self.web_socket_policies(account_sid, channel_sid)
+        url = [TASK_ROUTER_WEBSOCKET_BASE_URL, account_sid, channel_sid].join('/')
+        get = Policy.new(url, 'GET', true)
+        post = Policy.new(url, 'POST', true)
+        [get, post]
+      end
 
-      def setup_resource
-        @resource_url = @base_url + '/TaskQueues/' + @channel_id
+      def self.worker_policies(workspace_sid, worker_sid)
+        activities = Policy.new(self.activities(workspace_sid), 'GET', true)
+        tasks = Policy.new(self.all_tasks(workspace_sid), 'GET', true)
+        reservations = Policy.new(self.all_reservations(workspace_sid, worker_sid), 'GET', true)
+        fetch = Policy.new(self.worker(workspace_sid, worker_sid), 'GET', true)
+        [activities, tasks, reservations, fetch]
       end
     end
   end