micro-rb 0.1.0.rc2 → 0.1.0.rc3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: d4214b295604dcf084cac803a951262200ec128b
-  data.tar.gz: e345620800f3507ba539a95ed35c703fd0643229
+  metadata.gz: d1b9ae456a543d65ed8a7d4d65edded21fffdf94
+  data.tar.gz: 03e81e3baa4a7985dd955d041347c9bc8140edcd
 SHA512:
-  metadata.gz: 06afa4711aa6ea7414a3974c1f84a09dc31f325dd5e107cfefb702c5febbc054064e652ac6ca7acad8b3b117e9baa8326341f69fb5c40d5a64a4aa1d6b0d487f
-  data.tar.gz: 74063eab50bcd01092800c9003f6ee30bb53a657537b0607f18528dbf006708f1918791d79b1f595927b0f31c65c5c98245157056ae8f0d080d4931e3f2981c2
+  metadata.gz: c9f1f7428fc1e2b9339e2ea837b8ecff2bf43a28a6c29b5aa13470c66fdfe5f0f8aa50cb5d3f8b04f849564ec65ec8e92f2e1575b52c2cbef71953a2cde09b62
+  data.tar.gz: 65e6b5381fe0c9f9c57f24afd047596986cf6af00355fc8c8db8c111e1d302af742ba6cb7aa0c1f8a7006d3bd27328c2eede70a295c3d9a4fa936c265944b2dd

data/.rubocop.yml

@@ -1305,7 +1305,7 @@ Metrics/ModuleLength:
   Max: 100
 
 Metrics/ParameterLists:
-  Max: 5
+  Max: 6
   CountKeywordArgs: true
 
 Metrics/PerceivedComplexity:

data/Gemfile

@@ -8,3 +8,5 @@ gemspec
 gem 'awesome_print'
 gem 'puma'
 gem 'rubocop', '~> 0.48.1', require: false
+
+gem 'celluloid-io'

data/README.md

@@ -67,8 +67,10 @@ class MyHandler
   end
 end
 
-server = MicroRb::Servers::Web.new(:test, debug: true)
-server.add_handler MyHandler.new
+service_config = MicroRb::ServiceConfiguration.new(name: :test)
+service_config.add_handler(MyHandler.new)
+
+server = MicroRb::Servers::Web.new(service_config)
 server.start!
 
 ```
@@ -81,7 +83,7 @@ Configuration has the following defaults for sidecar endpoint.
 
 `Registy: "/registry"`
 
-Configuration has the following defaults for api gateway.
+Configuration has the following defaults for the micro api.
 
 `Host: http://127.0.0.1`
 
@@ -97,9 +99,9 @@ MicroRb::Configuration.configure do |c|
   c.sidecar_port     = '8080'
   c.sidecar_registry = '/awesome_registry'
   
-  c.gateway_host  = 'http://mysite.com'
-  c.gateway_port  = '8080'
-  c.gateway_rpc   = '/awesome_micro_rb'
+  c.api_host  = 'http://mysite.com'
+  c.api_port  = '8080'
+  c.api_rpc   = '/awesome_micro_rb'
 end
 ```
 
@@ -108,7 +110,8 @@ This works with thin etc because we just pass the options along to the rack serv
 
 ```ruby
 require 'rack/handler/puma'
-server = MicroRb::Servers::Web.new(:test, debug: true, server: :puma)
+service_config = MicroRb::ServiceConfiguration.new(name: :test, server: :puma)
+server = MicroRb::Servers::Web.new(service_config)
 ```
 
 Every handler must setup the following requirements at a minimum.
@@ -123,7 +126,7 @@ Every handler must include a prtobuf module that has `Request` and `Response` co
 ![alt text](https://github.com/amedeiros/micro-rb/blob/master/sum.png)
 
 
-## Micro API Gateway
+## Micro API
 
 `micro api --address 0.0.0.0:3002`
 

data/lib/micro/clients/rpc.rb

@@ -6,10 +6,10 @@ module MicroRb
     class Rpc
       include Base
 
-      base_uri MicroRb::Configuration.instance.gateway_uri
+      base_uri MicroRb::Configuration.instance.api_uri
 
       def self.call(service:, method:, params:, klass_response: nil)
-        response = post(MicroRb::Configuration.instance.gateway_rpc,
+        response = post(MicroRb::Configuration.instance.api_rpc,
                         options(service: service, method: method, request: params))
 
         return klass_response.new(response.to_h.symbolize_keys!) if klass_response

data/lib/micro/clients/tcp.rb

@@ -0,0 +1,39 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'celluloid/current'
+require 'celluloid/io'
+
+module MicroRb
+  module Clients
+    class TCP
+      attr_reader :host, :port
+
+      def initialize(host, port)
+        @host = host
+        @port = port
+      end
+
+      def call(service:, method:, params:, klass_response: nil)
+        response = nil
+
+        Celluloid::IO::TCPSocket.open(host, port) do |sock|
+          msg = { service: service, method: method, params: params }
+          json = MultiJson.encode(msg)
+          sock.write(json)
+          response = MultiJson.decode(sock.readpartial(4096))
+        end
+
+        return klass_response.new(response.to_h.symbolize_keys!) if klass_response
+
+        response
+      end
+
+      def self.call(service:, method:, params:, host:, port:, klass_response: nil)
+        new(host, port)
+          .call(service: service, method: method,
+                params: params, klass_response: klass_response)
+      end
+    end
+  end
+end

data/lib/micro/configuration.rb

@@ -8,8 +8,8 @@ module MicroRb
     # Sidecar settings
     attr_accessor :sidecar_registry, :sidecar_host, :sidecar_port
 
-    # API gateway settings
-    attr_accessor :gateway_host, :gateway_port, :gateway_rpc
+    # Micro API settings
+    attr_accessor :api_host, :api_port, :api_rpc
 
     def self.configure
       yield(instance) if block_given?
@@ -23,12 +23,12 @@ module MicroRb
       "#{sidecar_uri}#{sidecar_registry}"
     end
 
-    def gateway_uri
-      "#{gateway_host}:#{gateway_port}"
+    def api_uri
+      "#{api_host}:#{api_port}"
     end
 
-    def gateway_rpc_uri
-      "#{gateway_uri}#{gateway_rpc}"
+    def api_rpc_uri
+      "#{api_uri}#{api_rpc}"
     end
 
     private
@@ -41,10 +41,10 @@ module MicroRb
       self.sidecar_registry ||= '/registry'
       self.sidecar_port     ||= '8081'
 
-      # Default API gateway settings
-      self.gateway_host ||= 'http://127.0.0.1'
-      self.gateway_rpc  ||= '/rpc'
-      self.gateway_port ||= '3002'
+      # Default micro API settings
+      self.api_host ||= 'http://127.0.0.1'
+      self.api_rpc  ||= '/rpc'
+      self.api_port ||= '3002'
     end
   end
 end

data/lib/micro/examples/fib.rb

@@ -37,8 +37,10 @@ class FibHandler
   end
 end
 
-server = MicroRb::Servers::Web.new(:test, debug: true, metadata: { example: 'Fib Service' }, server: :puma)
-server.add_handler FibHandler.new
+service_config = MicroRb::ServiceConfiguration.new(name: :test, metadata: { example: 'Fib Service' }, server: :puma)
+service_config.add_handler(FibHandler.new)
+
+server = MicroRb::Servers::Web.new(service_config)
 server.start!
 
 # MicroRb::Clients::Rpc.call(service: :test, method: 'FibHandler.fibonacci', params: { n:  15 } )

data/lib/micro/examples/sum.rb

@@ -17,6 +17,8 @@ class MyHandler
   end
 end
 
-server = MicroRb::Servers::Web.new(:test, debug: true, metadata: { example: 'Service' })
-server.add_handler MyHandler.new
+service_config = MicroRb::ServiceConfiguration.new(name: :test, metadata: { example: 'Service' })
+service_config.add_handler(MyHandler.new)
+
+server = MicroRb::Servers::Web.new(service_config)
 server.start!

data/lib/micro/examples/sum_tcp.rb

@@ -0,0 +1,24 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require_relative '../../../lib/microrb'
+require_relative '../examples/proto/sum_pb'
+
+class TcpSumExample
+  include MicroRb::Handler
+  include MicroRb::SumHandler
+
+  handler name: :test, metadata: { hello: 'Micro-Rb' }, rpc_method: :sum
+
+  def sum(request: Request.new, response: Response.new)
+    response.total = request.a + request.b
+
+    response
+  end
+end
+
+service_config = MicroRb::ServiceConfiguration.new(name: :tcp_example)
+service_config.add_handler(TcpSumExample.new)
+
+server = MicroRb::Servers::TCP.new(service_config)
+server.start!

data/lib/micro/request_manager.rb

@@ -0,0 +1,79 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module MicroRb
+  class RequestManager
+    attr_reader :handler_manager
+
+    REQUIRED_TYPES = { method: [String], params: [Hash, Array],
+                       id: [String, Integer, NilClass] }.freeze
+
+    REQUIRED_KEYS  = ['method'].freeze
+
+    def initialize(handler_manager = MicroRb::HandlerManager.new)
+      @handler_manager = handler_manager
+      # Add the default debug handler
+      handler_manager.add_handler(MicroRb::Handlers::Debug.new)
+    end
+
+    def handle_request(request)
+      response = nil
+
+      begin
+        request  = decode(request)
+        response = create_response(request) if valid_request?(request)
+        response ||= error_response(MicroRb::Servers::Error::InvalidRequest.new, request)
+      rescue MultiJson::ParseError => e
+        MicroRb.logger.warn(e)
+        response = error_response(MicroRb::Servers::Error::ParseError.new)
+      rescue StandardError => e
+        MicroRb.logger.warn(e)
+        response = error_response(MicroRb::Servers::Error::InternalError.new(e), request)
+      end
+
+      MultiJson.encode(response)
+    end
+
+    private
+
+    def create_response(request)
+      method = request[:method].strip.to_sym
+      params = Array.wrap(request[:params]).map(&:symbolize_keys)
+
+      unless handler_manager.rpc_method?(method)
+        return error_response(MicroRb::Servers::Error::MethodNotFound.new(method), request)
+      end
+
+      response = handler_manager.call_rpc_method(method, params)
+
+      success_response(request, response)
+    end
+
+    def valid_request?(request)
+      return false unless request.is_a?(Hash)
+
+      REQUIRED_KEYS.each do |key|
+        return false unless request.key?(key)
+      end
+
+      REQUIRED_TYPES.each do |key, types|
+        return false if request.key?(key) &&
+                        types.none? { |type| request[key].is_a?(type) }
+      end
+
+      true
+    end
+
+    def success_response(request, result)
+      { result: result, id: request['id'] }
+    end
+
+    def error_response(error, request = {})
+      { error: error.to_h, id: request['id'] }
+    end
+
+    def decode(request)
+      MultiJson.decode(request).with_indifferent_access
+    end
+  end
+end

data/lib/micro/servers/tcp.rb

@@ -0,0 +1,48 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+require 'celluloid/current'
+require 'celluloid/io'
+
+module MicroRb
+  module Servers
+    class TCP
+      include Celluloid::IO
+
+      attr_reader :server, :service_config
+
+      finalizer :shutdown
+
+      def initialize(service_config)
+        @service_config  = service_config
+        @server          = TCPServer.new(service_config.host, service_config.port)
+      end
+
+      def shutdown
+        @server&.close
+      end
+
+      def start!
+        service_config.register!
+        loop { async.handle_connection @server.accept }
+      end
+
+      private
+
+      def handle_connection(socket)
+        _, port, host = socket.peeraddr
+        MicroRb.logger.debug("*** Received connection from #{host}:#{port}")
+
+        loop do
+          request  = socket.readpartial(4096)
+          response = service_config.request_manager.handle_request(request)
+          socket.write(response)
+          socket.flush
+        end
+      rescue EOFError => e
+        MicroRb.logger.debug("*** #{host}:#{port} disconnected", e)
+        socket.close
+      end
+    end
+  end
+end

data/lib/micro/servers/web.rb

@@ -4,70 +4,21 @@
 require 'rack'
 require 'rack/request'
 require 'rack/response'
-require 'multi_json'
 
 module MicroRb
   module Servers
     class Web
-      attr_accessor :host, :port, :show_errors, :debug, :metadata, :version,
-                    :handler_manager, :name, :node_id, :server
+      attr_accessor :service_config, :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.metadata = opts.delete(:metadata) || {}
-        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
-
-        server_opts = opts.merge(Host: host, Port: port, app: self)
+      def initialize(service_config)
+        self.service_config = service_config
+        server_opts = service_config.options.merge(Host: service_config.host, Port: service_config.port, app: self)
         self.server = Rack::Server.new(server_opts)
       end
 
-      def add_handler(handler)
-        handler_manager.add_handler(handler)
-      end
-
       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::Clients::Sidecar.register(self).response.value
-
-        if debug
-          MicroRb.logger
-                 .debug("Registered #{name}:#{host}:#{port} with sidecar.")
-        end
-
-        add_finalizer_hook!
+        service_config.register!
         server.start
-      rescue Net::HTTPFatalError => e
-        msg = "Sidecar error: #{e.message}"
-        MicroRb.logger.warn(msg)
-
-        raise MicroRb::Servers::Error::ServerError.new(-32_000, msg)
-      end
-
-      def to_h
-        {
-          version: version,
-          metadata: metadata,
-          name: name,
-          nodes: [{ id: node_id, address: host, port: port }],
-          endpoints: handler_manager.endpoints
-        }
-      end
-
-      def to_json
-        to_h.to_json
       end
 
       #
@@ -79,73 +30,11 @@ module MicroRb
 
         return resp.finish unless req.post?
 
-        resp.write handle_request(req.body.read)
-        resp.finish
-      end
+        request  = req.body.read
+        response = service_config.request_manager.handle_request(request)
 
-      def create_response(request)
-        method  = request['method'].strip.to_sym
-        params  = request['params'].map(&:symbolize_keys!)
-
-        return error_response(Error::MethodNotFound.new(method), request) unless handler_manager.rpc_method?(method)
-
-        response = handler_manager.call_rpc_method(method, params)
-
-        success_response(request, response)
-      end
-
-      def handle_request(request)
-        request  = parse_request(request)
-        response = nil
-
-        begin
-          response = create_response(request) if valid_request?(request)
-          response ||= error_response(Error::InvalidRequest.new, request)
-        rescue MultiJson::ParseError => e
-          MicroRb.logger.warn(e)
-          response = error_response(Error::ParseError.new)
-        rescue StandardError => e
-          MicroRb.logger.warn(e)
-          response = error_response(Error::InternalError.new(e), request)
-        end
-
-        MultiJson.encode(response)
-      end
-
-      private
-
-      def valid_request?(request)
-        return false unless request.is_a?(Hash)
-
-        REQUIRED_KEYS.each do |key|
-          return false unless request.key?(key)
-        end
-
-        REQUIRED_TYPES.each do |key, types|
-          return false if request.key?(key) &&
-                          types.none? { |type| request[key].is_a?(type) }
-        end
-
-        true
-      end
-
-      def success_response(request, result)
-        { result: result, id: request['id'] }
-      end
-
-      def error_response(error, request = {})
-        { error: error.to_h, id: request['id'] }
-      end
-
-      def add_finalizer_hook!
-        at_exit do
-          MicroRb.logger.debug("Shutting down #{name}:#{host}:#{port}") if debug
-          MicroRb::Clients::Sidecar.remove(self)
-        end
-      end
-
-      def parse_request(request)
-        MultiJson.decode(request)
+        resp.write(response)
+        resp.finish
       end
     end
   end

data/lib/micro/service_configuration.rb

@@ -0,0 +1,61 @@
+# coding: utf-8
+# frozen_string_literal: true
+
+module MicroRb
+  class ServiceConfiguration
+    attr_accessor :name, :port, :host, :metadata,
+                  :version, :node_id, :options, :request_manager
+
+    def initialize(options = {})
+      self.port     = options.delete(:port)     || 3000
+      self.host     = options.delete(:host)     || '0.0.0.0'
+      self.metadata = options.delete(:metadata) || {}
+      self.version  = options.delete(:version)  || '0.0.1'
+      self.name     = options.delete(:name)
+      self.node_id  = "#{name}-#{SecureRandom.uuid}"
+      self.options  = options
+      self.request_manager = MicroRb::RequestManager.new
+    end
+
+    def add_handler(handler)
+      request_manager.handler_manager.add_handler(handler)
+    end
+
+    def to_h
+      {
+        version: version,
+        metadata: metadata,
+        name: name,
+        nodes: [{ id: node_id, address: host, port: port }],
+        endpoints: request_manager.handler_manager.endpoints
+      }
+    end
+
+    def to_json
+      to_h.to_json
+    end
+
+    def register!
+      # Value will raise an error on anything not 2XX
+      MicroRb::Clients::Sidecar.register(self).response.value
+
+      MicroRb.logger.debug("Registered #{name}:#{host}:#{port} with sidecar.")
+
+      add_finalizer_hook!
+    rescue Net::HTTPFatalError => e
+      msg = "Sidecar error: #{e.message}"
+      MicroRb.logger.warn(msg)
+
+      raise MicroRb::Servers::Error::ServerError.new(-32_000, msg)
+    end
+
+    private
+
+    def add_finalizer_hook!
+      at_exit do
+        MicroRb.logger.debug("Shutting down #{name}:#{host}:#{port}")
+        MicroRb::Clients::Sidecar.remove(self)
+      end
+    end
+  end
+end

data/lib/micro/version.rb

@@ -2,5 +2,5 @@
 # frozen_string_literal: true
 
 module MicroRb
-  VERSION = '0.1.0.rc2'
+  VERSION = '0.1.0.rc3'
 end

data/lib/microrb.rb

@@ -4,6 +4,7 @@
 require 'bundler/setup'
 require 'active_support/all'
 require 'semantic_logger'
+require 'multi_json'
 
 module MicroRb
   include SemanticLogger::Loggable
@@ -15,12 +16,16 @@ end
 
 require 'micro/version'
 require 'micro/configuration'
+require 'micro/service_configuration'
 require 'micro/clients/base'
 require 'micro/clients/sidecar'
 require 'micro/clients/rpc'
 require 'micro/clients/http'
+require 'micro/clients/tcp'
 require 'micro/handler'
 require 'micro/handler_manager'
+require 'micro/request_manager'
 require 'micro/servers/web'
 require 'micro/servers/error'
+require 'micro/servers/tcp'
 require 'micro/handlers/debug'

data/micro-rb.gemspec

@@ -27,6 +27,7 @@ Gem::Specification.new do |spec|
   spec.add_development_dependency 'minitest', '~> 5.0'
   spec.add_development_dependency 'minitest-reporters', '~> 1.1'
   spec.add_development_dependency 'shoulda', '~> 3.5'
+  spec.add_development_dependency 'mocha', '~> 1.2'
 
   spec.add_runtime_dependency 'activesupport', '~> 5.1', '>= 5.1.0'
   spec.add_runtime_dependency 'httparty', '~> 0.14.0'

data/templates/bin/app

@@ -12,6 +12,9 @@ ActiveRecord::Base.establish_connection(
     password: ENV[:DB_PASSWORD]
 )
 <% end %>
-server = MicroRb::Servers::Web.new(:example_service, debug: true)
-server.add_handler <%= @class_name %>::ExampleHandler.new
+
+service_config = MicroRb::ServiceConfiguration(name: :example_service)
+service_config.add_handler(<%= @class_name %>::ExampleHandler.new)
+
+server = MicroRb::Servers::Web.new(service_config)
 server.start!

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: micro-rb
 version: !ruby/object:Gem::Version
-  version: 0.1.0.rc2
+  version: 0.1.0.rc3
 platform: ruby
 authors:
 - Andrew Medeiros
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-05-12 00:00:00.000000000 Z
+date: 2017-05-17 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: bundler
@@ -80,6 +80,20 @@ dependencies:
     - - "~>"
       - !ruby/object:Gem::Version
         version: '3.5'
+- !ruby/object:Gem::Dependency
+  name: mocha
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
 - !ruby/object:Gem::Dependency
   name: activesupport
   requirement: !ruby/object:Gem::Requirement
@@ -221,6 +235,7 @@ files:
 - lib/micro/clients/http.rb
 - lib/micro/clients/rpc.rb
 - lib/micro/clients/sidecar.rb
+- lib/micro/clients/tcp.rb
 - lib/micro/configuration.rb
 - lib/micro/examples/fib.rb
 - lib/micro/examples/proto/fib.proto
@@ -228,14 +243,18 @@ files:
 - lib/micro/examples/proto/sum.proto
 - lib/micro/examples/proto/sum_pb.rb
 - lib/micro/examples/sum.rb
+- lib/micro/examples/sum_tcp.rb
 - lib/micro/handler.rb
 - lib/micro/handler_manager.rb
 - lib/micro/handlers/debug.rb
 - lib/micro/project_generator.rb
 - lib/micro/proto/debug.proto
 - lib/micro/proto/debug_pb.rb
+- lib/micro/request_manager.rb
 - lib/micro/servers/error.rb
+- lib/micro/servers/tcp.rb
 - lib/micro/servers/web.rb
+- lib/micro/service_configuration.rb
 - lib/micro/version.rb
 - lib/microrb.rb
 - micro-rb.gemspec