bitgirder-platform 0.1.7

data/lib/mingle/codec.rb

@@ -0,0 +1,54 @@
+require 'bitgirder/io'
+
+module Mingle
+module Codec
+
+require 'tempfile'
+
+class MingleCodecError < StandardError; end
+
+module MingleCodecImpl
+
+    private
+    def codec_raise( *argv )
+        raise Mingle::Codec::MingleCodecError, *argv
+    end
+end
+
+module MingleCodecs
+
+    @@bgm = BitGirder::Core::BitGirderMethods
+
+    def decode( codec, obj )
+
+        @@bgm.not_nil( codec, :codec )
+        @@bgm.not_nil( obj, :obj )
+
+        case obj
+
+            when String then codec.from_buffer( obj )
+
+            when IO, Tempfile
+                data = BitGirder::Io.slurp_io( obj ) || ""
+                decode( codec, data ) # recurse
+
+            else 
+                raise "Don't know how to decode obj #{obj} of type #{obj.class}"
+        end
+    end
+
+    module_function :decode
+
+    def encode( codec, mv )
+ 
+        @@bgm.not_nil( codec, :codec )
+        @@bgm.not_nil( mv, :mv )
+
+        codec.as_buffer( mv )
+    end
+
+    module_function :encode
+end
+
+end
+end

data/lib/mingle/http.rb

@@ -0,0 +1,156 @@
+require 'bitgirder/core'
+require 'mingle'
+require 'mingle/service'
+require 'mingle/codec'
+
+require 'uri'
+
+module Mingle
+module Http
+
+class ServerLocation < BitGirder::Core::BitGirderClass
+
+    bg_attr :host
+    bg_attr :port
+
+    bg_attr :uri,
+            :processor => lambda { |s| s.start_with?( "/" ) ? s : "/#{s}" }
+    
+    public
+    def to_url
+        "http://#{host}:#{port}#{uri}"
+    end
+end
+
+class HttpCodecContext < BitGirder::Core::BitGirderClass
+    
+    bg_attr :codec
+    bg_attr :content_type
+end
+
+# Simple blocking client using ruby builtin http lib
+class NetHttpMingleRpcClient < BitGirder::Core::BitGirderClass
+    
+    require 'net/http'
+
+    include Mingle::Codec
+    include Mingle::Service
+
+    bg_attr :location
+    bg_attr :codec_ctx
+    bg_attr :reactor, :required => false
+
+    private
+    def react( meth, *argv )
+ 
+        case @reactor
+
+            when Hash
+                if func = @reactor[ meth ] then func.call( *argv ) end
+
+            else
+                if @reactor.respond_to?( meth )
+                    @reactor.send( meth, *argv )
+                end
+        end
+    end
+
+    # Input checker/converter for call()
+    private
+    def get_mg_req( argv )
+        
+        # Fail if nothing at all was given
+        not_nil( argv[ 0 ], :mg_req )
+
+        case argv.size
+            when 1 
+                case obj = argv[ 0 ]
+                    when MingleServiceRequest then obj
+                    when Hash then MingleServiceRequest.new( obj )
+                    else raise "Invalid or incomplete call param: #{obj}"
+                end
+            else
+                MingleServiceRequest.new(
+                    :namespace => argv[ 0 ],
+                    :service => argv[ 1 ],
+                    :operation => argv[ 2 ],
+                    :parameters => argv[ 3 ],
+                    :authentication => argv[ 4 ] )
+        end
+    end
+
+    private
+    def create_request( mv )
+         
+        req = Net::HTTP::Post.new( @location.uri )
+
+        req.body = MingleCodecs.encode( @codec_ctx.codec, mv )
+        req.content_type = @codec_ctx.content_type
+        req[ "connection" ] = "close"
+
+        react( :complete_request, req )
+
+        req
+    end
+
+    private
+    def as_service_response( body )
+        
+        ms = MingleCodecs.decode( @codec_ctx.codec, body )
+        MingleServices.as_service_response( ms )
+    end
+
+    public
+    def call( *argv )
+        
+        mv = MingleServices.as_mingle_struct( get_mg_req( argv ) )
+        req = create_request( mv )
+
+        resp = 
+            Net::HTTP.new( @location.host, @location.port ).start do |http|
+                http.request( req )
+            end
+ 
+        react( :response_received, resp )
+
+        case resp
+            when Net::HTTPOK then as_service_response( resp.body )
+            else raise "Got non-OK response: #{resp} (#{resp.body})"
+        end
+    end
+
+#    class ServiceClient < BitGirder::Core::BitGirderClass
+#        
+#        bg_attr :cli
+#        bg_attr :namespace
+#        bg_attr :service
+#        bg_attr( :identifier => :authentication )
+#
+#        def initialize( opts )
+#            super
+#        end
+#
+#        public
+#        def call( op, args = {}, auth = nil )
+#
+#            @cli.call(
+#                @namespace,
+#                @service,
+#                not_nil( op, :op ),
+#                not_nil( args, :args ),
+#                auth || @authentication
+#            )
+#        end
+#    end
+#
+#    # returns a ServiceClient object bound with the given preset context. opts
+#    # must contain the keys :namespace ans :service and may optionally contain
+#    # an auth object :authentication
+#    public
+#    def create_service_client( opts )
+#        ServiceClient.new( opts.merge( :cli => self ) )
+#    end
+end
+
+end
+end

data/lib/mingle/io/stream.rb

@@ -0,0 +1,142 @@
+require 'bitgirder/core'
+require 'bitgirder/io'
+require 'mingle/io'
+
+module Mingle
+module Io
+module Stream
+
+MESSAGE_VERSION1 = 1
+
+TYPE_CODE_HEADERS = 1
+TYPE_CODE_MESSAGE_BODY = 2
+
+class Message < BitGirder::Core::BitGirderClass
+
+    bg_attr :headers, 
+            :processor => lambda { |val|
+                Mingle::Io::Headers.as_headers( val )
+            },
+            :default => lambda { Mingle::Io::Headers.as_headers( {} ) }
+
+    bg_attr :body, :default => "".freeze
+end
+
+class Connection < BitGirder::Core::BitGirderClass
+
+    include Mingle
+
+    bg_attr :reader
+    bg_attr :writer
+
+    private
+    def impl_initialize
+
+        @enc = Io::Encoder.new( @writer )
+        @dec = Io::Decoder.new( @reader )
+    end
+
+    private
+    def write_headers( hdrs )
+
+        @enc.write_int32( TYPE_CODE_HEADERS )
+        @enc.write_headers( hdrs )
+    end
+
+    private
+    def write_body( body )
+        
+        @enc.write_int32( TYPE_CODE_MESSAGE_BODY )
+        @enc.write_int64( sz = body.bytesize )
+        @writer.write( body ) unless sz == 0
+    end
+
+    public
+    def write_message( msg )
+
+        msg = Message.as_instance( msg )
+
+        @enc.write_int32( MESSAGE_VERSION1 )
+        write_headers( msg.headers )
+        write_body( msg.body )
+        @writer.flush
+    end
+
+    private
+    def read_body
+        sz = @dec.read_int64
+        @dec.read_full( sz )
+    end
+
+    public
+    def read_message
+        
+        @dec.expect_version( MESSAGE_VERSION1, "message" )
+
+        @dec.expect_type_code( TYPE_CODE_HEADERS )
+        hdrs = @dec.read_headers
+
+        @dec.expect_type_code( TYPE_CODE_MESSAGE_BODY )
+        body = read_body
+        
+        Message.new( :headers => hdrs, :body => body )
+    end
+
+end
+
+class MinglePeer < BitGirder::Core::BitGirderClass
+
+    include Mingle
+    
+    private_class_method :new
+
+    bg_attr :proc_builder
+
+    private
+    def start
+        @peer = @proc_builder.popen( "r+" )
+        @conn = Connection.new( :reader => @peer, :writer => @peer )
+    end
+
+    public
+    def exchange_message( msg )
+        
+        @conn.write_message( msg )
+        @conn.read_message
+    end
+
+    public
+    def await_exit( opts = { :expect_success => true } )
+
+        not_nil( opts, :opts )
+
+        msg = nil
+
+        begin
+            pid, stat = 
+                BitGirder::Io.debug_wait2( :pid => @peer.pid, :name => :peer )
+    
+            unless stat.success?
+                msg = "Peer #{pid} exited with non-success #{stat.exitstatus}"
+            end
+        rescue Errno::ECHILD
+            msg = "Peer #{pid} appears to have exited already"
+        end
+        
+        if msg
+            if opts[ :expect_success ] then raise msg else warn msg end
+        end
+    end
+
+    def self.open( *argv )
+        
+        res = self.send( :new, *argv )
+        res.send( :start )
+
+        res
+    end
+end
+
+end
+end
+end

data/lib/mingle/io.rb

@@ -0,0 +1,160 @@
+require 'mingle'
+require 'bitgirder/core'
+require 'bitgirder/io'
+
+module Mingle
+module Io
+
+require 'forwardable'
+
+class Headers < BitGirder::Core::BitGirderClass
+    
+    def self.make_fields( flds )
+        
+        pairs = flds.inject( {} ) do |h, pair|
+            val = pair[ 1 ]
+            val = val.external_form if val.is_a?( MingleIdentifier )
+            val = MingleModels.as_mingle_value( val )
+            val = MingleModels.as_mingle_string( val )
+            h[ pair[ 0 ] ] = val
+            h
+        end
+
+        MingleSymbolMap.create( pairs )
+    end
+
+    def self.as_headers( val )
+        case val
+            when Headers then val
+            when Hash, MingleSymbolMap then Headers.new( :fields => val )
+            else raise TypeError, "Invalid headers value: #{val.class}"
+        end
+    end
+
+    bg_attr :fields,
+            :processor => lambda { |val| self.make_fields( val ) },
+            :default => lambda { {} }
+end
+
+HEADERS_VERSION1 = 0x01
+
+TYPE_CODE_HEADERS_FIELD = 0x01
+TYPE_CODE_HEADERS_END = 0x02
+
+BYTE_ORDER = BitGirder::Io::ORDER_LITTLE_ENDIAN
+
+class Encoder < BitGirder::Core::BitGirderClass
+ 
+    bg_attr :writer
+
+    private
+    def impl_initialize
+        @bin = BitGirder::Io::BinaryWriter.new( :order => BYTE_ORDER, :io => @writer )
+    end
+
+    public
+    def write_int32( i )
+        @bin.write_int32( i )
+    end
+
+    public 
+    def write_int64( i )
+        @bin.write_int64( i )
+    end
+
+    public
+    def write_utf8( s )
+        @bin.write_utf8( s )
+    end
+
+    public
+    def write_headers( hdrs )
+
+        write_int32( HEADERS_VERSION1 )
+        hdrs.fields.each_pair do |k, v|
+            write_int32( TYPE_CODE_HEADERS_FIELD )
+            write_utf8( k.external_form )
+            write_utf8( v.to_s )
+        end
+        write_int32( TYPE_CODE_HEADERS_END )
+    end
+end
+
+class InvalidVersionError < StandardError; end
+class InvalidTypeCodeError < StandardError; end
+
+class Decoder < BitGirder::Core::BitGirderClass
+    
+    bg_attr :reader
+
+    extend Forwardable
+    def_delegators :@bin, 
+        :read_full, :read_int32, :read_int64, :read_buffer32, :read_utf8
+
+    private
+    def impl_initialize
+        @bin = BitGirder::Io::BinaryReader.new( :order => BYTE_ORDER, :io => @reader )
+    end
+
+    public
+    def read_version
+        read_int32
+    end
+
+    public
+    def expect_version( expct, ver_typ )
+        
+        unless ( ver = read_version ) == expct
+
+            tmpl = "Invalid %s :version => 0x%08x (expected 0x%08x)"
+            msg = sprintf( tmpl, ver_typ, ver, expct )
+            raise InvalidVersionError.new( msg )
+        end
+    end
+
+    public
+    def read_type_code
+        read_int32
+    end
+
+    public
+    def expect_type_code( expct )
+        
+        unless ( act = read_type_code ) == expct
+            
+            tmpl = "Invalid type :code => 0x%08x (expected 0x%08x)"
+            msg = sprintf( tmpl, act, expct )
+            raise InvalidTypeCodeError.new( msg )
+        end
+    end
+ 
+    private
+    def read_header_field( flds )
+        flds[ read_utf8 ] = read_utf8
+    end
+
+    public
+    def read_headers
+        
+        expect_version( HEADERS_VERSION1, "headers" )
+
+        flds = {}
+        while true do
+
+            case tc = read_type_code
+
+                when TYPE_CODE_HEADERS_FIELD then read_header_field( flds )
+
+                when TYPE_CODE_HEADERS_END 
+                    return Headers.new( :fields => flds )
+                
+                else 
+                    msg = sprintf( "Unknown type :code => 0x%08x", tc )
+                    raise InvalidTypeCodeError.new( msg )
+            end
+        end
+    end
+end
+
+end
+end