web.rb in micro-rb-0.1.0.rc2

- old
+ new

@@ -7,23 +7,23 @@
 require 'multi_json'
 
 module MicroRb
   module Servers
     class Web
-      attr_accessor :host, :port, :show_errors, :debug, :metadata, :version
-      attr_accessor :handler_manager, :name, :node_id, :server
+      attr_accessor :host, :port, :show_errors, :debug, :metadata, :version,
+                    :handler_manager, :name, :node_id, :server
 
       REQUIRED_TYPES = { method: [String], params: [Hash, Array],
                          id: [String, Integer, NilClass] }.freeze
 
       REQUIRED_KEYS  = ['method'].freeze
 
       def initialize(name, opts = {})
-        self.port     = opts.delete(:port)  || 3000
-        self.host     = opts.delete(:host)  || '0.0.0.0'
+        self.port     = opts.delete(:port)     || 3000
+        self.host     = opts.delete(:host)     || '0.0.0.0'
         self.metadata = opts.delete(:metadata) || {}
-        self.version  = opts.delete(:version) || '0.0.1'
+        self.version  = opts.delete(:version)  || '0.0.1'
         self.debug    = opts.delete(:debug)
         self.name     = name
         self.node_id  = "#{name}-#{SecureRandom.uuid}"
         self.handler_manager = MicroRb::HandlerManager.new
 
@@ -38,11 +38,11 @@
       def start!
         # Register the debug handler. This is kinda poor.
         add_handler(MicroRb::Handlers::Debug.new)
 
         # Value will raise an error on anything not 2XX
-        MicroRb::Sidecar::Register.notify(self).response.value
+        MicroRb::Clients::Sidecar.register(self).response.value
 
         if debug
           MicroRb.logger
                  .debug("Registered #{name}:#{host}:#{port} with sidecar.")
         end
@@ -77,31 +77,21 @@
         req  = Rack::Request.new(env)
         resp = Rack::Response.new
 
         return resp.finish unless req.post?
 
-        resp.write process(req.body.read)
+        resp.write handle_request(req.body.read)
         resp.finish
       end
 
-      def process(content)
-        response = handle_request(content)
-
-        MultiJson.encode(response)
-      end
-
       def create_response(request)
         method  = request['method'].strip.to_sym
         params  = request['params'].map(&:symbolize_keys!)
 
-        unless handler_manager.rpc_method?(method)
-          return error_response(Error::MethodNotFound.new(method), request)
-        end
+        return error_response(Error::MethodNotFound.new(method), request) unless handler_manager.rpc_method?(method)
 
-        rpc_method = handler_manager.rpc_method(method)
-        response   = rpc_method.call(request: handler_manager.rpc_method_request(method, params),
-                                     response: handler_manager.rpc_method_response(method))
+        response = handler_manager.call_rpc_method(method, params)
 
         success_response(request, response)
       end
 
       def handle_request(request)
@@ -117,11 +107,11 @@
         rescue StandardError => e
           MicroRb.logger.warn(e)
           response = error_response(Error::InternalError.new(e), request)
         end
 
-        response
+        MultiJson.encode(response)
       end
 
       private
 
       def valid_request?(request)
@@ -148,10 +138,10 @@
       end
 
       def add_finalizer_hook!
         at_exit do
           MicroRb.logger.debug("Shutting down #{name}:#{host}:#{port}") if debug
-          MicroRb::Sidecar::Register.remove(self)
+          MicroRb::Clients::Sidecar.remove(self)
         end
       end
 
       def parse_request(request)
         MultiJson.decode(request)