unrestful 0.1.3 → 0.1.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f1f85b74343e706d02705c4994bb54bf9433697b273eff7f28e451c21516fea8
-  data.tar.gz: b274e109d89b2d89806269627fde55a916bf0b83e4e68f4bea6fe73bbd224caa
+  metadata.gz: 8ed14da4951593e6b5461d2d776a16097b46ed7495ab60ca7cae9c24fc778bdc
+  data.tar.gz: 2f9dd412dcae54e6a86fff857752898d1f654f2d6acf7cf5f1d7e6d8f6c87bf1
 SHA512:
-  metadata.gz: 8889f208b5d6fc05ec1516fcd14b85c0392fef74f379f4f35d7ce8d66404741d93ee3f7d0171f7d777312c90c6235ead34085f52a8628da841b680ad99a9ccf3
-  data.tar.gz: 45f21e549c14e1497776463adf39704002ea6e2e0351be0224da1095b29ec71fdb93a7ad0d88e462be96bbb4620f87d2fcbe9bfa74fd4053b1a36fba788a2998
+  metadata.gz: f58bde1f04744005aeec13d1e46c1002c66de852086b1da36843d66fe501320339f1d8e63e2c5c6380e9943b0abaa13f16a8035a6e9f7d5a0ee55e1622e05f33
+  data.tar.gz: d816f606a7aa1e36857c046e76df687d7866d4df5b35085f58642ac7ad9a39b430f737ea1dc6f16ecee0c599acfb85bb4e1a3191b4a131f5f139f1f48ac5fffe

data/lib/unrestful/async_job.rb

@@ -1,111 +1,111 @@
 require 'redis'
 
 module Unrestful
-	class AsyncJob
-		include ActiveModel::Serializers::JSON
-
-		ALLOCATED = 0
-		RUNNING = 1
-		FAILED = 2
-		SUCCESS = 3
-
-		KEY_TIMEOUT = 3600
-		KEY_LENGTH = 10
-		CHANNEL_TIMEOUT = 10
-
-		attr_reader :job_id
-
-		def attributes
-			{
-				job_id: job_id,
-				state: state,
-				last_message: last_message,
-				ttl: ttl
-			}
-		end
-
-		def initialize(job_id: nil)
-			if job_id.nil?
-				@job_id = SecureRandom.hex(KEY_LENGTH)
-			else
-				@job_id = job_id
-			end
-		end
-
-		def update(state, message: '')
-			raise ArgumentError, 'failed states must have a message' if message.blank? && state == FAILED
-
-			redis.set(job_key, state)
-			redis.set(job_message, message) unless message.blank?
-
-			if state == ALLOCATED
-				redis.expire(job_key, KEY_TIMEOUT)
-				redis.expire(job_message, KEY_TIMEOUT)
-			end
-		end
-
-		def ttl
-			redis.ttl(job_key)
-		end
-
-		def state
-			redis.get(job_key)
-		end
-
-		def last_message
-			redis.get(job_message)
-		end
-
-		def delete
-			redis.del(job_key)
-			redis.del(job_message)
-		end
-
-		def subscribe(timeout: CHANNEL_TIMEOUT, &block)
-			raise AsyncError, "job #{job_key} doesn't exist" unless valid?
-
-			redis.subscribe_with_timeout(timeout, job_channel, &block)
-		end
-
-		def publish(message)
-			raise AsyncError, "job #{job_key} doesn't exist" unless valid?
-
-			redis.publish(job_channel, message)
-		end
-
-		def valid?
-			redis.exists(job_key)
-		end
-
-		def unsubscribe
-			redis.unsubscribe(job_channel)
-		rescue 
-			# ignore unsub errors
-		end
-
-		def redis
-			@redis ||= Redis.new(url: Unrestful.configuration.redis_address)
-		end
-
-		def close
-			redis.unsubscribe(job_channel) if redis.subscribed?
-		ensure 
-			@redis.quit
-		end
-
-		private
-
-		def job_key
-			"unrestful:job:state:#{@job_id}"
-		end
-
-		def job_channel
-			"unrestful:job:channel:#{@job_id}"
-		end
-
-		def job_message
-			"unrestful:job:message:#{@job_id}"
-		end
-
-	end
+  class AsyncJob
+    include ActiveModel::Serializers::JSON
+
+    ALLOCATED = 0
+    RUNNING = 1
+    FAILED = 2
+    SUCCESS = 3
+
+    KEY_TIMEOUT = 3600
+    KEY_LENGTH = 10
+    CHANNEL_TIMEOUT = 10
+
+    attr_reader :job_id
+
+    def attributes
+      {
+        job_id: job_id,
+        state: state,
+        last_message: last_message,
+        ttl: ttl
+      }
+    end
+
+    def initialize(job_id: nil)
+      if job_id.nil?
+        @job_id = SecureRandom.hex(KEY_LENGTH)
+      else
+        @job_id = job_id
+      end
+    end
+
+    def update(state, message: '')
+      raise ArgumentError, 'failed states must have a message' if message.blank? && state == FAILED
+
+      redis.set(job_key, state)
+      redis.set(job_message, message) unless message.blank?
+
+      if state == ALLOCATED
+        redis.expire(job_key, KEY_TIMEOUT)
+        redis.expire(job_message, KEY_TIMEOUT)
+      end
+    end
+
+    def ttl
+      redis.ttl(job_key)
+    end
+
+    def state
+      redis.get(job_key)
+    end
+
+    def last_message
+      redis.get(job_message)
+    end
+
+    def delete
+      redis.del(job_key)
+      redis.del(job_message)
+    end
+
+    def subscribe(timeout: CHANNEL_TIMEOUT, &block)
+      raise AsyncError, "job #{job_key} doesn't exist" unless valid?
+
+      redis.subscribe_with_timeout(timeout, job_channel, &block)
+    end
+
+    def publish(message)
+      raise AsyncError, "job #{job_key} doesn't exist" unless valid?
+
+      redis.publish(job_channel, message)
+    end
+
+    def valid?
+      redis.exists(job_key)
+    end
+
+    def unsubscribe
+      redis.unsubscribe(job_channel)
+    rescue
+      # ignore unsub errors
+    end
+
+    def redis
+      @redis ||= Redis.new(url: Unrestful.configuration.redis_address)
+    end
+
+    def close
+      redis.unsubscribe(job_channel) if redis.subscribed?
+    ensure
+      @redis.quit
+    end
+
+    private
+
+    def job_key
+      "unrestful:job:state:#{@job_id}"
+    end
+
+    def job_channel
+      "unrestful:job:channel:#{@job_id}"
+    end
+
+    def job_message
+      "unrestful:job:message:#{@job_id}"
+    end
+
+  end
 end

data/lib/unrestful/errors.rb

@@ -1,9 +1,16 @@
 module Unrestful
-	class Error < StandardError; end
-	class FailError < Error; end
-	class AuthError < Error; end
-	class NotLiveError < Error; end
-	class LiveError < Error; end
-	class AsyncError < Error; end
-	class StreamInterrupted < Error; end
+  class Error < StandardError;
+  end
+  class FailError < Error;
+  end
+  class AuthError < Error;
+  end
+  class NotLiveError < Error;
+  end
+  class LiveError < Error;
+  end
+  class AsyncError < Error;
+  end
+  class StreamInterrupted < Error;
+  end
 end

data/lib/unrestful/fail_response.rb

@@ -2,25 +2,25 @@ require_relative 'response'
 require 'json/add/exception'
 
 module Unrestful
-	class FailResponse < Unrestful::Response
-		
-		attr_accessor :message
-		attr_accessor :exception
+  class FailResponse < Unrestful::Response
 
-		def self.render(message, exc: nil)
-			obj = Unrestful::FailResponse.new
-			obj.message = message
-			obj.exception = exc if !exc.nil? && Rails.env.development?
-			obj.ok = false
-			
-			return obj.as_json
-		end
-		
-		def as_json
-			result = { message: message }
-			result.merge!({ exception: exception }) unless exception.nil?
-			super.merge(result)
-		end
-		
-	end
+    attr_accessor :message
+    attr_accessor :exception
+
+    def self.render(message, exc: nil)
+      obj = Unrestful::FailResponse.new
+      obj.message = message
+      obj.exception = exc if !exc.nil? && Rails.env.development?
+      obj.ok = false
+
+      return obj.as_json
+    end
+
+    def as_json
+      result = {message: message}
+      result.merge!({exception: exception}) unless exception.nil?
+      super.merge(result)
+    end
+
+  end
 end

data/lib/unrestful/json_web_token.rb

@@ -3,32 +3,32 @@ require 'net/http'
 require 'uri'
 
 module Unrestful
-	class JsonWebToken
-		LEEWAY = 30
+  class JsonWebToken
+    LEEWAY = 30
 
-		def self.verify(token)
-			JWT.decode(token, nil,
-					   true,
-					   algorithm: 'RS256',
-					   iss: Unrestful.configuration.issuer,
-					   verify_iss: true,
-					   aud: Unrestful.configuration.audience,
-					   verify_aud: true) do |header|
-				jwks_hash[header['kid']]
-			end
-		end
+    def self.verify(token)
+      JWT.decode(token, nil,
+                 true,
+                 algorithm: 'RS256',
+                 iss: Unrestful.configuration.issuer,
+                 verify_iss: true,
+                 aud: Unrestful.configuration.audience,
+                 verify_aud: true) do |header|
+        jwks_hash[header['kid']]
+      end
+    end
 
-		def self.jwks_hash
-			jwks_raw = Net::HTTP.get URI("#{Unrestful.configuration.issuer}.well-known/jwks.json")
-			jwks_keys = Array(JSON.parse(jwks_raw)['keys'])
-			Hash[
-				jwks_keys.map do |k|
-					[
-						k['kid'],
-						OpenSSL::X509::Certificate.new(Base64.decode64(k['x5c'].first)).public_key
-					]
-				end
-			]
-		end
-	end
+    def self.jwks_hash
+      jwks_raw = Net::HTTP.get URI("#{Unrestful.configuration.issuer}.well-known/jwks.json")
+      jwks_keys = Array(JSON.parse(jwks_raw)['keys'])
+      Hash[
+        jwks_keys.map do |k|
+          [
+            k['kid'],
+            OpenSSL::X509::Certificate.new(Base64.decode64(k['x5c'].first)).public_key
+          ]
+        end
+      ]
+    end
+  end
 end

data/lib/unrestful/jwt_secured.rb

@@ -2,33 +2,43 @@
 require 'jwt'
 
 module Unrestful
-	module JwtSecured
-		extend ActiveSupport::Concern
-	
-		private
-	
-		def authenticate_request!
-			@auth_payload, @auth_header = auth_token
-		
-			raise AuthError, 'Insufficient scope' unless scope_included
-		end
+  module JwtSecured
+    extend ActiveSupport::Concern
 
-		def http_token
-			if request.headers['Authorization'].present?
-				request.headers['Authorization'].split(' ').last
-			end
-		end
-	
-		def auth_token
-			JsonWebToken.verify(http_token)
-		end
+    private
 
-		def scope_included
-			if self.class.assigned_scopes[@method] == nil
-			  false
-			else
-			  (String(@auth_payload['scope']).split(' ') & (self.class.assigned_scopes[@method])).any?
-			end
-		end
-	end
-end
+    def authenticate_request!
+      @auth_payload, @auth_header = auth_token
+      raise AuthError, 'Insufficient scope' unless scope_included
+    end
+
+    def http_token
+      if request.headers['Authorization'].present?
+        # strip off the Bearer
+        request.headers['Authorization'].split(' ').last
+      end
+    end
+
+    def auth_token
+      JsonWebToken.verify(http_token)
+    end
+
+    def scope_included
+      permissions_required = class_assigned_scopes
+      permissions_present = @auth_payload['permissions'] || []
+      # ensure that we have the required permission to call the method
+      (permissions_present & permissions_required).any?
+    end
+
+    def class_assigned_scopes
+      class_assigned_scopes = self.class.assigned_scopes[@method] || []
+      # ensure that we have a scope defined for this method, and that it has an array value
+      if class_assigned_scopes.nil? || class_assigned_scopes.empty? || !class_assigned_scopes.is_a?(Array)
+        raise "#{self.class.name} MUST declare a \"scopes\" hash that INCLUDES key \"#{@method}\" with value of an array of permissions"
+      end
+      class_assigned_scopes
+    rescue NoMethodError
+      raise "#{self.class.name} MUST implement ::Unrestful::RpcController AND declare \"scopes\" for each method request, with its corresponding array of permissions"
+    end
+  end
+end

data/lib/unrestful/response.rb

@@ -4,8 +4,8 @@ module Unrestful
     attr_accessor :ok
 
     def as_json
-      { ok: @ok }
+      {ok: @ok}
     end
 
   end
-end
+end

data/lib/unrestful/rpc_controller.rb

@@ -2,18 +2,18 @@ module Unrestful
   class RpcController
 
     attr_reader :service
-	attr_reader :method
-	attr_reader :request
-	attr_reader :response
-	attr_reader :live
-	attr_reader :async
-	attr_reader :job
+    attr_reader :method
+    attr_reader :request
+    attr_reader :response
+    attr_reader :live
+    attr_reader :async
+    attr_reader :job
 
     class_attribute :before_method_callbacks, default: ActiveSupport::HashWithIndifferentAccess.new
-	class_attribute :after_method_callbacks, default: ActiveSupport::HashWithIndifferentAccess.new
-	class_attribute :assigned_scopes, default: ActiveSupport::HashWithIndifferentAccess.new
-	class_attribute :live_methods, default: []
-	class_attribute :async_methods, default: []
+    class_attribute :after_method_callbacks, default: ActiveSupport::HashWithIndifferentAccess.new
+    class_attribute :assigned_scopes, default: ActiveSupport::HashWithIndifferentAccess.new
+    class_attribute :live_methods, default: []
+    class_attribute :async_methods, default: []
 
     def before_callbacks
       self.class.before_method_callbacks.each do |k, v|
@@ -26,36 +26,36 @@ module Unrestful
       self.class.after_method_callbacks.each do |k, v|
         self.send(k)
       end
-	end
+    end
+
+    def write(message)
+      raise NotLiveError unless live
+      msg = message.end_with?("\n") ? message : "#{message}\n"
+      response.stream.write msg
+    end
 
-	def write(message)
-		raise NotLiveError unless live
-		msg = message.end_with?("\n") ? message : "#{message}\n"
-		response.stream.write msg
-	end
-	
     protected
 
     def self.before_method(method, options = {})
-      self.before_method_callbacks = { method => options }
+      self.before_method_callbacks = {method => options}
     end
 
     def self.after_method(method, options = {})
-      self.after_method_callbacks = { method => options }
-	end
+      self.after_method_callbacks = {method => options}
+    end
 
-	def self.scopes(scope_list)
-		self.assigned_scopes = ActiveSupport::HashWithIndifferentAccess.new(scope_list)
-	end
+    def self.scopes(scope_list)
+      self.assigned_scopes = ActiveSupport::HashWithIndifferentAccess.new(scope_list)
+    end
+
+    def self.live(live_list)
+      self.live_methods = live_list
+    end
 
-	def self.live(live_list)
-		self.live_methods = live_list
-	end
+    def self.async(async_list)
+      self.async_methods = async_list
+    end
 
-	def self.async(async_list)
-		self.async_methods = async_list
-	end
-	
     def fail!(message = "")
       raise ::Unrestful::FailError, message
     end

data/lib/unrestful/success_response.rb

@@ -14,7 +14,7 @@ module Unrestful
     end
 
     def as_json
-      super.merge({ payload: payload })
+      super.merge({payload: payload})
     end
   end
-end
+end

data/lib/unrestful/utils.rb

@@ -1,19 +1,19 @@
 module Unrestful
-	module Utils
+  module Utils
 
-		def watchdog(last_words)
-			yield
-		  rescue Exception => exc
-			Rails.logger.debug "#{last_words}: #{exc}"
-			#raise exc
-		  end
-	  
-		def safe_thread(name, &block)
-			Thread.new do
-				Thread.current['unrestful_name'.freeze] = name
-				watchdog(name, &block)
-			end
-	  	end
-	  
-	end 
+    def watchdog(last_words)
+      yield
+    rescue Exception => exc
+      Rails.logger.debug "#{last_words}: #{exc}"
+      #raise exc
+    end
+
+    def safe_thread(name, &block)
+      Thread.new do
+        Thread.current['unrestful_name'.freeze] = name
+        watchdog(name, &block)
+      end
+    end
+
+  end
 end

data/lib/unrestful/version.rb

@@ -1,3 +1,3 @@
 module Unrestful
-  VERSION = '0.1.3'
+  VERSION = '0.1.4'
 end

data/lib/unrestful.rb

@@ -3,43 +3,43 @@ require "unrestful/engine"
 Dir[File.join(__dir__, 'unrestful', '*.rb')].each {|file| require file}
 
 module Unrestful
-	def self.configure(options = {}, &block)
-		@config = Unrestful::Config.new(options)
-		block.call(@config) if block.present?
-		@config
-	end
-
-	def self.configuration
-		@config || Unrestful::Config.new({})
-	end
-
-	class Config
-		def initialize(options)
-			@options = options
-		end
-
-		def issuer
-			@options[:issuer] || ENV.fetch("ISSUER")
-		end
-
-		def issuer=(value)
-			@options[:issuer] = value
-		end
-
-		def audience
-			@options[:audience] || ENV.fetch("AUDIENCE")
-		end
-
-		def audience=(value)
-			@options[:audience] = value
-		end
-
-		def redis_address
-			@options[:redis_address] || ENV.fetch("REDIS_URL") {"redis://localhost:6379/1"}
-		end
-
-		def redis_address=(value)
-			@options[:redis_address] = value
-		end
-	end
+  def self.configure(options = {}, &block)
+    @config = Unrestful::Config.new(options)
+    block.call(@config) if block.present?
+    @config
+  end
+
+  def self.configuration
+    @config || Unrestful::Config.new({})
+  end
+
+  class Config
+    def initialize(options)
+      @options = options
+    end
+
+    def issuer
+      @options[:issuer] || ENV.fetch("ISSUER")
+    end
+
+    def issuer=(value)
+      @options[:issuer] = value
+    end
+
+    def audience
+      @options[:audience] || ENV.fetch("AUDIENCE")
+    end
+
+    def audience=(value)
+      @options[:audience] = value
+    end
+
+    def redis_address
+      @options[:redis_address] || ENV.fetch("REDIS_URL") {"redis://localhost:6379/1"}
+    end
+
+    def redis_address=(value)
+      @options[:redis_address] = value
+    end
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: unrestful
 version: !ruby/object:Gem::Version
-  version: 0.1.3
+  version: 0.1.4
 platform: ruby
 authors:
 - Khash Sajadi
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2019-07-16 00:00:00.000000000 Z
+date: 2019-08-07 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: rails
@@ -134,8 +134,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.7.9
+rubygems_version: 3.0.4
 signing_key: 
 specification_version: 4
 summary: Unrestful is a simple RPC framework for Rails