rflow-components-http 0.0.2

data/.gitignore

@@ -0,0 +1,6 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+\#*
+.\#*

data/Gemfile

@@ -0,0 +1,3 @@
+source "http://rubygems.org"
+
+gemspec

data/Rakefile

@@ -0,0 +1,15 @@
+require 'bundler'
+require 'rspec/core/rake_task'
+require 'rdoc/task'
+Bundler::GemHelper.install_tasks
+
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.verbose = true
+  t.rspec_opts = '--tty --color'
+end
+
+Rake::RDocTask.new do |rd|
+  rd.main = "README"
+  rd.rdoc_files.include("README", "lib/**/*.rb")
+  rd.rdoc_dir = File.join('doc', 'html')
+end

data/lib/rflow/components/http/extensions.rb

@@ -0,0 +1,68 @@
+class RFlow
+  module Components
+    module HTTP
+
+      # The set of extensions to add capability to HTTP data types
+      module Extensions
+
+        module IPConnectionExtension
+          # Default accessors
+          # TODO: validate the stuffs
+          ['client_ip', 'client_port', 'server_ip', 'server_port'].each do |name|
+            define_method name do |*args|
+              data_object[name]
+            end
+            define_method :"#{name}=" do |*args|
+              data_object[name] = args.first
+            end
+          end
+        end
+        
+        # Need to be careful when extending to not clobber data already in data_object
+        module HTTPRequestExtension
+          def self.extended(base_data)
+            base_data.data_object ||= {'uri' => '/', 'method' => 'GET', 'protocol' => 'HTTP/1.0', 'headers'=>{}, 'content' => ''}
+          end
+
+          # Default accessors
+          ['method', 'uri', 'query_string', 'protocol', 'headers', 'content'].each do |name|
+            define_method name do |*args|
+              data_object[name]
+            end
+            define_method :"#{name}=" do |*args|
+              data_object[name] = args.first
+            end
+          end
+        end
+        
+        # Need to be careful when extending to not clobber data already in data_object
+        module HTTPResponseExtension
+          def self.extended(base_data)
+            base_data.data_object ||= {'protocol' => 'HTTP/1.0', 'status_code' => 200, 'status_reason_phrase' => 'OK', 'headers' => {}, 'content' => ''}
+          end
+
+          # Default accessors
+          ['protocol', 'status_reason_phrase', 'headers', 'content'].each do |name|
+            define_method name do |*args|
+              data_object[name]
+            end
+            define_method :"#{name}=" do |*args|
+              data_object[name] = args.first
+            end
+          end
+
+          ['status_code'].each do |name|
+            define_method name do |*args|
+              data_object[name]
+            end
+            define_method :"#{name}=" do |*args|
+              data_object[name] = args.first.to_i
+            end
+          end
+          
+        end
+
+      end
+    end
+  end
+end

data/lib/rflow/components/http/server.rb

@@ -0,0 +1,123 @@
+require 'eventmachine'
+require 'evma_httpserver'
+
+require 'rflow'
+
+class RFlow
+  module Components
+    module HTTP
+
+      class Server < RFlow::Component
+        input_port :response_port
+        output_port :request_port
+        
+        attr_accessor :port, :listen, :server_signature, :connections
+        
+        def configure!(config)
+          @listen = config['listen'] ? config['listen'] : '127.0.0.1'
+          @port = config['port'] ? config['port'].to_i : 8000
+          @connections = Hash.new
+        end
+
+        def run!
+          @server_signature = EM.start_server(@listen, @port, Connection) do |conn|
+            conn.server = self
+            self.connections[conn.signature.to_s] = conn
+          end
+        end
+
+        # Getting all messages to response_port, which we need to filter for
+        # those that pertain to this component and have active connections.
+        # This is done by inspecting the provenance, specifically the
+        # context attribute that we stored originally
+        def process_message(input_port, input_port_key, connection, message)
+          RFlow.logger.debug "Received a message"
+          return unless message.data_type_name == 'RFlow::Message::Data::HTTP::Response'
+
+          
+          RFlow.logger.debug "Received a HTTP::Response message, determining if its mine"
+          my_events = message.provenance.find_all {|processing_event| processing_event.component_instance_uuid == instance_uuid}
+          RFlow.logger.debug "Found #{my_events.size} processing events from me"
+          # Attempt to send the data to each context match
+          my_events.each do |processing_event|
+            RFlow.logger.debug "Inspecting #{processing_event.context}"
+            connection_signature = processing_event.context
+            if connections[connection_signature]
+              RFlow.logger.debug "Found connection for #{processing_event.context}"
+              connections[connection_signature].send_http_response message
+            end
+          end
+        end
+        
+        class Connection < EventMachine::Connection
+          include EventMachine::HttpServer
+
+          attr_accessor :server
+          attr_reader :client_ip, :client_port, :server_ip, :server_port
+
+          def post_init
+            @client_port, @client_ip = Socket.unpack_sockaddr_in(get_peername) rescue ["?", "?.?.?.?"]
+            @server_port, @server_ip = Socket.unpack_sockaddr_in(get_sockname) rescue ["?", "?.?.?.?"]
+            RFlow.logger.debug "Connection from #{@client_ip}:#{@client_port} to #{@server_ip}:#{@server_port}"
+            super
+            no_environment_strings
+          end
+
+          
+          def receive_data(data)
+            RFlow.logger.debug "Received #{data.bytesize} bytes of data from #{client_ip}:#{client_port} to #{@server_ip}:#{@server_port}"
+            super
+          end
+          
+          
+          def process_http_request
+            RFlow.logger.debug "Received a HTTP request from #{client_ip}:#{client_port} to #{@server_ip}:#{@server_port}"
+            
+            processing_event = RFlow::Message::ProcessingEvent.new(server.instance_uuid, Time.now.utc)
+
+            request_message = RFlow::Message.new('RFlow::Message::Data::HTTP::Request')
+            request_message.data.uri = @http_request_uri
+
+            processing_event.context = signature
+            processing_event.completed_at = Time.now.utc
+            request_message.provenance << processing_event
+
+            server.request_port.send_message request_message
+          end
+
+          
+          def send_http_response(response_message=nil)
+            RFlow.logger.debug "Sending an HTTP response to #{client_ip}:#{client_port}"
+            resp = EventMachine::DelegatedHttpResponse.new(self)
+
+            # Default values
+            resp.status                  = 200
+            resp.content                 = ""
+            resp.headers["Content-Type"] = "text/html"
+            resp.headers["Server"]       = "Apache"
+            
+            if response_message
+              resp.status  = response_message.data.status_code
+              resp.content = response_message.data.content
+              response_message.data.headers.each do |header, value|
+                resp[headers] = value
+              end
+            end
+
+            resp.send_response
+            close_connection_after_writing
+          end
+
+          
+          # Called when a connection is torn down for whatever reason.
+          # Remove this connection from the server's list
+          def unbind(reason=nil)
+            RFlow.logger.debug "Disconnected from HTTP client #{client_ip}:#{client_port} due to '#{reason}'"
+            server.connections.delete(self.signature)
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/rflow/components/http/version.rb

@@ -0,0 +1,7 @@
+class RFlow
+  module Components
+    module HTTP
+      VERSION = "0.0.2"
+    end
+  end
+end

data/lib/rflow/components/http.rb

@@ -0,0 +1,34 @@
+require 'rflow/components/http/extensions'
+require 'rflow/components/http/server'
+
+class RFlow
+  module Components
+    module HTTP
+      # Load the schemas
+      SCHEMA_DIRECTORY = ::File.expand_path(::File.join(::File.dirname(__FILE__), '..', '..', '..', 'schema'))
+      
+      SCHEMA_FILES = {
+        'http_response.avsc' => 'RFlow::Message::Data::HTTP::Response',
+        'http_request.avsc'  => 'RFlow::Message::Data::HTTP::Request',
+      }
+      
+      SCHEMA_FILES.each do |file_name, data_type_name|
+        schema_string = ::File.read(::File.join(SCHEMA_DIRECTORY, file_name))
+        RFlow::Configuration.add_available_data_type data_type_name, 'avro', schema_string
+      end
+
+      # Load the data extensions
+      RFlow::Configuration.add_available_data_extension('RFlow::Message::Data::HTTP::Request',
+                                                        RFlow::Components::HTTP::Extensions::IPConnectionExtension)
+      RFlow::Configuration.add_available_data_extension('RFlow::Message::Data::HTTP::Request',
+                                                        RFlow::Components::HTTP::Extensions::HTTPRequestExtension)
+
+      
+      RFlow::Configuration.add_available_data_extension('RFlow::Message::Data::HTTP::Response',
+                                                        RFlow::Components::HTTP::Extensions::IPConnectionExtension)
+      RFlow::Configuration.add_available_data_extension('RFlow::Message::Data::HTTP::Response',
+                                                        RFlow::Components::HTTP::Extensions::HTTPResponseExtension)
+
+    end
+  end
+end

data/lib/rflow-components-http.rb

@@ -0,0 +1,2 @@
+require 'rflow'
+require 'rflow/components/http'

data/rflow-components-http.gemspec

@@ -0,0 +1,28 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+require "rflow/components/http/version"
+
+Gem::Specification.new do |s|
+  s.name        = "rflow-components-http"
+  s.version     = RFlow::Components::HTTP::VERSION
+  s.platform    = Gem::Platform::RUBY
+  s.required_ruby_version = '~> 1.9'
+  s.authors     = ["Michael L. Artz"]
+  s.email       = ["michael.artz@redjack.com"]
+  s.homepage    = ""
+  s.summary     = %q{HTTP client and server components for the RFlow FBP framework}
+  s.description = %q{HTTP client and server components for the RFlow FBP framework.  Also includes the necessary HTTP::Request and HTTP::Response message types}
+
+  s.rubyforge_project = "rflow-components-http"
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  s.add_dependency 'rflow', '~> 0.0'
+  s.add_dependency 'eventmachine_httpserver', '~> 0.2'
+
+  s.add_development_dependency 'rspec', '~> 2.6'
+  s.add_development_dependency 'rake', '>= 0.8.7'
+end

data/schema/http_request.avsc

@@ -0,0 +1,19 @@
+{
+    "type": "record",
+    "name": "Request",
+    "namespace": "org.rflow.message.data.http",
+    "aliases": [],
+    "fields": [
+        {"name": "client_ip",    "type": ["string", "null"]},
+        {"name": "client_port",  "type": ["int", "null"]},
+        {"name": "server_ip",    "type": ["string", "null"]},
+        {"name": "server_port",  "type": ["int", "null"]},
+
+        {"name": "method",       "type": "string"},
+        {"name": "uri",          "type": "string"},
+        {"name": "query_string", "type": ["string", "null"]},
+        {"name": "protocol",     "type": "string"},
+        {"name": "headers",      "type": {"type": "map", "values": ["string", "null"]}},
+        {"name": "content",      "type": ["bytes", "null"]}
+    ]
+}

data/schema/http_response.avsc

@@ -0,0 +1,18 @@
+{
+    "type": "record",
+    "name": "Response",
+    "namespace": "org.rflow.message.data.http",
+    "aliases": [],
+    "fields": [
+        {"name": "client_ip",    "type": ["string", "null"]},
+        {"name": "client_port",  "type": ["int", "null"]},
+        {"name": "server_ip",    "type": ["string", "null"]},
+        {"name": "server_port",  "type": ["int", "null"]},
+
+        {"name": "protocol",             "type": "string"},
+        {"name": "status_code",          "type": "int"},
+        {"name": "status_reason_phrase", "type": "string"},
+        {"name": "headers",              "type": {"type": "map", "values": "string"}},
+        {"name": "content",              "type": "bytes"}
+    ]
+}

data/spec/extensions_spec.rb

@@ -0,0 +1,43 @@
+require 'spec_helper.rb'
+
+describe RFlow::Components::HTTP::Extensions::HTTPRequestExtension do
+  before(:each) do
+    @schema_string = RFlow::Configuration.available_data_types['RFlow::Message::Data::HTTP::Request']['avro']
+  end
+
+  it "should work" do
+    RFlow::Configuration.available_data_extensions['RFlow::Message::Data::HTTP::Request'].should include(described_class)
+
+    request = RFlow::Message.new('RFlow::Message::Data::HTTP::Request')
+    request.data.uri.should == '/'
+    request.data.method.should == 'GET'
+    request.data.query_string.should == nil
+    request.data.protocol.should == 'HTTP/1.0'
+    request.data.headers.should == {}
+
+    request.data.uri = 'POST'
+    request.data.uri.should == 'POST'
+  end
+  
+end
+
+describe RFlow::Components::HTTP::Extensions::HTTPResponseExtension do
+  before(:each) do
+    @schema_string = RFlow::Configuration.available_data_types['RFlow::Message::Data::HTTP::Response']['avro']
+  end
+
+  it "should work" do
+    RFlow::Configuration.available_data_extensions['RFlow::Message::Data::HTTP::Response'].should include(described_class)
+    
+    response = RFlow::Message.new('RFlow::Message::Data::HTTP::Response')
+    response.data.protocol.should == 'HTTP/1.0'
+    response.data.status_code.should == 200
+    response.data.status_reason_phrase.should == 'OK'
+    response.data.headers.should == {}
+    response.data.content.should == ''
+
+    response.data.status_code = 404
+    response.data.status_code.should == 404
+  end
+  
+end

data/spec/schema_spec.rb

@@ -0,0 +1,67 @@
+require 'spec_helper.rb'
+
+describe 'RFlow::Message::Data::HTTP::Request Avro Schema' do
+  before(:each) do
+    @schema_string = RFlow::Configuration.available_data_types['RFlow::Message::Data::HTTP::Request']['avro']
+  end
+  
+  it "should encode and decode an object" do
+    request = {
+      'method' => 'METHOD',
+      'uri' => 'URI',
+      'query_string' => 'QUERYSTRING',
+      'protocol' => 'PROTOCOL',
+      'headers' => {
+        'header1' => 'HEADER1',
+        'header2' => 'HEADER2',
+      },
+      'content' => '',
+    }
+
+    expect {encode_avro(@schema_string, request)}.to_not raise_error
+    avro_encoded_request = encode_avro(@schema_string, request)
+
+    expect {decode_avro(@schema_string, avro_encoded_request)}.to_not raise_error
+    decoded_request = decode_avro(@schema_string, avro_encoded_request)
+
+    decoded_request['method'].should == request['method']
+    decoded_request['uri'].should == request['uri']
+    decoded_request['query_string'].should == request['query_string']
+    decoded_request['protocol'].should == request['protocol']
+    decoded_request['headers'].should == request['headers']
+    decoded_request['content'].should == request['content']
+  end
+end
+
+
+describe 'RFlow::Message::Data::HTTP::Response Avro Schema' do
+  before(:each) do
+    @schema_string = RFlow::Configuration.available_data_types['RFlow::Message::Data::HTTP::Response']['avro']
+  end
+  
+  it "should encode and decode an object" do
+    response = {
+      'protocol' => 'METHOD',
+      'status_code' => 200,
+      'status_reason_phrase' => 'STATUSREASONPHRASE',
+      'headers' => {
+        'header1' => 'HEADER1',
+        'header2' => 'HEADER2',
+      },
+      'content' => 'CONTENT',
+    }
+
+    expect {encode_avro(@schema_string, response)}.to_not raise_error
+    avro_encoded_response = encode_avro(@schema_string, response)
+
+    expect {decode_avro(@schema_string, avro_encoded_response)}.to_not raise_error
+    decoded_response = decode_avro(@schema_string, avro_encoded_response)
+
+    decoded_response['protocol'].should == response['protocol']
+    decoded_response['status_code'].should == response['status_code']
+    decoded_response['status_reason_phrase'].should == response['status_reason_phrase']
+    decoded_response['headers'].should == response['headers']
+    decoded_response['content'].should == response['content']
+  end
+end
+

data/spec/spec_helper.rb

@@ -0,0 +1,18 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'rflow-components-http'))
+
+require 'logger'
+
+RFlow.logger = Logger.new STDOUT
+  
+def decode_avro(schema_string, serialized_object)
+  schema = Avro::Schema.parse(schema_string)
+  sio = StringIO.new(serialized_object)
+  Avro::IO::DatumReader.new(schema, schema).read Avro::IO::BinaryDecoder.new(sio)
+end
+
+def encode_avro(schema_string, object)
+  schema = Avro::Schema.parse(schema_string)
+  sio = StringIO.new
+  Avro::IO::DatumWriter.new(schema).write object, Avro::IO::BinaryEncoder.new(sio)
+  sio.string
+end

metadata

@@ -0,0 +1,128 @@
+--- !ruby/object:Gem::Specification
+name: rflow-components-http
+version: !ruby/object:Gem::Version
+  version: 0.0.2
+  prerelease: 
+platform: ruby
+authors:
+- Michael L. Artz
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2014-03-17 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rflow
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: eventmachine_httpserver
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '0.2'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ~>
+      - !ruby/object:Gem::Version
+        version: '2.6'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: 0.8.7
+description: HTTP client and server components for the RFlow FBP framework.  Also
+  includes the necessary HTTP::Request and HTTP::Response message types
+email:
+- michael.artz@redjack.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- Rakefile
+- lib/rflow-components-http.rb
+- lib/rflow/components/http.rb
+- lib/rflow/components/http/client.rb
+- lib/rflow/components/http/extensions.rb
+- lib/rflow/components/http/server.rb
+- lib/rflow/components/http/version.rb
+- rflow-components-http.gemspec
+- schema/http_request.avsc
+- schema/http_response.avsc
+- spec/extensions_spec.rb
+- spec/schema_spec.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ~>
+    - !ruby/object:Gem::Version
+      version: '1.9'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: rflow-components-http
+rubygems_version: 1.8.24
+signing_key: 
+specification_version: 3
+summary: HTTP client and server components for the RFlow FBP framework
+test_files:
+- spec/extensions_spec.rb
+- spec/schema_spec.rb
+- spec/spec_helper.rb