bitgirder-platform 0.1.7

data/lib/bitgirder/event/logger.rb

@@ -0,0 +1,137 @@
+require 'bitgirder/core'
+include BitGirder::Core
+
+require 'thread'
+require 'set'
+
+module BitGirder
+module Event
+
+# Base library for BitGirder event logging. Generators of an event will call
+# Engine.log_event, which dispatches the event to a dynamic set of listeners.
+#
+# Typically an application will create a single Engine instance during
+# application startup, register some number of listeners, and then make the
+# engine available to the rest of the application for logging events via
+# Engine#log_event.
+#
+# Listeners registered with an Engine (see Engine#add_listener) should process
+# events immediately and without blocking, since they execute in the call stack
+# of the event producer.  In particular, implementations which serialize events
+# and perform IO (write to disk, send over a network) should be careful not to
+# perform the IO directly upon receiving the event, but should delegate this to
+# some ancillary thread.
+#
+# Events can be any ruby object. It is up to each listener to decide if/how to
+# handle a given event. 
+#
+# Development roadmap for this library:
+#
+# - Add skeletal listener implementations to simplify offloading IO or other
+#   intensive processing to a helper thread, as well as managing queuing
+#   policies and overload behavior (drop new events, drop old events, grow
+#   unbounded, etc).
+#
+module Logger
+
+# An Engine coordinates dispatching of logged events a dynamic set of listeners.
+# All methods are safe to call from concurrent threads.
+class Engine < BitGirderClass
+    
+    bg_attr :error_handler,
+            :required => false,
+            :description => <<-END_DESC
+                If set, this object will be called for various error methods to
+                which it responds.
+            END_DESC
+ 
+    # Creates a new instance with an empty listener set.
+    def impl_initialize # :nodoc:
+        
+        super
+
+        @listeners = Set.new
+        @mut = Mutex.new
+    end
+
+    # In case we later decide to allow @mut to be optional or of varying
+    # implementations (not all apps which log will necessarily be threaded)
+    # we'll only need to modify this block to run code which should be
+    # threadsafe
+    private
+    def guarded( &blk )
+        @mut.synchronize( &blk )
+    end
+
+    # Gets the number of listeners managed by this engine
+    public
+    def listener_count
+        guarded { @listeners.size }
+    end
+
+    private
+    def listener_failed( l, ev, ex )
+        
+        if @error_handler.respond_to?( :listener_failed )
+            @error_handler.listener_failed( l, ev, ex )
+        else
+            warn( ex, "Listener #{l} failed for event #{ev}" )
+        end
+    end
+
+    # Logs an event. After this method returns all listeners will have received
+    # the event.
+    public
+    def log_event( ev )
+
+        # Accumulate failures here so we can process them after releasing the
+        # lock
+        failures = []
+
+        guarded do 
+            @listeners.each do |l| 
+                begin 
+                    l.event_logged( ev )
+                rescue Exception => ex
+                    failures << [ l, ev, ex ]
+                end
+            end
+        end
+
+        failures.each { |arr| listener_failed( *arr ) }
+    end
+
+    # Adds the given listener to this engine if it is not already present. All
+    # subsequent calls to log_event will dispatch to +l+ until a call is made to
+    # remove_listener
+    #
+    # This method returns +l+ to allow callers to chain listener
+    # creation/addition:
+    #
+    #   list = eng.add_listener( SomeListener.new( ... ) )
+    #
+    public
+    def add_listener( l )
+
+        guarded do
+            if l.respond_to?( :event_logged ) 
+                @listeners << l unless @listeners.include?( l )
+            else
+                raise "Not an event listener: #{l} (#{l.class})" 
+            end
+        end
+
+        l
+    end
+
+    # Removes +l+ from the dispatch set. It is not an error to call this
+    # method for an unregistered listener.
+    public
+    def remove_listener( l )
+        guarded { @listeners.delete( l ) }
+    end
+end
+
+end
+end
+end

data/lib/bitgirder/event/testing.rb

@@ -0,0 +1,88 @@
+require 'bitgirder/core'
+include BitGirder::Core
+
+require 'bitgirder/io'
+require 'bitgirder/io/testing'
+include BitGirder::Io
+
+module BitGirder
+module Event
+module Testing
+
+class Int32Event < BitGirderClass
+
+    TYPE_CODE = 0x0001
+
+    bg_attr :i
+
+    def self.from_i( i ); self.new( :i => i ); end
+end
+
+class BufferEvent < BitGirderClass
+    
+    TYPE_CODE = 0x0002
+
+    bg_attr :buf
+end
+
+class DelayEvent < BitGirderClass
+    
+    bg_attr :delay # will be arg to sleep()
+    bg_attr :event
+end
+
+class TestCodec < BitGirderClass
+
+    include BitGirder::Io
+
+    private
+    def impl_initialize
+        @conv = BinaryConverter.new( :order => Io::ORDER_LITTLE_ENDIAN )
+    end
+
+    public
+    def encode_event( ev, io )
+
+        if ev.is_a?( DelayEvent )
+            sleep( ev.delay )
+            ev = ev.event
+        end
+
+        io.write( @conv.write_int32( ev.class::TYPE_CODE ) )
+
+        case ev
+        when Int32Event then io.write( @conv.write_int32( ev.i ) )
+        when BufferEvent then io.write( ev.buf )
+        else raise TypeError.new( "Unrecognized event: #{ev.class}" )
+        end
+    end
+
+    public
+    def decode_event( io, len )
+ 
+        ev_buf_len = len - 4
+
+        case cd = @conv.read_int32( io.read( 4 ) )
+        when Int32Event::TYPE_CODE
+            Int32Event.from_i( @conv.read_int32( io.read( 4 ) ) )
+        when BufferEvent::TYPE_CODE
+            BufferEvent.new( Io.read_full( io, ev_buf_len ) )
+        else raise sprintf( "Unexpected type code: %04x", cd )
+        end
+    end
+end
+
+def self.roundtrip( ev, codec )
+    
+    io = Io::Testing.new_string_io
+    codec.encode_event( ev, io )
+    
+    len = io.pos
+    io.seek( 0, IO::SEEK_SET )
+    
+    codec.decode_event( io, len )
+end
+
+end
+end
+end

data/lib/bitgirder/http.rb

@@ -0,0 +1,255 @@
+require 'bitgirder/core'
+include BitGirder::Core
+
+require 'mingle'
+include Mingle
+
+require 'net/http'
+
+module BitGirder
+module Http
+
+class HttpHeaders < BitGirderClass
+    
+    private_class_method :new
+
+    bg_attr :pairs, 
+            :default => [],
+            :processor => lambda { |pairs| pairs.sort!.freeze }
+
+    def self.as_header_name( nm )
+        nm.to_s.downcase
+    end
+
+    def self.as_header_val( val )
+        val.to_s.strip
+    end
+
+    def self.as_header_val_list( val )
+        
+        case val
+
+            when Array, MingleList 
+                val.empty? ? [ "" ] : val.map { |v| self.as_header_val( v ) }
+
+            else [ self.as_header_val( val ) ]
+        end
+    end
+
+    map_instance_of( Hash ) do |h|
+        
+        pairs = {}
+
+        h.each_pair do |k, v|
+            arr = ( pairs[ self.as_header_name( k ) ] ||= [] )
+            arr.push( *( self.as_header_val_list( v ) ) )
+        end
+
+        self.send( :new, :pairs => pairs.to_a )
+    end
+
+    map_instance_of( Array ) do |arr|
+        
+        pairs = arr.map do |pair|
+ 
+            if pair.size == 2
+                [ self.as_header_name( pair[ 0 ] ), 
+                  self.as_header_val_list( pair[ 1 ] ) ]
+            else
+                raise "Not a http header pair: #{pair.inspect}"
+            end
+        end
+
+        self.send( :new, :pairs => pairs )
+    end
+
+    map_instance_of( Net::HTTPHeader ) do |hdrs|
+
+        pairs = []
+        hdrs.each_name { |nm| pairs << [ nm.downcase, hdrs.get_fields( nm ) ] }
+
+        self.send( :new, :pairs => pairs )
+    end
+
+    public
+    def to_mingle_struct
+
+        MingleStruct.new(
+            :type => :"bitgirder:http@v1/HttpHeaders",
+            :fields => { :pairs => @pairs.map { |p| MingleList.new( p ) } }
+        )
+    end
+
+    def self.from_mingle_struct( ms )
+        self.as_instance( ( ms[ :pairs ] || [] ).to_a )
+    end
+end
+
+class HttpEndpoint < BitGirderClass
+    
+    bg_attr :host, :required => false
+    bg_attr :port, :required => false
+    bg_attr :is_ssl, :required => false
+
+    map_instance_of( Net::HTTP ) do |http|
+
+        new( 
+            :host => http.address, 
+            :port => http.port, 
+            :is_ssl => http.use_ssl?
+        )
+    end
+
+    def to_mingle_struct
+
+        MingleStruct.new(
+            :type => :"bitgirder:http@v1/HttpEndpoint",
+            :fields => {
+                :host => @host,
+                :port => @port,
+                :is_ssl => @is_ssl
+            }
+        )
+    end
+
+    def self.from_mingle_struct( ms )
+        
+        self.new(
+            :host => ms.fields.get_string( :host ),
+            :port => ms.fields.get_int( :port ),
+            :is_ssl => ms.fields.get_boolean( :is_ssl )
+        )
+    end
+end
+
+PROC_TO_BIN = lambda { |b|
+    RubyVersions.when_19x( b ) { b.encode( Encoding::BINARY ) }
+}
+
+class HttpRequest < BitGirderClass
+ 
+    bg_attr :headers, :processor => HttpHeaders, :required => false
+    bg_attr :path, :required => false
+    bg_attr :body, :processor => PROC_TO_BIN, :required => false
+
+    def to_mingle_struct
+        
+        MingleStruct.new(
+            :type => :"bitgirder:http@v1/HttpRequest",
+            :fields => {
+                :headers => @headers ? @headers.to_mingle_struct : nil,
+                :path => @path,
+                :body => @body ? MingleBuffer.new( @body ) : nil
+            }
+        )
+    end
+
+    def self.from_mingle_struct( ms )
+        
+        mg_hdrs, mg_body = ms[ :headers ], ms[ :body ]
+
+        self.new(
+            :headers => 
+                mg_hdrs ? HttpHeaders.from_mingle_struct( mg_hdrs ) : nil,
+            :path => ms.fields.get_string( :path ),
+            :body => mg_body ? mg_body.buf : nil
+        )
+    end
+end
+
+class HttpStatus < BitGirderClass
+    
+    bg_attr :code
+    bg_attr :message
+    bg_attr :version
+
+    map_instance_of( Net::HTTPResponse ) do |resp|
+        
+        ver =
+            if ( ver_base = resp.http_version ).start_with?( "HTTP/" )
+                ver_base
+            else
+                "HTTP/#{ver_base}"
+            end
+
+        self.new( 
+            :message => resp.message, :code => resp.code, :version => ver )
+    end
+
+    public
+    def to_mingle_struct
+        MingleStruct.new(
+            :type => :"bitgirder:http@v1/HttpStatus",
+            :fields => {
+                :code => @code,
+                :message => @message,
+                :version => @version
+            }
+        )
+    end
+
+    def self.from_mingle_struct( ms )
+
+        self.new(
+            :code => ms[ :code ].to_i,
+            :message => ms[ :message ].to_s,
+            :version => ms[ :version ].to_s
+        )
+    end
+end
+
+class HttpResponse < BitGirderClass
+ 
+    bg_attr :status, :processor => HttpStatus, :required => false
+    bg_attr :headers, :processor => HttpHeaders, :required => false
+    bg_attr :body, :processor => PROC_TO_BIN, :required => false
+
+    def self.from_net_http_response( resp, opts = {} )
+ 
+        not_nil( resp, :resp )
+        not_nil( opts, :opts )
+
+        log_body = opts[ :log_body ]
+
+        attrs = {
+            :status => HttpStatus.as_instance( resp ),
+            :headers => HttpHeaders.as_instance( resp )
+        }
+
+        if opts[ :log_body ] && resp.class.body_permitted?
+            attrs[ :body ] = resp.body
+        end
+
+        new( attrs )
+    end
+
+    map_instance_of( Net::HTTPResponse ) do |resp|
+        self.from_net_http_response( resp, :log_body => false )
+    end
+
+    def to_mingle_struct
+
+        MingleStruct.new(
+            :type => :"bitgirder:http@v1/HttpResponse",
+            :fields => {
+                :status => @status ? @status.to_mingle_struct : nil,
+                :headers => @headers ? @headers.to_mingle_struct : nil,
+                :body => @body ? MingleBuffer.new( body ) : nil
+            }
+        )
+    end
+
+    def self.from_mingle_struct( ms )
+ 
+        stat, hdrs, body = ms[ :status ], ms[ :headers ], ms[ :body ]
+
+        self.new(
+            :status => stat ? HttpStatus.from_mingle_struct( stat ) : nil,
+            :headers => hdrs ? HttpHeaders.from_mingle_struct( hdrs ) : nil,
+            :body => body ? body.buf : nil
+        )
+    end
+end
+
+end
+end

data/lib/bitgirder/io/testing.rb

@@ -0,0 +1,33 @@
+require 'bitgirder/core'
+require 'stringio'
+
+module BitGirder
+module Io
+
+module Testing
+    
+    [ :force_encoding, :encode, :encode! ].each do |meth|
+        define_method( :"opt_#{meth}" ) do |s, *argv|
+            RubyVersions.when_19x( s ) { |s| s.send( meth, *argv ) }
+        end
+    end
+
+    def new_string_io( str = "" )
+        RubyVersions.when_19x( StringIO.new( str ) ) do |io|
+            io.set_encoding( "binary" )
+        end
+    end
+    
+    module_function :new_string_io
+
+    def rand_buf( len )
+
+        len = len.bytes if len.is_a?( DataSize )
+        File.open( "/dev/random", "rb" ) { |io| Io.read_full( io, len ) }
+    end
+
+    module_function :rand_buf
+end
+
+end
+end