herdst_servicecall 0.1.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: edcb93afbd7eb625014ac88fa8fbdcbfe5ecca6ccf91c3a3355c8b4b46893977
+  data.tar.gz: 1225417249d81bf83ae5091e8d157c972bf41649db094b2338326788e4bec664
+SHA512:
+  metadata.gz: 678cde9436e7f4e0b56ef6b7d6728161268144caef2fb0048850cd4d340c8d13172f1d0024f91f9ac670d21e430573e83eb4593720da40e76dfd756c2bc4a51e
+  data.tar.gz: f3d4513df4c007aa1b292f6746f8c523aacba28a1ceb46e753e634b2b9f56cf2237b2c3616d80794908ff66f3ee340f556feaa9982c421cdcf42491d7076f5b2

data/MIT-LICENSE

@@ -0,0 +1,20 @@
+Copyright 2020 Matthew Mills
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+"Software"), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
+LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
+OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
+WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/README.md

@@ -0,0 +1,31 @@
+# Servicecall
+Short description and motivation.
+
+## Usage
+How to use my plugin.
+
+## Installation
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'servicecall'
+```
+
+And then execute:
+```bash
+$ bundle
+```
+
+Or install it yourself as:
+```bash
+$ gem install servicecall
+```
+
+## Install config
+```rails generate servicecall:install```
+
+## Contributing
+Contribution directions go here.
+
+## License
+The gem is available as open source under the terms of the [MIT License](https://opensource.org/licenses/MIT).

data/Rakefile

@@ -0,0 +1,29 @@
+ENV["TZ"] = "UTC"
+
+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    = 'HerdstServicecall'
+  rdoc.options << '--line-numbers'
+  rdoc.rdoc_files.include('README.md')
+  rdoc.rdoc_files.include('lib/**/*.rb')
+end
+
+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/lib/generators/herdst_servicecall/install_generator.rb

@@ -0,0 +1,12 @@
+require 'rails/generators/base'
+
+
+module HerdstServicecall
+    class InstallGenerator < Rails::Generators::Base
+        source_root File.expand_path("../../templates", __FILE__)
+        
+        def create_initializer_file
+            template "herdst_servicecall.rb", "config/initializers/herdst_servicecall.rb"
+        end
+    end
+end

data/lib/generators/templates/herdst_servicecall.rb

@@ -0,0 +1,12 @@
+# Configures service call
+HerdstServicecall.setup do |config|
+
+    config.jwt_secret "secret"
+    
+    config.register_service :service_one, "http://localhost:3000"
+    config.register_service :service_two, "http://localhost:3001"
+    config.register_service :service_three, "http://localhost:3002"
+    
+    config.on("user_created", "user#created")
+
+end

data/lib/herdst_servicecall.rb

@@ -0,0 +1,44 @@
+require 'jwt'
+require 'json'
+
+require "herdst_servicecall/railtie"
+require "herdst_servicecall/configurator"
+require "herdst_servicecall/caller"
+require "herdst_servicecall/receiver"
+require "herdst_servicecall/middleware"
+require "herdst_servicecall/request"
+require "herdst_servicecall/response"
+require "herdst_servicecall/responder"
+require "herdst_servicecall/responder_error"
+require "herdst_servicecall/mocker" if (ENV["RAILS_ENV"] == "test") || (ENV["WORKER_ENV"] == "test")
+
+
+module HerdstServicecall
+    
+    
+    @@config = Configurator.new
+    @@caller = Caller.new(@@config)
+    @@receiver = Receiver.new(@@config)
+    
+    
+    def self.config
+        @@config
+    end
+
+    
+    def self.receive(token, data)
+        @@receiver.receive(token, data)
+    end
+    
+    
+    def self.call(service_name, event_name, data)
+        @@caller.call(service_name, event_name, data)
+    end
+    
+    
+    def self.setup(&block)
+        yield @@config if block_given?
+    end
+    
+    
+end

data/lib/herdst_servicecall/caller.rb

@@ -0,0 +1,58 @@
+require 'net/http'
+require 'uri'
+
+
+module HerdstServicecall
+    class Caller
+    
+        
+        attr_accessor :config, :responder
+        
+        
+        def initialize(config)
+            self.config = config
+        end
+        
+        
+        def call(service_name, event_name, data)
+            service_endpoint = @config.get_service(service_name.to_sym)
+            
+            raise "No service endpoint!" unless service_endpoint
+            
+            call_endpoint = service_endpoint + @config.event_path  + "?" + { :token => get_token }.to_query
+            
+            response = send_request!(call_endpoint, Request.new(event_name, data))
+            
+            Response.parse(response)
+        end
+        
+        
+        private
+            def send_request!(endpoint, service_request)
+                uri = URI.parse(endpoint)
+                http = Net::HTTP.start(uri.host, uri.port, :use_ssl => uri.scheme == "https")
+                request = Net::HTTP::Post.new(uri.to_s)
+                
+                request.content_type = "application/json"
+                request.body = service_request.to_json
+                
+                make_request!(http, request)
+            end
+            
+            def get_token
+                payload = {
+                    :iat => (Time.now.utc.to_i - 1),
+                    :nbf => (Time.now.utc.to_i - 10),
+                    :exp => (Time.now.utc.to_i + 300)
+                }
+                
+                JWT.encode(payload, self.config.jwt_secret, self.config.jwt_algorithm)
+            end
+            
+            def make_request!(http, request)
+                http.request(request)
+            end
+        
+            
+    end
+end

data/lib/herdst_servicecall/configurator.rb

@@ -0,0 +1,40 @@
+module HerdstServicecall
+    class Configurator
+    
+        
+        def initialize
+            @config = Hash.new.with_indifferent_access
+            @config[:services] = Hash.new
+            @config[:events] = Hash.new
+            @config[:event_path] = "/servicecall/event"
+            @config[:jwt_secret] = nil
+            @config[:jwt_algorithm] = "HS256"
+        end
+        
+        
+        def register_service(name, endpoint)
+            @config[:services][name.to_sym] = endpoint
+        end
+        
+        
+        def get_service(name)
+            @config[:services][name.to_sym]
+        end
+        
+        
+        def on(event_name, action)
+            @config[:events][event_name.to_sym] = action
+        end
+        
+        
+        def method_missing(method, *args)
+            if (args.size == 1)
+                @config[method.to_sym] = args.first
+            else
+                @config[method.to_sym]
+            end
+        end
+        
+    
+    end
+end

data/lib/herdst_servicecall/middleware.rb

@@ -0,0 +1,43 @@
+module HerdstServicecall
+    class Middleware
+    
+    
+        def initialize(app)
+            @app = app
+            @event_path = HerdstServicecall.config.event_path
+        end
+        
+        
+        def call(env)
+            if env["REQUEST_METHOD"] == "POST"
+                req = nil
+                
+                unless env["REQUEST_PATH"]
+                    req = Rack::Request.new(env)
+                    
+                    env["REQUEST_PATH"] = req.path
+                end
+                
+                if env["REQUEST_PATH"] == @event_path
+                    req = Rack::Request.new(env) unless req
+                    body = req.body.read
+                    token = Rack::Utils.parse_nested_query(req.query_string)["token"] rescue nil
+                    
+                    if body
+                        response = HerdstServicecall.receive(token, body)
+                        
+                        return [
+                            response.code,
+                            { "Content-Type" => "application/json" },
+                            [ response.to_json ]
+                        ]
+                    end
+                end
+            end
+            
+            return @app.call(env)
+        end
+        
+    
+    end
+end

data/lib/herdst_servicecall/mocker.rb

@@ -0,0 +1,44 @@
+require "minitest/mock"
+
+
+module HerdstServicecall
+    class Mocker
+        
+        
+        def self.mock_call(event, body, code = 200, &block)
+            stub_call(:call, event, body, code) do
+                yield if block_given?
+            end
+        end
+        
+        
+        private
+            def self.stub_call(method, event, body, code = 200)
+                calls = []
+                
+                Caller.class_eval do
+                    alias_method :"new_#{method}", method
+                    
+                    define_method(method) do |*args|
+                        calls << args
+                        
+                        Response.new(event, code, body)
+                    end
+                end
+                
+                begin
+                    yield if block_given?
+                ensure
+                    Caller.class_eval do
+                        undef_method method
+                        alias_method method, :"new_#{method}"
+                        undef_method :"new_#{method}"
+                    end
+                end
+                
+                calls
+            end
+        
+        
+    end
+end

data/lib/herdst_servicecall/railtie.rb

@@ -0,0 +1,17 @@
+module HerdstServicecall
+  class Railtie < ::Rails::Railtie
+      
+        
+        initializer "herdst_servicecall.configure_rails_initialization" do |app|
+            app.middleware.insert_after Rack::TempfileReaper, Middleware
+        end
+        
+        generators do
+            generator_path = File.expand_path("../../generators/herdst_servicecall", __FILE__)
+            
+            require "#{generator_path}/install_generator"
+        end
+        
+        
+  end
+end

data/lib/herdst_servicecall/receiver.rb

@@ -0,0 +1,66 @@
+module HerdstServicecall
+    class Receiver
+    
+        
+        attr_accessor :config, :events
+    
+        
+        def initialize(config)
+            self.config = config
+        end
+    
+        
+        def receive(token, data)
+            request = Request.new(nil, nil)
+            
+            begin
+                verify_token!(token)
+                
+                request.parse!(data)
+                
+                action = self.config.events[request.event.to_sym] rescue nil
+                
+                raise ResponderError.new(request.event, "Invalid event") unless action
+                
+                action_class_name, action_name = action.split("#")
+                action_class = "#{action_class_name.classify}ServiceEvent".constantize.new(request.event, request.body)
+                response = action_class.send(action_name, request.body)
+                
+                Response.new(request.event, 200, response)
+            rescue Exception => ex
+                if ex.instance_of?(ResponderError)
+                    ex.response
+                    
+                elsif ex.instance_of?(JWT::VerificationError)
+                    Response.new(request.event, 400, {
+                        :error => ex.message
+                    })
+                    
+                elsif ex.instance_of?(JWT::DecodeError)
+                    Response.new(request.event, 400, {
+                        :error => "Invalid token"
+                    })
+                    
+                else
+                    Response.new(request.event, 400, {
+                        :error => ex.message
+                    })
+                    
+                end
+            end
+        end
+        
+        
+        private
+            def verify_token!(token)
+                JWT.decode(
+                    token, 
+                    self.config.jwt_secret, 
+                    true,
+                    { algorithm: self.config.jwt_algorithm }
+                )
+            end
+            
+    
+    end
+end

data/lib/herdst_servicecall/request.rb

@@ -0,0 +1,37 @@
+module HerdstServicecall
+    class Request
+    
+        
+        attr_accessor :event, :body
+    
+
+        def initialize(event, body)
+            self.event = event
+            self.body = body ? 
+                (body.respond_to?(:with_indifferent_access) ? body.with_indifferent_access : body) : 
+                nil
+        end
+        
+        
+        def to_json
+            {
+                :event => self.event,
+                :data => self.body
+            }.to_json
+        end
+        
+        
+        def parse!(data)
+            body = JSON.parse(data) rescue nil
+            
+            raise "Invalid body" unless body
+            
+            self.event = body["event"]
+            self.body = body["data"].respond_to?(:with_indifferent_access) ? 
+                body["data"].with_indifferent_access : 
+                body["data"]
+        end
+        
+            
+    end
+end

data/lib/herdst_servicecall/responder.rb

@@ -0,0 +1,17 @@
+module HerdstServicecall
+    class Responder
+    
+    
+        def initialize(event, data)
+            @event = event
+            @data = data
+        end
+    
+        
+        def reject!(data, code = 400)
+            raise ResponderError.new(@event, data, code)
+        end
+        
+        
+    end
+end

data/lib/herdst_servicecall/responder_error.rb

@@ -0,0 +1,48 @@
+module HerdstServicecall
+    class ResponderError < Exception
+        
+        
+        def initialize(event, data, code = 400)
+            @event = event
+            @code = code
+            @response = Response.new(event, code, get_body(data))
+        end
+        
+        
+        def event
+            @event
+        end
+        
+        
+        def code
+            @code
+        end
+        
+        
+        def response
+            @response
+        end
+        
+        
+        private
+            def get_body(data)
+                body = data
+                
+                if data.is_a?(String)
+                    body = {
+                        :message => data
+                    }
+                end
+                
+                if data.is_a?(ActiveModel::Validations) && ((data.errors.empty? == false) || (data.valid? == false))
+                    body = {
+                        :message => "A validation error occured", 
+                        :errors => data.errors 
+                    }
+                end
+                
+                body
+            end
+        
+    end
+end

data/lib/herdst_servicecall/response.rb

@@ -0,0 +1,55 @@
+module HerdstServicecall
+    class Response
+    
+        
+        attr_accessor :event, :body, :code
+    
+
+        def initialize(event, code, body)
+            self.event = event
+            self.code = code
+            self.body = body ? 
+                (body.respond_to?(:with_indifferent_access) ? body.with_indifferent_access : body) : 
+                nil
+        end
+        
+        
+        def was_successful?
+            code && code >= 200 && code < 400
+        end
+        
+        
+        def error(default = "Unknown Error")
+            if (self.was_successful? == false)
+                return (self.body == nil) ? { :message => default } : self.body
+            end
+            
+            return nil
+        end
+        
+        
+        def to_json
+            {
+                :event => self.event,
+                :success => self.was_successful?,
+                :data => self.body
+            }.to_json
+        end
+        
+        
+        def [](key)
+            self.body ? self.body[key] : nil
+        end
+            
+        
+        def self.parse(response)
+            body = JSON.parse(response.body) rescue nil
+            event = body && body["event"]
+            data = body && body["data"]
+            
+            self.new(event, response.code.to_i, data)
+        end
+        
+            
+    end
+end

data/lib/herdst_servicecall/version.rb

@@ -0,0 +1,3 @@
+module HerdstServicecall
+  VERSION = '0.1.5'
+end

data/lib/tasks/servicecall_tasks.rake

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

metadata

@@ -0,0 +1,116 @@
+--- !ruby/object:Gem::Specification
+name: herdst_servicecall
+version: !ruby/object:Gem::Version
+  version: 0.1.5
+platform: ruby
+authors:
+- Herd.St
+autorequire:
+bindir: bin
+cert_chain: []
+date: 2021-06-23 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: 6.0.3
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 6.0.3.2
+- !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: sqlite3
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.3'
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: 1.3.11
+description: Caller other services from with the app.
+email:
+- devops@herd.st
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- MIT-LICENSE
+- README.md
+- Rakefile
+- lib/generators/herdst_servicecall/install_generator.rb
+- lib/generators/templates/herdst_servicecall.rb
+- lib/herdst_servicecall.rb
+- lib/herdst_servicecall/caller.rb
+- lib/herdst_servicecall/configurator.rb
+- lib/herdst_servicecall/middleware.rb
+- lib/herdst_servicecall/mocker.rb
+- lib/herdst_servicecall/railtie.rb
+- lib/herdst_servicecall/receiver.rb
+- lib/herdst_servicecall/request.rb
+- lib/herdst_servicecall/responder.rb
+- lib/herdst_servicecall/responder_error.rb
+- lib/herdst_servicecall/response.rb
+- lib/herdst_servicecall/version.rb
+- lib/tasks/servicecall_tasks.rake
+homepage: https://herd.st
+licenses:
+- Nonstandard
+metadata:
+  allowed_push_host: https://rubygems.org/
+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: []
+rubygems_version: 3.2.20
+signing_key:
+specification_version: 4
+summary: Caller other services.
+test_files: []