rough 0.2.5

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: a468899e1c99040aeeb6ae39e39dbc053dbcbeff
+  data.tar.gz: df0d272d7cd18682fc2e95529eb5a8fd2321c7ea
+SHA512:
+  metadata.gz: 0237bab2668299a304339f7fc481e98d053ca03c119c40f2e77873033634dc58c80f9a0a345de56b051428ed3bede0c779964692ca44956ceb85c47c9e14623c
+  data.tar.gz: 71c71fb2bc285bd0d85818a7a81da5254fa4b1b06beb21e4511ad6813c7fc3b18e223f51d251ca0cda13d234c18e50392eada037bd5677a45430c1f0d1e837de

data/lib/rough.rb

@@ -0,0 +1,5 @@
+require_relative 'rough/engine'
+
+# Rough
+module Rough
+end

data/lib/rough/base_controller.rb

@@ -0,0 +1,73 @@
+require_relative 'rpc_registry'
+require_relative 'invalid_request_proto'
+require 'action_dispatch'
+
+module Rough
+
+  module BaseController
+
+    PROTO_MIME = Mime::Type.new('application/x-protobuf')
+
+    def self.included(base)
+      base.class_eval do
+        before_action :log_proto, if: :rpc?
+        alias_method_chain :params, :request_proto
+      end
+    end
+
+    def render(options = {})
+      return if performed?
+      if rpc?
+        if request.accept == PROTO_MIME || request.content_type == PROTO_MIME
+          response.headers['Content-Type'] = PROTO_MIME.to_s
+          super text: response_proto.encode, status: options[:status]
+        else
+          super json: response_proto.to_json, status: options[:status]
+        end
+      else
+        super
+      end
+    end
+
+    def request_proto
+      return nil unless rpc?
+      @request_proto ||=
+        if request.content_type == PROTO_MIME
+          RpcRegistry.request_class_for(rpc_name).decode(request.body.read)
+        else
+          RpcRegistry.request_class_for(rpc_name).new(params_without_request_proto)
+        end
+    rescue TypeError => e
+      raise InvalidRequestProto, e
+    end
+
+    def response_proto
+      return nil unless rpc?
+      @response_proto ||= RpcRegistry.response_class_for(rpc_name).new
+    end
+
+    private
+
+    def params_with_request_proto
+      if rpc?
+        ActionController::Parameters.new(request_proto.to_hash)
+      else
+        params_without_request_proto
+      end
+    end
+
+    def rpc?
+      rpc_name
+    end
+
+    def log_proto
+      Rails.logger.info("  Request Proto: #{request_proto.inspect}")
+    end
+
+    def rpc_name
+      params_without_request_proto[:rpc]
+    end
+
+  end
+
+end

data/lib/rough/engine.rb

@@ -0,0 +1,15 @@
+require_relative 'middleware'
+require_relative 'base_controller'
+require 'rails/engine'
+
+module Rough
+
+  class Engine < Rails::Engine
+
+    initializer 'rough_engine.middleware' do |app|
+      app.middleware.insert_after ActionDispatch::ParamsParser, Rough::Middleware
+    end
+
+  end
+
+end

data/lib/rough/invalid_request_proto.rb

@@ -0,0 +1,6 @@
+module Rough
+
+  class InvalidRequestProto < StandardError
+  end
+
+end

data/lib/rough/invalid_route.rb

@@ -0,0 +1,6 @@
+module Rough
+
+  class InvalidRoute < StandardError
+  end
+
+end

data/lib/rough/middleware.rb

@@ -0,0 +1,35 @@
+require_relative 'route_registry'
+
+module Rough
+
+  class Middleware
+
+    # This is the format for the service routes.  It is expected to capture
+    # service_name and method_name (as named regex matches) from the given URL.
+    ROUTE_FORMAT = %r{^/services/(?<service_name>.+)/(?<method_name>.+)$}
+
+    def initialize(app)
+      @app = app
+    end
+
+    def call(env)
+      path = env['PATH_INFO']
+      if env['REQUEST_METHOD'] == 'POST'
+        match = path.match(ROUTE_FORMAT)
+        if match
+          # re-map this route if we detect a matching RPC
+          rpc_route = RouteRegistry.rpc_route_for(match[:service_name], match[:method_name])
+          if rpc_route
+            env['PATH_INFO'] = rpc_route.path
+            env['REQUEST_METHOD'] = rpc_route.request_method
+            env['HTTP_ACCEPT'] = 'application/x-protobuf'
+            env['HTTP_CONTENT_TYPE'] = 'application/x-protobuf'
+          end
+        end
+      end
+      @app.call(env)
+    end
+
+  end
+
+end

data/lib/rough/route.rb

@@ -0,0 +1,39 @@
+require_relative 'invalid_route'
+
+module Rough
+
+  class Route
+
+    attr_reader :route
+
+    def initialize(route)
+      @route = route
+    end
+
+    def path
+      @path ||= load_path
+    end
+
+    def request_method
+      @request_method ||= load_request_method
+    end
+
+    private
+
+    def load_request_method
+      method_rule = @route.constraints[:request_method]
+      methods = ActionDispatch::Request::RFC2616.select { |t| t =~ method_rule }
+      methods.count == 1 ? methods.first : fail(InvalidRoute)
+    end
+
+    def load_path
+      fake_defaults = @route.defaults.dup
+      fake_defaults[:only_path] = true
+      @route.segments.each { |s| fake_defaults[s.to_sym] = s }
+      path = Rails.application.routes.url_for(fake_defaults)
+      path || fail(InvalidRoute)
+    end
+
+  end
+
+end

data/lib/rough/route_registry.rb

@@ -0,0 +1,67 @@
+require_relative 'route'
+require_relative 'invalid_route'
+
+module Rough
+
+  module RouteRegistry
+
+    class << self
+
+      def rpc_route_for(service_name, method_name)
+        return cached_routes[service_name][method_name] if cached_routes[service_name].key?(method_name)
+        route = find_route(service_name, method_name)
+        cached_routes[service_name][method_name] = route ? Route.new(route) : nil
+      end
+
+      # Warm up cache for each defined RPC route
+      def warm!
+        rpc_driven_routes.each do |route|
+          service_name, method_name = route.defaults[:rpc].split('#')
+
+          # java-ize service name
+          service_segments = service_name.split('::')
+          final_service_name = service_segments.pop
+          service_name = (service_segments.map(&:underscore) << final_service_name).join('.')
+
+          # java-ize method name
+          method_name = method_name.camelize
+
+          cached_routes[service_name][method_name] = Route.new(route)
+        end
+      end
+
+      private
+
+      def cached_routes
+        @cached_routes ||= Hash.new { |h, k| h[k] = {} }
+      end
+
+      # find a particular rails route for a given service_name and method_name
+      def find_route(matched_service_name, matched_method_name)
+        rpc_driven_routes.find do |route|
+          service_name, method_name = route.defaults[:rpc].split('#')
+
+          # ruby-ize service name
+          matched_service_segments = matched_service_name.split('.')
+          final_service_name = matched_service_segments.pop
+          matched_service_name = (matched_service_segments.map(&:capitalize) << final_service_name).join('::')
+
+          # ruby-ize method name
+          matched_method_name = matched_method_name.underscore
+
+          # does it match
+          matched_service_name == service_name && matched_method_name == method_name
+        end
+      end
+
+      def rpc_driven_routes
+        Rails.application.routes.routes.lazy.select do |route|
+          route.defaults && route.defaults[:rpc]
+        end
+      end
+
+    end
+
+  end
+
+end

data/lib/rough/rpc_registry.rb

@@ -0,0 +1,42 @@
+require 'protobuf'
+
+module Rough
+
+  module RpcRegistry
+
+    class << self
+
+      def request_class_for(rpc_name)
+        rpc_for(rpc_name).request_type
+      end
+
+      def response_class_for(rpc_name)
+        rpc_for(rpc_name).response_type
+      end
+
+      private
+
+      def rpc_for(rpc_name)
+        return method_structs[rpc_name] if method_structs.key?(rpc_name)
+
+        # TODO: in the future, should you be able to pass in a Rpc::Service, or separate rpc_name and method_names?
+        service_name, method_name = rpc_name.split('#')
+
+        service_class = service_name.constantize
+        fail 'not a service class' unless service_class < Protobuf::Rpc::Service
+
+        method_struct = service_class.rpcs[method_name.to_sym]
+        fail 'not a valid rpc' unless method_struct.is_a?(Struct::RpcMethod)
+
+        method_structs[rpc_name] = method_struct
+      end
+
+      def method_structs
+        @method_structs ||= {}
+      end
+
+    end
+
+  end
+
+end

data/lib/rough/version.rb

@@ -0,0 +1,3 @@
+module Rough
+  VERSION = '0.2.5'
+end

metadata

@@ -0,0 +1,181 @@
+--- !ruby/object:Gem::Specification
+name: rough
+version: !ruby/object:Gem::Version
+  version: 0.2.5
+platform: ruby
+authors:
+- john crepezzi
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2015-12-08 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rails
+  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: protobuf
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.4'
+- !ruby/object:Gem::Dependency
+  name: actionpack
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '4.1'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: rspec-rails
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3'
+- !ruby/object:Gem::Dependency
+  name: simplecov
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.8'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.28'
+- !ruby/object:Gem::Dependency
+  name: combustion
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.5'
+- !ruby/object:Gem::Dependency
+  name: stickler
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '2.4'
+description: protobuf-driven APIs in Rails
+email:
+- johnc@squareup.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/rough.rb
+- lib/rough/base_controller.rb
+- lib/rough/engine.rb
+- lib/rough/invalid_request_proto.rb
+- lib/rough/invalid_route.rb
+- lib/rough/middleware.rb
+- lib/rough/route.rb
+- lib/rough/route_registry.rb
+- lib/rough/rpc_registry.rb
+- lib/rough/version.rb
+homepage: https://rubygems.org/gems/rough
+licenses:
+- Apache
+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.2.2
+signing_key: 
+specification_version: 4
+summary: protobuf APIs
+test_files: []
+has_rdoc: