carnivore-http 0.1.0

data/CHANGELOG.md

@@ -0,0 +1,2 @@
+# v0.1.0
+* Initial release

data/README.md

@@ -0,0 +1,36 @@
+# Carnivore HTTP
+
+Provides HTTP `Carnivore::Source`
+
+# Usage
+
+## HTTP
+
+```ruby
+require 'carnivore'
+require 'carnivore-http'
+
+Carnivore.configure do
+  source = Carnivore::Source.build(
+    :type => :http, :args => {:port => 8080}
+  )
+end
+```
+
+## HTTP with configured end points
+
+```ruby
+require 'carnivore'
+require 'carnivore-http'
+
+Carnivore.configure do
+  source = Carnivore::Source.build(
+    :type => :http_endpoints, :args => {:auto_respond => false}
+  )
+end.start!
+```
+
+# Info
+* Carnivore: https://github.com/heavywater/carnivore
+* Repository: https://github.com/heavywater/carnivore-http
+* IRC: Freenode @ #heavywater

data/carnivore-http.gemspec

@@ -0,0 +1,16 @@
+$LOAD_PATH.unshift File.expand_path(File.dirname(__FILE__)) + '/lib/'
+require 'carnivore-http/version'
+Gem::Specification.new do |s|
+  s.name = 'carnivore-http'
+  s.version = Carnivore::Http::VERSION.version
+  s.summary = 'Message processing helper'
+  s.author = 'Chris Roberts'
+  s.email = 'chrisroberts.code@gmail.com'
+  s.homepage = 'https://github.com/heavywater/carnivore-http'
+  s.description = 'Carnivore HTTP source'
+  s.require_path = 'lib'
+  s.add_dependency 'carnivore', '>= 0.1.8'
+  s.add_dependency 'reel'
+  s.add_dependency 'blockenspiel'
+  s.files = Dir['**/*']
+end

data/lib/carnivore-http.rb

@@ -0,0 +1,5 @@
+require 'carnivore-http/version'
+require 'carnivore'
+
+Carnivore::Source.provide(:http, 'carnivore-http/http')
+Carnivore::Source.provide(:http_endpoints, 'carnivore-http/http_endpoints')

data/lib/carnivore-http/http.rb

@@ -0,0 +1,54 @@
+require 'reel'
+require 'carnivore/source'
+
+module Carnivore
+  class Source
+
+    class Http < Source
+
+      attr_reader :args
+
+      def setup(args={})
+        @args = default_args(args)
+      end
+
+      def default_args(args)
+        {
+          :bind => '0.0.0.0',
+          :port => '3000',
+          :auto_respond => true
+        }.merge(args)
+      end
+
+      def transmit(message, orignal_message_or_connection, args={})
+        if(original_message_or_connection.is_a?(Message))
+          con = original_message_or_connection[:connection]
+        else
+          con = original_message_or_connection[:connection]
+        end
+        # TODO: add `args` options for marshaling: json/xml/etc
+        con.respond(args[:code] || :ok, message)
+      end
+
+      def process(*process_args)
+        srv = Reel::Server.supervise(args[:bind], args[:port]) do |con|
+          while(req = con.request)
+            begin
+              msg = format(:request => req, :body => req.body, :connection => con)
+              callbacks.each do |name|
+                c_name = callback_name(name)
+                debug "Dispatching message<#{msg[:message].object_id}> to callback<#{name} (#{c_name})>"
+                Celluloid::Actor[c_name].async.call(msg)
+              end
+              con.respond(:ok, 'So long, and thanks for all the fish!') if args[:auto_respond]
+            rescue => e
+              con.respond(:bad_request, 'Failed to process request')
+            end
+          end
+        end
+      end
+
+    end
+
+  end
+end

data/lib/carnivore-http/http_endpoints.rb

@@ -0,0 +1,85 @@
+require 'carnivore-http/http'
+require 'carnivore-http/point_builder'
+
+module Carnivore
+  class Source
+    class HttpEndpoints < Http
+
+      class << self
+
+        def register(args={})
+          args = Hash[*(
+              args.map do |k,v|
+                [k.to_sym, v]
+              end.flatten
+          )]
+          builder = {:name => args[:name], :base_path => args[:base_path]}
+          if(res = builder.find_all{|x,y| y.nil})
+            raise ArgumentError.new("Missing required argument! (#{res.map(&:first).join(',')})")
+          end
+          builders[builder[:name].to_sym] = builder[:base_path]
+          self
+        end
+
+        def builders
+          @point_builders ||= {}
+        end
+
+        def load_builder(name)
+          if(builders[name.to_sym])
+            require File.join(builders[name.to_sym], name)
+          else
+            raise NameError.new("Requested end point builder not found (#{name})")
+          end
+          self
+        end
+
+        def setup!
+          only = Carnivore::Config.get(:http_endpoints, :only)
+          except = Carnivore::Config.get(:http_endpoints, :except)
+          # NOTE: Except has higher precedence than only
+          builders.keys.each do |name|
+            next if only && !only.include?(name.to_s)
+            next if except && except.include?(name.to_s)
+            load_builder(name)
+          end
+          true
+        end
+
+      end
+
+      attr_reader :points
+
+      def setup(args={})
+        super
+        @conf_key = (args[:config_key] || :http_endpoints).to_sym
+        set_points
+      end
+
+      def process(*process_args)
+        srv = Reel::Server.supervise(args[:bind], args[:port]) do |con|
+          con.each_request do |req|
+            begin
+              msg = format(:request => req, :body => req.body, :connection => con)
+              unless(@points.deliver(msg))
+                con.respond(:ok, 'So long, and thanks for all the fish!')
+              end
+            rescue => e
+              error "Failed to process message: #{e.class} - #{e}"
+              debug "#{e.class}: #{e}\n#{e.backtrace.join("\n")}"
+              con.respond(:bad_request, 'Failed to process request')
+            end
+          end
+        end
+      end
+
+      def set_points
+        @points = PointBuilder.new(
+          :only => Carnivore::Config.get(@conf_key, :only),
+          :except => Carnivore::Config.get(@conf_key, :except)
+        )
+        self
+      end
+    end
+  end
+end

data/lib/carnivore-http/point_builder.rb

@@ -0,0 +1,161 @@
+require 'blockenspiel'
+require 'singleton'
+require 'carnivore/utils'
+require 'celluloid'
+
+module Carnivore
+  class PointBuilder
+
+    class Endpoint
+
+      include Celluloid
+      include Carnivore::Utils::Logging
+
+      attr_reader :endpoint, :type
+
+      def initialize(type, endpoint, block)
+        @endpoint = endpoint
+        @type = type
+        define_singleton_method(:run, &block)
+      end
+
+      def to_s
+        "<Endpoint[#{endpoint}]>"
+      end
+
+      def inspect
+        "<Endpoint[#{endpoint}] type=#{type} objectid=#{self.object_id}>"
+      end
+
+    end
+
+    include Carnivore::Utils::Params
+    include Celluloid::Logger
+    include Blockenspiel::DSL
+
+    attr_reader :static, :regex, :only, :except
+
+    def initialize(args)
+      @only = args[:only]
+      @except = args[:except]
+      @static = {}
+      @regex = {}
+      @callback_names = {}
+      @endpoint_supervisor = Celluloid::SupervisionGroup.run!
+      load_endpoints!
+    end
+
+    [:get, :put, :post, :delete, :head, :options, :trace].each do |name|
+      define_method(name) do |regexp_or_string, args={}, &block|
+        endpoint(name, regexp_or_string, args, &block)
+      end
+    end
+
+    dsl_methods false
+
+    def deliver(msg)
+      type = msg[:message][:request].method.to_s.downcase.to_sym
+      path = msg[:message][:request].url
+      static_points(msg, type, path) || regex_points(msg, type, path)
+    end
+
+    def static_points(msg, type, path)
+      if(static[type])
+        match = static[type].keys.detect do |point|
+          path.sub(%r{/$}, '') == point
+        end
+        if(match)
+          if(static[type][match][:async])
+            Celluloid::Actor[callback_name(match, type)].async.run(msg)
+            false
+          else
+            Celluloid::Actor[callback_name(match, type)].run(msg)
+            true
+          end
+        end
+      end
+    end
+
+    def regex_points(msg, type, path)
+      if(regex[type])
+        match = regex[type].keys.map do |point|
+          unless((res = path.scan(/^#{point}$/)).empty?)
+            [point, res.first.is_a?(Array) ? res.first : []]
+          end
+        end.compact.first
+        unless(match.empty?)
+          if(regex[type][match.first][:async])
+            Celluloid::Actor[callback_name(match.first, type)].async.run([msg] + match.last)
+            false
+          else
+            Celluloid::Actor[callback_name(match.first, type)].run([msg] + match.last)
+            true
+          end
+        end
+      end
+    end
+
+    def callback_name(point, type)
+      key = "#{point}_#{type}"
+      unless(@callback_names[key])
+        @callback_names[key] = Digest::SHA256.hexdigest(key)
+      end
+      @callback_names[key]
+    end
+
+    def endpoint(request_type, regexp_or_string, args, &block)
+      request_type = request_type.to_sym
+      if(regexp_or_string.is_a?(Regexp))
+        regex[request_type] ||= {}
+        regex[request_type][regexp_or_string] = args
+      else
+        static[request_type] ||= {}
+        static[request_type][regexp_or_string.sub(%r{/$}, '')] = args
+      end
+      if(args[:workers] && args[:workers].to_i > 1)
+        @endpoint_supervisor.pool(Endpoint,
+          as: callback_name(regexp_or_string, request_type), size: args[:workers.to_i],
+          args: [request_type, regexp_or_string, block]
+        )
+      else
+        @endpoint_supervisor.supervise_as(
+          callback_name(regexp_or_string, request_type), Endpoint, request_type, regexp_or_string, block
+        )
+      end
+      true
+    end
+
+    def endpoints
+      [static, regex]
+    end
+
+    private
+
+    def load_endpoints!
+      self.class.storage.each do |name, block|
+        next if only && !only.include?(name.to_s)
+        next if except && except.include?(name.to_s)
+        Blockenspiel.invoke(block, self)
+      end
+      true
+    end
+
+    class << self
+      def define(&block)
+        name = File.basename(
+          caller.first.match(%r{.*?:}).to_s.sub(':', '')
+        ).sub('.rb', '')
+        store(name, block)
+      end
+
+      def store(name, block)
+        storage[name.to_sym] = block
+        self
+      end
+
+      def storage
+        @storage ||= {}
+      end
+    end
+  end
+end

data/lib/carnivore-http/version.rb

@@ -0,0 +1,7 @@
+module Carnivore
+  module Http
+    class Version < Gem::Version
+    end
+    VERSION = Version.new('0.1.0')
+  end
+end

metadata

@@ -0,0 +1,101 @@
+--- !ruby/object:Gem::Specification
+name: carnivore-http
+version: !ruby/object:Gem::Version
+  version: 0.1.0
+  prerelease: 
+platform: ruby
+authors:
+- Chris Roberts
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-10-15 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: carnivore
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.1.8
+- !ruby/object:Gem::Dependency
+  name: reel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: blockenspiel
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Carnivore HTTP source
+email: chrisroberts.code@gmail.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/carnivore-http/point_builder.rb
+- lib/carnivore-http/version.rb
+- lib/carnivore-http/http.rb
+- lib/carnivore-http/http_endpoints.rb
+- lib/carnivore-http.rb
+- README.md
+- carnivore-http.gemspec
+- CHANGELOG.md
+homepage: https://github.com/heavywater/carnivore-http
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: Message processing helper
+test_files: []
+has_rdoc: