unrestful 0.1.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 3a72f2af5b6292b01574673437b1e1102ec301d6dadc818b56a3e5e2f98beeaf
+  data.tar.gz: a8bb7550136979bb330de73d7f4b303121cf5e2685504b2ce9848f847c118527
+SHA512:
+  metadata.gz: 34dec6df9aae1c4fb211cfee6d8dd1069aad5f9938b1d3058e1095d5dd5e6026c1d4987402987041d93935d7fcdd1069100af2aa4e994f92253152e4e20b8c14
+  data.tar.gz: 36b3738b1dc28431c44941665cb5c9c1e8c81df6540565a22bb2a82c3311507ad43616679e58c9df3acb98f75ee3d91c25b5ae0acff139db1d59d0fbdf3fb3f9

data/README.md

@@ -0,0 +1,137 @@
+<img src="http://cdn2-cloud66-com.s3.amazonaws.com/images/oss-sponsorship.png" width=150/>
+
+# Unrestful
+
+REST is not fit for all use cases. Most of RPC frameworks are too heavy and complicated and require a lot of Ops involvement.
+
+Unrestful is a lightweight simple RPC framework for Rails that can sit next to your existing application. It supports the following:
+
+- Simple procedure calls over HTTP
+- Streaming
+- Async jobs and async job log streaming and status tracking
+
+## Dependencies
+
+Unrestful requires Rails 5.2 (can work with earlier versions) and Redis.
+In development environments, Unrestful requires a multi-threaded web server like Puma. (it won't work with Webrick).
+
+## Usage
+
+Mount Unrestful on your Rails app:
+
+```ruby
+Rails.application.routes.draw do
+  # ...
+  mount Unrestful::Engine => "/mount/path"
+  # ...
+end
+```
+
+This will add the following paths to your application:
+
+```
+/mount/path/rpc/:service/:method
+/mount/path/jobs/status/:job_id
+/mount/path/jobs/live/:job_id
+```
+
+You can start your Rails app as normal.
+
+## Services and Method
+
+Unrestful looks for files under `app/models/rpc` to find the RPC method. Any class should be derived from `::Unrestful::RpcController` to be considered. Here is an example:
+
+```ruby
+require 'unrestful'
+
+module Rpc
+	class Account < ::Unrestful::RpcController
+		include Unrestful::JwtSecured
+		scopes({
+			'switch_owner' => ['write:account'],
+			'migrate' => ['read:account'],
+			'long_one' => ['read:account']
+		})
+		live(['migrate'])
+		async(['long_one'])
+
+		before_method :authenticate_request!
+		#after_method :do_something
+
+		def switch_owner(from:, to:)
+			foo = ::AcmeFoo.new
+			foo.from = from
+			foo.to = to
+
+			return foo
+		end
+
+		def migrate(repeat:)
+			repeat.to_i.times {
+				write "hello\n"
+				sleep 1
+			}
+
+			return nil
+		end
+
+		def long_one
+			return { not_done_yet: true }
+		end
+
+	end
+end
+```
+
+NOTE: All parameters on all RPC methods should be named.
+
+`POST` or `GET` parameters will be used to call the RPC method using their names. For example, `{ "from": "you", "to": "me" }` as a HTTP POST payload on `rpc/account/switch_owner` will be used to call the method with the corresponding parameters.
+
+NOTE: Both `rpc/accounts` and `rpc/account` are accepted.
+
+The three methods in the example above, support the 3 types of RPC calls Unrestful supports:
+
+### Synchronous calls
+
+Sync calls are called and return a value within the same HTTP session. `switch_owner` is an example of that. Any returned value will be wrapped in `Unrestful::Response` and sent to the client (this could be a `SuccessResponse` or `FailResponse` if there is an exception).
+
+### Live calls
+
+Live calls are calls that hold the client and send live logs of progress down the wire. They might be cancelled mid-flow if the client disconnects. Live methods should be named in the `live` class method and can use the `write` method to send live information back to the client.
+
+### Asynchronous calls
+
+Async calls are like sync calls, but return a job id which can be used to track the background job's progress and perhaps follow its logs. Use the `jobs/status` and `jobs/live` end points for those purposes. Async calls should be named in the `async` class method and can use `@job` (`Unrestful::AsyncJob`) to update job status or publish logs for the clients.
+
+## Code
+
+Most of the code for Unrestful is in 2 controllers: `Unrestful::EndpointsController` and `Unrestful::JobsController`. Most fo your questions will be answered by looking at those 2 methods!
+
+## Authorization
+
+By default Unrestful doesn't impose any authentication or authorization on the callers. However it comes with a prewritten JWT authorizer which can be used by using `include Unrestful::JwtSecured` in your own RPCController. This will look for a JWT on the header, will validate it and return the appropriate response.
+
+The simplest way to use Unrestful with JWT is to use a tool like Auth0. Create you API and App and use it to generate and use the tokens when making calls to Unrestful.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'unrestful'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install unrestful
+```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [Apache 2.0 License](https://opensource.org/licenses/Apache-2.0).

data/Rakefile

@@ -0,0 +1,32 @@
+begin
+  require 'bundler/setup'
+rescue LoadError
+  puts 'You must `gem install bundler` and `bundle install` to run rake tasks'
+end
+
+require 'rdoc/task'
+
+RDoc::Task.new(:rdoc) do |rdoc|
+  rdoc.rdoc_dir = 'rdoc'
+  rdoc.title    = 'Unrestful'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+APP_RAKEFILE = File.expand_path("spec/dummy/Rakefile", __dir__)
+load 'rails/tasks/engine.rake'
+
+load 'rails/tasks/statistics.rake'
+
+require 'bundler/gem_tasks'
+
+require 'rake/testtask'
+
+Rake::TestTask.new(:test) do |t|
+  t.libs << 'test'
+  t.pattern = 'test/**/*_test.rb'
+  t.verbose = false
+end
+
+task default: :test

data/app/assets/config/unrestful_manifest.js

@@ -0,0 +1,2 @@
+//= link_directory ../javascripts/unrestful .js
+//= link_directory ../stylesheets/unrestful .css

data/app/assets/javascripts/unrestful/application.js

@@ -0,0 +1,15 @@
+// This is a manifest file that'll be compiled into application.js, which will include all the files
+// listed below.
+//
+// Any JavaScript/Coffee file within this directory, lib/assets/javascripts, vendor/assets/javascripts,
+// or any plugin's vendor/assets/javascripts directory can be referenced here using a relative path.
+//
+// It's not advisable to add code directly here, but if you do, it'll appear at the bottom of the
+// compiled file. JavaScript code in this file should be added after the last require_* statement.
+//
+// Read Sprockets README (https://github.com/rails/sprockets#sprockets-directives) for details
+// about supported directives.
+//
+//= require rails-ujs
+//= require activestorage
+//= require_tree .

data/app/assets/stylesheets/unrestful/application.css

@@ -0,0 +1,15 @@
+/*
+ * This is a manifest file that'll be compiled into application.css, which will include all the files
+ * listed below.
+ *
+ * Any CSS and SCSS file within this directory, lib/assets/stylesheets, vendor/assets/stylesheets,
+ * or any plugin's vendor/assets/stylesheets directory can be referenced here using a relative path.
+ *
+ * You're free to add application-wide styles to this file and they'll appear at the bottom of the
+ * compiled file so the styles you add here take precedence over styles defined in any other CSS/SCSS
+ * files in this directory. Styles in this file should be added after the last require_* statement.
+ * It is generally better to create a new file per style scope.
+ *
+ *= require_tree .
+ *= require_self
+ */

data/app/controllers/unrestful/application_controller.rb

@@ -0,0 +1,5 @@
+module Unrestful
+	class ApplicationController < ActionController::Base
+		protect_from_forgery with: :exception
+	end
+end

data/app/controllers/unrestful/endpoints_controller.rb

@@ -0,0 +1,104 @@
+Dir[File.join(Rails.root, 'app', 'rpc', '*.rb')].each { |file| require file }
+require 'net/http'
+require 'uri'
+
+module Unrestful
+	class EndpointsController < ApplicationController
+		include ActionController::Live
+		protect_from_forgery unless: -> { request.format.json? }
+
+		INVALID_PARAMS = [:method, :service, :controller, :action, :endpoint]
+
+        def endpoint
+            method = params[:method]
+            service = params[:service]
+			service_class = service.camelize.singularize
+			
+			arguments = params.to_unsafe_h.symbolize_keys.reject { |x| INVALID_PARAMS.include? x }
+
+			klass = "::Rpc::#{service_class}".constantize
+            
+            raise NameError, "#{klass} is not a Unrestful::RpcController" unless klass <= ::Unrestful::RpcController
+			actor = klass.new
+			
+			live = actor.live_methods.include? method
+			async = actor.async_methods.include? method
+
+            actor.instance_variable_set(:@service, service)
+			actor.instance_variable_set(:@method, method)
+			actor.instance_variable_set(:@request, request)
+			actor.instance_variable_set(:@response, response)
+			actor.instance_variable_set(:@live, live)
+			actor.instance_variable_set(:@async, async)
+
+            # only public methods
+            raise "#{klass} doesn't have a method called #{method}" unless actor.respond_to? method
+
+
+			response.headers['X-Live'] = live ? 'true' : 'false'
+			response.headers['X-Async'] = async ? 'true' : 'false'
+
+			return if request.head?
+
+			if async
+				@job = AsyncJob.new
+				response.headers['X-Async-JobID'] = @job.job_id
+				@job.update(AsyncJob::ALLOCATED)
+				actor.instance_variable_set(:@job, @job)
+			end
+
+			response.headers['Content-Type'] = 'text/event-stream' if live
+
+			actor.before_callbacks
+			if arguments.count == 0
+				payload = actor.send(method)
+			else
+				payload = actor.send(method, arguments)
+			end
+
+			raise LiveError if live && !payload.nil?
+
+			unless live 
+				if payload.nil?
+					render json: Unrestful::SuccessResponse.render({}.to_json)
+				else
+					render json: Unrestful::SuccessResponse.render(payload.as_json) 
+				end
+			end
+
+            actor.after_callbacks
+        rescue NameError => exc
+            not_found(exc: exc)
+        rescue ArgumentError => exc
+            fail(exc: exc)
+        rescue ::Unrestful::FailError => exc
+			fail(exc: exc)
+		rescue ::Unrestful::Error => exc
+			fail(exc: exc)
+		rescue IOError
+			# ignore as this could be the client disconnecting during streaming
+		rescue => exc
+			fail(exc: exc, status: :internal_server_error)
+		ensure 
+			response.stream.close if live
+        end
+        
+        private 
+
+        def not_found(exc:)
+            if !Rails.env.development?
+                fail(exc: exc, status: :not_found)
+            else
+                raise exc
+            end
+        end
+        
+		def fail(exc:, status: :bad_request, message: nil)
+			raise ArgumentError if exc.nil? && message.nil? 
+			msg = exc.nil? ? message : exc.message
+			@job.update(AsyncJob::FAILED, message: msg) unless @job.nil?
+
+            render json: Unrestful::FailResponse.render(msg, exc: exc) , status: status
+		end
+	end
+end

data/app/controllers/unrestful/jobs_controller.rb

@@ -0,0 +1,64 @@
+module Unrestful
+	class JobsController < ApplicationController
+		include ActionController::Live
+		include Unrestful::Utils
+		include Unrestful::JwtSecured
+
+		before_action :authenticate_request!
+
+		def status
+			job = AsyncJob.new(job_id: params[:job_id])
+			render(json: Unrestful::FailResponse.render("job #{job.job_id} doesn't exist"), status: :not_found) and return unless job.valid?
+
+			render json: job.as_json
+		end
+
+		def live
+			job = AsyncJob.new(job_id: params[:job_id])
+			response.headers['Content-Type'] = 'text/event-stream'
+
+			# this might be messy but will breakout of redis subscriptions when 
+			# the app needs to be shutdown
+			trap(:INT) { raise StreamInterrupted } 
+
+			# this is to keep redis connection alive during long sessions
+			ticker = safe_thread "ticker:#{job.job_id}" do
+				loop { job.redis.publish("unrestful:heartbeat", 1); sleep 5 }
+			end
+			sender = safe_thread "sender:#{job.job_id}" do
+				job.subscribe do |on|
+					on.message do |chn, message|
+						# we need to add a newline at the end or
+						# it will get stuck in the buffer
+						msg = message.end_with?("\n") ? message : "#{message}\n"
+						response.stream.write msg
+					end
+				end
+			end
+			ticker.join
+			sender.join
+		rescue Redis::TimeoutError
+			# ignore this
+		rescue AsyncError => exc
+			render json: Unrestful::FailResponse.render(exc.message, exc: exc) , status: :not_found
+		rescue IOError
+			# ignore as this could be the client disconnecting during streaming
+			job.unsubscribe if job
+		rescue StreamInterrupted
+			job.unsubscribe if job
+		ensure
+			ticker.kill if ticker
+			sender.kill if sender
+			response.stream.close
+			job.close if job
+		end
+
+		private 
+
+		# overwriting this as scopes don't apply to this controller
+		def scope_included
+			true 
+		end
+	end
+end
+

data/app/helpers/unrestful/application_helper.rb

@@ -0,0 +1,4 @@
+module Unrestful
+  module ApplicationHelper
+  end
+end

data/app/jobs/unrestful/application_job.rb

@@ -0,0 +1,4 @@
+module Unrestful
+  class ApplicationJob < ActiveJob::Base
+  end
+end

data/app/mailers/unrestful/application_mailer.rb

@@ -0,0 +1,6 @@
+module Unrestful
+  class ApplicationMailer < ActionMailer::Base
+    default from: 'from@example.com'
+    layout 'mailer'
+  end
+end

data/app/models/unrestful/application_record.rb

@@ -0,0 +1,5 @@
+module Unrestful
+  class ApplicationRecord < ActiveRecord::Base
+    self.abstract_class = true
+  end
+end

data/app/views/layouts/unrestful/application.html.erb

@@ -0,0 +1,16 @@
+<!DOCTYPE html>
+<html>
+<head>
+  <title>Unrestful</title>
+  <%= csrf_meta_tags %>
+  <%= csp_meta_tag %>
+
+  <%= stylesheet_link_tag    "unrestful/application", media: "all" %>
+  <%= javascript_include_tag "unrestful/application" %>
+</head>
+<body>
+
+<%= yield %>
+
+</body>
+</html>

data/config/routes.rb

@@ -0,0 +1,5 @@
+Unrestful::Engine.routes.draw do
+	get 'jobs/status/:job_id', controller: :jobs, action: :status, as: :job_status
+	get 'jobs/live/:job_id', controller: :jobs, action: :live, as: :job_live
+	match 'rpc/:service/:method', controller: :endpoints, action: :endpoint, as: :endpoint, via: [:get, :post]
+end

data/lib/tasks/unrestful_tasks.rake

@@ -0,0 +1,4 @@
+# desc "Explaining what the task does"
+# task :unrestful do
+#   # Task goes here
+# end

data/lib/unrestful/async_job.rb

@@ -0,0 +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
+end

data/lib/unrestful/engine.rb

@@ -0,0 +1,5 @@
+module Unrestful
+  class Engine < ::Rails::Engine
+    isolate_namespace Unrestful
+  end
+end

data/lib/unrestful/errors.rb

@@ -0,0 +1,9 @@
+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
+end

data/lib/unrestful/fail_response.rb

@@ -0,0 +1,26 @@
+require_relative 'response'
+require 'json/add/exception'
+
+module Unrestful
+	class FailResponse < Unrestful::Response
+		
+		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

@@ -0,0 +1,36 @@
+# frozen_string_literal: true
+require 'net/http'
+require 'uri'
+
+module Unrestful 
+	class JsonWebToken
+		ISSUER = 'https://cloud66.eu.auth0.com/'
+		LEEWAY = 30
+		AUDIENCE = ['central.admin.api.v2.development']
+
+		def self.verify(token)
+			JWT.decode(token, nil,
+					true,
+					algorithm: 'RS256',
+					iss: ISSUER,
+					verify_iss: true,
+					aud: AUDIENCE,
+					verify_aud: true) do |header|
+						jwks_hash[header['kid']]
+					end
+		end
+
+		def self.jwks_hash
+			jwks_raw = Net::HTTP.get URI("#{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

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+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
+
+		def http_token
+			if request.headers['Authorization'].present?
+				request.headers['Authorization'].split(' ').last
+			end
+		end
+	
+		def auth_token
+			JsonWebToken.verify(http_token)
+		end
+
+		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

data/lib/unrestful/response.rb

@@ -0,0 +1,11 @@
+module Unrestful
+  class Response
+
+    attr_accessor :ok
+
+    def as_json
+      { ok: @ok }
+    end
+
+  end
+end

data/lib/unrestful/rpc_controller.rb

@@ -0,0 +1,64 @@
+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
+
+    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: []
+
+    def before_callbacks
+      self.class.before_method_callbacks.each do |k, v|
+        # no checks for now
+        self.send(k)
+      end
+    end
+
+    def after_callbacks
+      self.class.after_method_callbacks.each do |k, v|
+        self.send(k)
+      end
+	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 }
+    end
+
+    def self.after_method(method, options = {})
+      self.after_method_callbacks = { method => options }
+	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.async(async_list)
+		self.async_methods = async_list
+	end
+	
+    def fail!(message = "")
+      raise ::Unrestful::FailError, message
+    end
+
+  end
+end

data/lib/unrestful/success_response.rb

@@ -0,0 +1,20 @@
+require_relative 'response'
+
+module Unrestful
+  class SuccessResponse < Unrestful::Response
+
+    attr_accessor :payload
+
+    def self.render(payload)
+      obj = Unrestful::SuccessResponse.new
+      obj.payload = payload
+      obj.ok = true
+
+      return obj.as_json
+    end
+
+    def as_json
+      super.merge({ payload: payload })
+    end
+  end
+end

data/lib/unrestful/utils.rb

@@ -0,0 +1,19 @@
+module Unrestful
+	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 
+end

data/lib/unrestful/version.rb

@@ -0,0 +1,3 @@
+module Unrestful
+  VERSION = '0.1.0'
+end

data/lib/unrestful.rb

@@ -0,0 +1,25 @@
+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)
+
+		@config
+	end
+
+	def self.configuration
+		@config || Unrestful::Config.new({})
+	end
+
+  class Config
+	def initialize(options)
+		@options = options
+	end
+
+	def redis_address
+		@options[:redis_address] || ENV.fetch("REDIS_URL") { "redis://localhost:6379/1" }
+	end
+  end
+end

metadata

@@ -0,0 +1,142 @@
+--- !ruby/object:Gem::Specification
+name: unrestful
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+platform: ruby
+authors:
+- Khash Sajadi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2019-07-09 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 5.2.0
+- !ruby/object:Gem::Dependency
+  name: jwt
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.2'
+- !ruby/object:Gem::Dependency
+  name: redis
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: puma
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Sometimes you need an API but not a RESTful one. You also don't want
+  the whole gRPC or Thrift stack in your Rails app. Unrestful is the answer!
+email:
+- khash@cloud66.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- README.md
+- Rakefile
+- app/assets/config/unrestful_manifest.js
+- app/assets/javascripts/unrestful/application.js
+- app/assets/stylesheets/unrestful/application.css
+- app/controllers/unrestful/application_controller.rb
+- app/controllers/unrestful/endpoints_controller.rb
+- app/controllers/unrestful/jobs_controller.rb
+- app/helpers/unrestful/application_helper.rb
+- app/jobs/unrestful/application_job.rb
+- app/mailers/unrestful/application_mailer.rb
+- app/models/unrestful/application_record.rb
+- app/views/layouts/unrestful/application.html.erb
+- config/routes.rb
+- lib/tasks/unrestful_tasks.rake
+- lib/unrestful.rb
+- lib/unrestful/async_job.rb
+- lib/unrestful/engine.rb
+- lib/unrestful/errors.rb
+- lib/unrestful/fail_response.rb
+- lib/unrestful/json_web_token.rb
+- lib/unrestful/jwt_secured.rb
+- lib/unrestful/response.rb
+- lib/unrestful/rpc_controller.rb
+- lib/unrestful/success_response.rb
+- lib/unrestful/utils.rb
+- lib/unrestful/version.rb
+homepage: https://github.com/khash/unrestful
+licenses:
+- Apache-2.0
+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.7.9
+signing_key: 
+specification_version: 4
+summary: Unrestful is a simple RPC framework for Rails
+test_files: []