shatter-rb 0.0.2 → 0.1.0

data/lib/shatter/service/base.rb

@@ -1,71 +1,64 @@
 # frozen_string_literal: true
-require 'singleton'
-require 'benchmark'
+
 require "drb/drb"
-require "zk"
 require "concurrent-ruby"
 
 # Server Side of the drb
 module Shatter
   module Service
     class Base
-      include Concurrent::Async
-
-      class ZooKeeperConnection
-        include Singleton
-        attr_reader :client
-        def initialize
-          @client = ZK.new(Shatter::Config.zookeeper_host)
+      class ReloadWrapper
+        def self.method_missing(method, *args, &)
+          Shatter::RELOAD_RW_LOCK.with_write_lock do
+            Shatter.reload
+          end
+          Shatter::RELOAD_RW_LOCK.with_read_lock do
+            Shatter::Service::Base.send(method, *args)
+          end
         end
       end
 
+      include Concurrent::Async
+
       class << self
-        attr_reader :service_definition
-        attr_writer :service_definition
+        attr_accessor :service_definition
       end
 
       def self.response_for(uuid)
-        ResponsePool.instance.pool[uuid]
+        Shatter::Service::ResponsePool.instance.pool[uuid]
       end
 
       def self.respond_to_missing?(method)
-        @service_definition.instance_methods.include?(method.to_sym)
+        @service_definition.new.respond_to?(method)
       end
 
       def self.set_static_result_for(uuid, result)
-        puts "Setting static content"
-        populate_pool_with_result(Time.now, {uuid:, result:}, nil)
+        populate_pool_with_result(Time.now, { uuid:, result: }, nil)
       end
 
       def self.method_missing(method, *args, &)
-        Shatter.logger.info "Mapping #{method}"
+        super unless respond_to_missing?(method)
         uuid = args[0].is_a?(Hash) ? args[0][:uuid] : args[0].uuid
-        return {error: 'missing uuid'} if uuid.nil?
+        return { error: "missing uuid" } if uuid.nil?
+
         future = @service_definition.new.async.send(method, *args, &)
         future.add_observer(self, :populate_pool_with_result)
       end
 
-      def self.populate_pool_with_result(time, value, err)
-        if err
-          Shatter.logger.info err
-        end
-        ResponsePool.instance.pool[value[:uuid]] = value
-        zk = ZooKeeperConnection.instance.client
-        key = nil
-        key = Util.zookeeper_response_key(value[:uuid])
-        my_ip = ENV["HOST_NAME"] || "localhost"
-        host = "#{my_ip}:#{Shatter::Config.service_port}"
-        Shatter.logger.info "Recording location of #{value[:uuid]} at #{host} #{value}"
-        zk.create(key, host)
-        my_ip
-      rescue Exception => e
+      def self.populate_pool_with_result(_time, value, err)
+        Shatter.logger.info err if err
+        Shatter.logger.info "#{value[:uuid]} => #{value}" unless err
+        Shatter::Service::ResponsePool.instance.pool[value[:uuid]] = value
+        Shatter::Service::Discovery.populate_result_location(value[:uuid])
+      rescue StandardError => e
         Shatter.logger.error e
         raise e
       end
 
       def self.close
         logger = Shatter.logger
-        logger.info "Closing down DRb service"
+        logger.info "Closing down DRb service: #{@service_instance}"
+        @service_instance.stop_service
         port = Shatter::Config.service_port
         uri = "localhost:#{port}"
         logger.info "Removing my existnce at #{port} to zookeeper"
@@ -80,7 +73,7 @@ module Shatter
         logger.info "Logging my existnce at #{uri} to zookeeper"
         Shatter::Service::Discovery.register_service(uri)
         logger.info "Starting DRb service"
-        DRb.start_service("druby://#{uri}", self)
+        @service_instance = DRb.start_service("druby://#{uri}", Shatter::Config.reload_classes ? ReloadWrapper : self)
         logger.info "DRb service started"
         DRb.thread.join
       end
@@ -90,4 +83,4 @@ module Shatter
       end
     end
   end
-end
+end

data/lib/shatter/service/discovery.rb

@@ -1,25 +1,30 @@
+# frozen_string_literal: true
+
+require "zk"
 module Shatter
   module Service
     class Discovery
       class << self
+        def connection_pool
+          @connection_pool ||= ZK::Pool::Bounded.new(Shatter::Config.zookeeper_host)
+        end
 
         def deregister_service(service_url)
-          zk = ZK.new (Shatter::Config.zookeeper_host)
-          if zk.exists?("/shater_service_instances/#{service_url}")
-            zk.delete("/shater_service_instances/#{service_url}")
-          end
-          zk.close
+          zk = connection_pool.checkout
+          key = Shatter::Util.instances_key
+          zk.delete("#{key}/#{service_url}") if zk.exists?("#{key}/#{service_url}")
+          connection_pool.checkin(zk)
         end
 
         def register_service(service_url)
           Shatter.logger.info "Registering #{service_url} to zookeeper"
-          zk = ZK.new (Shatter::Config.zookeeper_host)
-          unless zk.exists?("/shater_service_instances/#{service_url}")
-            created = zk.create("/shater_service_instances/#{service_url}")
+          zk = connection_pool.checkout
+          key = Shatter::Util.instances_key
+          unless zk.exists?("#{key}/#{service_url}")
+            created = zk.create("#{key}/#{service_url}")
             Shatter.logger.info "Registered #{created}"
           end
-          puts zk.children("/shater_service_instances")
-          zk.close
+          connection_pool.checkin(zk)
         end
 
         def service_instance_url
@@ -27,23 +32,31 @@ module Shatter
         end
 
         def service_instance_urls
-          zk = ZK.new (Shatter::Config.zookeeper_host)
-          urls = zk.children("/shater_service_instances")
-          zk.close
+          zk = connection_pool.checkout
+          urls = zk.children(Shatter::Util.instances_key)
+          connection_pool.checkin(zk)
           urls
         end
 
+        def populate_result_location(uuid)
+          zk = connection_pool.checkout
+          zk.create(Util.zookeeper_response_key(uuid), my_host)
+          connection_pool.checkin(zk)
+        end
+
+        def my_host
+          my_ip = ENV["HOST_NAME"] || "localhost"
+          "#{my_ip}:#{Shatter::Config.service_port}"
+        end
+
         def service_instance_url_for_uuid(uuid)
-          druby_instance_url = nil
           key = Util.zookeeper_response_key(uuid)
-          zk = ZK.new(Shatter::Config.zookeeper_host)
+          zk = connection_pool.checkout
           druby_instance_url = zk.get(key)[0] if zk.exists?(key)
-          zk.close
-          Shatter.logger.debug "Service instance url for #{uuid} - #{druby_instance_url}"
-
+          connection_pool.checkin(zk)
           druby_instance_url
         end
       end
     end
   end
-end
+end

data/lib/shatter/service/function.rb

@@ -1,56 +1,70 @@
+# frozen_string_literal: true
+
+require "erb"
+
 module Shatter
   module Service
     class Function
-
       def self.define_param(name, type:, nullable: true)
-        @@param_meta ||= {}
-        @@param_meta[name] = {name:, type:, nullable:}
+        @param_meta ||= {}
+        @param_meta[name] = { name:, type:, nullable: }
       end
 
       def self.meta
-        @@param_meta
+        @param_meta || {}
       end
+      define_param :uuid, nullable: false, type: "string"
 
-      define_param :uuid, nullable: false, type: 'string'
+      attr_reader :params
 
       def initialize(function_params)
         @params = function_params
       end
 
-      def params
-        Hash[@@param_meta.keys.map { |k| [k]}].merge(@params)
-      end
-
       def call
-        raise 'Invalid Args' unless valid_params?
-        valid_keys = @@param_meta.keys
-        {result: nil, error:nil}.merge(self.invoke.merge(uuid: params[:uuid]))
-      rescue Exception => e
-        {result: nil, error: e.message, uuid: params[:uuid]}
+        { result: nil, error: "Invalid Parameters" } unless valid_params?
+        { result: nil, error: nil }.merge(invoke.merge(uuid: params[:uuid]))
+      rescue StandardError => e
+        Shatter.logger.error e.message
+        Shatter.logger.error e.backtrace
+        { result: nil, error: "Something Went Wrong", uuid: params[:uuid] }
       end
 
       def valid_params?
-        self.class.meta.keys.each do |arg|
-          meta = self.class.meta[arg]
-          val = @params[arg]
-          puts meta
-          raise "#{arg} cannot be nil" if !meta[:nullable] && val.nil?
-          raise "expected #{arg} to be a string" if meta[:type]  == 'string' && !val.is_a?(String)
-
-          if meta[:type]  == 'integer'
-            if !meta[:nullable] && val.nil?
-              raise 'value cannot be nil'
-            end
-            if !val.nil? && !val.is_a?(Integer)
-              raise "expected #{arg} to be an integer"
-            end
-          end
+        self.class.meta.each_key do |arg|
+          return false unless valid_param?(arg)
         end
+        true
+      end
+
+      def valid_param?(arg)
+        meta = self.class.meta[arg]
+        return false if meta.nil?
+
+        meta => type:, nullable:
+        val = value_for_arg(arg)
+        return nullable if val.nil?
+
+        return false if type == "string" && !val.is_a?(String)
+        return false if type == "integer" && !val.is_a?(Integer)
+
+        true
+      end
+
+      def value_for_arg(arg)
+        @params[arg.to_s] || @params[arg.to_sym]
       end
 
       def self.invoke
-        raise 'cant invoke for base function'
+        raise "cant invoke for base function"
+      end
+
+      def self.to_typescript
+        function_nm = Shatter::Service::Base.service_definition.function_collection.to_a.detect do |fn_def|
+                        fn_def[1] == self
+                      end[0]
+        ERB.new(File.read("#{__dir__}/../../../templates/function_definition.ts.erb")).result(binding)
       end
     end
   end
-end
+end

data/lib/shatter/service/response_pool.rb

@@ -1,10 +1,15 @@
-require 'singleton'
+# frozen_string_literal: true
+
+require "singleton"
 module Shatter
-  class ResponsePool
-    include Singleton
-    attr_reader :pool
-    def initialize
-      @pool = {}
+  module Service
+    class ResponsePool
+      include Singleton
+      attr_reader :pool
+
+      def initialize
+        @pool = {}
+      end
     end
   end
-end
+end

data/lib/shatter/service/service_definition.rb

@@ -1,15 +1,21 @@
+# frozen_string_literal: true
+
 require "concurrent-ruby"
-require 'set'
 
 module Shatter
   module Service
     class ServiceDefinition
       include Concurrent::Async
       class << self
-        attr_reader :function_collection
+        attr_accessor :function_collection
+      end
+
+      def self.to_typescript
+        function_defs = @function_collection.values
+        ERB.new(File.read("#{__dir__}/../../../templates/service_client.ts.erb")).result(binding)
       end
+
       def self.register_function(identifier, function)
-        Shatter.logger.info "Registering function - #{identifier} for #{self}"
         @function_collection ||= {}
         @function_collection[identifier.to_s] = function
         define_method identifier do |params|
@@ -18,4 +24,4 @@ module Shatter
       end
     end
   end
-end
+end

data/lib/shatter/util.rb

@@ -1,19 +1,35 @@
 # frozen_string_literal: true
-require 'logger'
-require 'singleton'
+
+require "logger"
+require "singleton"
+
+class String
+  def camel_case_lower
+    split("_").inject([]) { |buffer, e| buffer.push(buffer.empty? ? e : e.capitalize) }.join
+  end
+end
 
 module Shatter
   module Util
     class Logger < ::Logger
       include Singleton
       def initialize
-        super(STDOUT, datetime_format: '%Y-%m-%d %H:%M:%S')
+        super($stdout, datetime_format: "%Y-%m-%d %H:%M:%S")
       end
     end
 
+    def self.instances_key
+      "/shater_service_instances"
+    end
+
+    def self.zookeeper_response_key_root
+      "/shatter::response_data_locations"
+    end
+
     def self.zookeeper_response_key(uuid)
-      raise 'Cant produce key without uuid' if uuid.nil?
-      "/shatter::response_data_locations/#{uuid}"
+      raise "Cant produce key without uuid" if uuid.nil?
+
+      "#{zookeeper_response_key_root}/#{uuid}"
     end
   end
 end

data/lib/shatter/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Shatter
-  VERSION = "0.0.2"
+  VERSION = "0.1.0"
 end

data/lib/shatter/web/application.rb

@@ -3,48 +3,50 @@
 require "drb/drb"
 require "concurrent-ruby"
 
-require_relative "./application"
-
 module Shatter
   module Web
     class Application
       include Concurrent::Async
 
       def response_for(uuid)
-        druby_instance_url = Shatter::Service::Discovery.service_instance_url_for_uuid(uuid)
-        return unless druby_instance_url
-        DRbObject.new_with_uri("druby://#{druby_instance_url}").response_for(uuid)
+        client = service_client(Shatter::Service::Discovery.service_instance_url_for_uuid(uuid))
+        return if client.nil?
+
+        client.response_for(uuid)
       end
 
       def route(uuid, path, params)
-        operation = path.scan(/\/(.+)$/).first&.first
-        raise 'failed to route' if operation.nil?
-        Shatter.logger.info Shatter::Service::Base.service_definition.function_collection
-        Shatter.logger.info operation
-        function = Shatter::Service::Base.service_definition.function_collection[operation]
-        if function.nil?
-          DRbObject.new_with_uri("druby://#{Shatter::Service::Discovery.service_instance_url}")
-            .set_static_result_for(uuid, {result: nil, error: :unknown_operation})
-        else
-          begin
-            func_params = params.merge(uuid:)
-            Shatter.logger.info "routing #{path}/#{func_params}"
-            DRbObject.new_with_uri("druby://#{Shatter::Service::Discovery.service_instance_url}")
-              .send(
-                operation.to_sym,
-                func_params
-              )
-          rescue ArgumentError => e
-            DRbObject.new_with_uri("druby://#{Shatter::Service::Discovery.service_instance_url}")
-              .set_static_result_for(uuid, {result: nil, error: e.message })
-          end
-        end
-      rescue Exception => e
-        Shatter.logger.error "caught error: #{e.message}"
-        Shatter.logger.error "#{e.backtrace.join("\n")}"
-        { data:, error: e.message, uuid: }
+        operation = operation_for(path)
+        return unknown_operation(uuid) if operation.nil?
+
+        client = service_client
+        client.send(operation.to_sym, params.merge(uuid:))
+      rescue StandardError => e
+        error_response(uuid, e)
+      end
+
+      protected
+
+      def unknown_operation(uuid)
+        service_client.set_static_result_for(uuid, { result: nil, error: :unknown_operation })
       end
 
+      def error_response(uuid, err)
+        Shatter.logger.error err
+        service_client.set_static_result_for(uuid, { result: nil, error: "Something went wrong" })
+      end
+
+      def service_client(druby_instance_url = Shatter::Service::Discovery.service_instance_url)
+        return if druby_instance_url.nil?
+
+        DRbObject.new_with_uri("druby://#{druby_instance_url}")
+      end
+
+      def operation_for(path)
+        operation = path.scan(%r{/(.+)$}).first&.first
+        function = Shatter::Service::Base.service_definition.function_collection[operation]
+        function.nil? ? nil : operation
+      end
     end
   end
-end
+end

data/lib/shatter/web/server.rb

@@ -6,40 +6,47 @@ require "json"
 module Shatter
   module Web
     class Server
-
       class << self
-        attr_reader :application
-        attr_writer :application
+        attr_accessor :application
       end
 
       def self.call(env)
         request = Rack::Request.new(env)
-        path = env["PATH_INFO"]
         if env["PATH_INFO"] == "/callbacks"
-          uuid = env['QUERY_STRING'].split("=")[1]
-          response_for(uuid)
-        elsif env["PATH_INFO"] == "/base_time"
-          [200, {}, [""]]
+          uuid = env["QUERY_STRING"].split("=")[1]
+          handle_response_for_request(uuid)
+        elsif request.post?
+          handle_operation_request(env)
         else
-          params = JSON.parse(request.body.read, {symbolize_names: true})
-          uuid = SecureRandom.uuid
-          future = application.new.async.route(uuid, path, params)
-          future.add_observer(:server_call_result, self)
-          [200, { "delay" => "20", "location" => "/callbacks?uuid=#{uuid}" }, []]
+          [404, {}, []]
+        end
+      end
+
+      def self.handle_operation_request(env)
+        request = Rack::Request.new(env)
+        params = begin
+          JSON.parse(request.body.read, { symbolize_names: true })
+        rescue StandardError
+          {}
         end
+        uuid = SecureRandom.uuid
+        future = application.new.async.route(uuid, request.path, params)
+        future.add_observer(:service_callback, self)
+        [200, { "delay" => Shatter::Config.initial_delay, "location" => "/callbacks?uuid=#{uuid}" }, []]
       end
 
-      def self.server_call_result(time, value, error)
+      def self.service_callback(_time, _value, error)
         return if error.nil?
-        Shatter.logger.error "#{ error }"
+
+        Shatter.logger.error error.to_s
       end
 
-      def self.response_for(uuid)
+      def self.handle_response_for_request(uuid)
         response = application.new.response_for(uuid)
         return [200, {}, [response.to_json]] unless response.nil?
 
-        [200, { "delay" => "100", "location" => "/callbacks?uuid=#{uuid}" }, []]
+        [200, { "delay" => Shatter::Config.missing_result_delay, "location" => "/callbacks?uuid=#{uuid}" }, []]
       end
     end
   end
-end
+end

data/lib/shatter.rb

@@ -1,21 +1,69 @@
 # frozen_string_literal: true
 
-require_relative "shatter/version"
-require_relative "shatter/web/application"
-require_relative "shatter/config"
-require_relative "shatter/web/server"
-require_relative "shatter/service/base"
-require_relative "shatter/service/discovery"
-require_relative "shatter/service/service_definition"
-require_relative "shatter/service/response_pool"
-require_relative "shatter/util"
-
-$stdout.sync = true
+require "zeitwerk"
+require "concurrent/atomic/read_write_lock"
+Dir["#{__dir__}/shatter/service/*.rb"].each { |file| require file }
+Dir["#{__dir__}/shatter/web/*.rb"].each { |file| require file }
+Dir["#{__dir__}/shatter/ext/*.rb"].each { |file| require file }
+require_relative "./shatter/config"
+require_relative "./shatter/util"
+require_relative "./shatter/version"
 
 module Shatter
   class Error < StandardError; end
+
+  def self.root
+    current = Dir.pwd
+    root_dir = nil
+
+    while current.size >= 1 && root_dir.nil?
+      root_dir = current if Dir.children(current).include?("Gemfile")
+      current = File.expand_path("..", current) if root_dir.nil?
+      Dir.new(current)
+    end
+    root_dir
+  end
+
   def self.logger
     Util::Logger.instance
   end
+
+  def self.config(&block)
+    block.call(Config) and return if block_given?
+
+    Config
+  end
+
+  def self.loader
+    @loader
+  end
+
+  def self.load_environment
+    require "#{Shatter.root}/config/environment.rb"
+  end
+
+  def self.reload
+    @loader.reload
+    link_definitions
+  end
+
+  def self.load
+    # @loader = Zeitwerk::Loader.for_gem
+    @loader = Zeitwerk::Loader.new
+    @loader.tag = File.basename(__FILE__, ".rb")
+    @loader.inflector = Zeitwerk::GemInflector.new(__FILE__)
+    Config.autoload_paths.each do |path|
+      @loader.push_dir(File.expand_path(path, root))
+    end
+    @loader.enable_reloading
+    @loader.setup # ready!
+    link_definitions
+  end
+
+  def self.link_definitions
+    Shatter::Service::Base.service_definition = ServiceDefinition if Object.const_defined?("ServiceDefinition")
+    Shatter::Web::Server.application = Application if Object.const_defined?("Application")
+  end
   # Your code goes here...
 end
+Shatter::RELOAD_RW_LOCK = Concurrent::ReadWriteLock.new

data/package.json

@@ -0,0 +1,7 @@
+{
+  "devDependencies": {
+    "@commitlint/cli": "^17.4.2",
+    "@commitlint/config-conventional": "^17.4.2",
+    "husky": "^8.0.3"
+  }
+}

data/templates/Gemfile.template

@@ -1,5 +1,3 @@
 source "https://rubygems.org"
-gem 'shatter', path: '..'
-gem "zookeeper", "~>1.5.4", github: 'EricRoos/zookeeper'
+gem 'shatter-rb'
 
-gem "foreman", "~> 0.87.2"

data/templates/application.erb

@@ -1,6 +1,2 @@
-module <%= app_name %>
-  class Application < Shatter::Web::Application
-  end
-end
-
-require_relative './app/service_definition'
+class Application < Shatter::Web::Application
+end

data/templates/config.ru

@@ -2,8 +2,16 @@
 
 require "bundler/setup"
 require "shatter"
+require "rack/cors"
 
 require_relative "./config/environment"
 
 use Rack::CommonLogger
+
+use Rack::Cors do
+  allow do
+    origins "*"
+    resource "*", headers: :any, methods: %i[get post patch put], expose: %w[delay location]
+  end
+end
 run Shatter::Web::Server