bitgirder-platform 0.1.7

data/lib/mingle/json.rb

@@ -0,0 +1,257 @@
+require 'bitgirder/core'
+require 'bitgirder/io'
+require 'mingle'
+require 'mingle/codec'
+
+module Mingle
+module Json
+
+include BitGirder::Core
+include Mingle
+
+class OptionsError < StandardError; end
+
+class JsonMingleCodec < BitGirderClass
+
+    KEY_TYPE = "$type"
+    KEY_CONSTANT = "$constant"
+                
+    MSG_MISSING_TYPE_KEY = %Q{Missing type key ("#{KEY_TYPE}")}
+
+    bg_attr :expand_enums, :processor => :boolean, :default => false
+ 
+    bg_attr :id_format,
+            :processor => lambda { |v| MingleIdentifier.as_format_name( v ) },
+            :default => :lc_hyphenated
+ 
+    bg_attr :omit_type_fields, :processor => :boolean, :default => false
+
+    include Mingle::Codec::MingleCodecImpl
+    include BitGirder::Core
+
+    require 'json'
+    require 'base64'
+
+    private
+    def impl_initialize
+
+        if @omit_type_fields && @expand_enums
+            raise OptionsError.new( 
+                "Illegal combination of :omit_type_fields and :expand_enums" )
+        end
+    end
+
+    private
+    def decode_raise( path, msg )
+        
+        msg = "#{path.format}: #{msg}" if path
+        codec_raise( msg )
+    end
+
+    private
+    def from_mingle_symbol_map( map, res = {} )
+        
+        map.each_pair do |k, v| 
+            res[ k.format( @id_format ) ] = from_mingle_value( v )
+        end
+
+        res
+    end
+
+    private
+    def from_mingle_struct( val )
+        
+        res = from_mingle_symbol_map( val.fields, {} )
+        res[ KEY_TYPE ] = val.type.external_form unless @omit_type_fields
+
+        res
+    end
+
+    private
+    def from_mingle_buffer( val )
+        Base64.strict_encode64( val.buf )
+    end
+
+    private
+    def from_mingle_enum( en )
+ 
+        val = en.value.external_form
+
+        if @expand_enums
+            { KEY_TYPE => en.type.external_form, KEY_CONSTANT => val }
+        else
+            val
+        end
+    end
+
+    private
+    def from_mingle_value( val )
+        
+        case val
+            when MingleString then val.to_s
+            when MingleSymbolMap then from_mingle_symbol_map( val )
+            when MingleStruct then from_mingle_struct( val )
+            when MingleBoolean then val.as_boolean
+
+            when MingleInt64, MingleInt32, MingleFloat64, MingleFloat32 
+                val.num
+
+            when MingleBuffer then from_mingle_buffer( val )
+            when MingleTimestamp then val.rfc3339
+            when MingleEnum then from_mingle_enum( val )
+            when MingleList then val.map { |elt| from_mingle_value( elt ) }
+            when MingleNull then nil
+            when nil then nil
+            else codec_raise "Can't convert to json an instance of #{val.class}"
+        end
+    end
+
+    public
+    def as_buffer( obj )
+        JSON.generate( from_mingle_value( obj ) )
+#        JSON.generate( from_mingle_value( obj ) ).encode( "binary" )
+    end
+
+    private
+    def descend( path, key )
+        path ? path.descend( key ) : ObjectPath.get_root( key )
+    end
+
+    private
+    def start_list( path )
+        path ? path.start_list : ObjectPath.get_root_list
+    end
+
+    private
+    def parse_identifier( s, path )
+        
+        begin
+            MingleIdentifier.parse( s )
+        rescue MingleParseError => e
+            decode_raise( path, e.message )
+        end
+    end
+
+    private
+    def parse_type_reference( s, path )
+        
+        begin
+            MingleTypeReference.parse( s )
+        rescue MingleParseError => e
+            decode_raise( path, e.message )
+        end
+    end
+
+    private
+    def enum_val_in( h, path )
+        
+        if val = h[ KEY_CONSTANT ]
+            if val.is_a?( String )
+                parse_identifier( val, descend( path, KEY_CONSTANT ) )
+            else
+                decode_raise( 
+                    path.descend( KEY_CONSTANT ), "Invalid constant value" )
+            end
+        end
+    end
+
+    private
+    def type_ref_in( h, path )
+        
+        if typ_str = h[ KEY_TYPE ]
+            parse_type_reference( typ_str, descend( path, KEY_TYPE ) )
+        end
+    end
+
+    private
+    def as_symbol_map( h, path )
+        
+        res = {}
+
+        h.each_pair do |k, v|
+            unless k == KEY_TYPE
+                if /^\$/ =~ k
+                    msg = "Unrecognized control key: #{k.inspect}"
+                    decode_raise( path, msg )
+                else
+                    key_path = descend( path, k )
+                    id = parse_identifier( k, key_path )
+                    val = as_mingle_value( v, key_path )
+                    res[ id ] = val
+                end
+            end
+        end
+
+        MingleSymbolMap.create( res )
+    end
+
+    private
+    def from_json_hash( h, struct_cls, path )
+        
+        en_const = enum_val_in( h, path )
+        type_ref = type_ref_in( h, path )
+
+        if en_const 
+            if type_ref 
+                if h.size > 2
+                    decode_raise path, "Enum has one or more unrecognized keys"
+                else
+                    MingleEnum.new( :type => type_ref, :value => en_const )
+                end
+            else
+                decode_raise path, MSG_MISSING_TYPE_KEY
+            end
+        else
+            flds = as_symbol_map( h, path )
+            type_ref ? 
+                MingleStruct.new( :type => type_ref, :fields => flds ) : flds
+        end
+    end
+
+    private
+    def from_json_array( arr, path )
+        
+        lp = start_list( path )
+
+        vals = arr.map do |v|
+            val = as_mingle_value( v, lp )
+            lp = lp.next
+            val
+        end
+
+        MingleList.new( vals )
+    end
+
+    private
+    def as_mingle_value( val, path )
+ 
+        case val
+            when Hash then from_json_hash( val, MingleStruct, path )
+            when Array then from_json_array( val, path )
+            else MingleModels.as_mingle_value( val )
+        end
+    end
+
+    public
+    def from_buffer( buf )
+
+        not_nil( buf, :buf )
+        json = BitGirder::Io.parse_json( buf )
+
+        if json.is_a?( Hash )
+
+            codec_raise( MSG_MISSING_TYPE_KEY ) if json.empty?
+
+            if ( res = as_mingle_value( json, nil ) ).is_a?( MingleStruct )
+                res
+            else
+                codec_raise( "Expected struct" ) 
+            end
+        else
+            codec_raise( "Unexpected top level JSON value" )
+        end
+    end
+end
+
+end
+end

data/lib/mingle/service.rb

@@ -0,0 +1,110 @@
+require 'bitgirder/core'
+require 'mingle'
+
+module Mingle
+module Service
+
+module MingleServices
+ 
+    extend BitGirder::Core::BitGirderMethods
+    include Mingle
+    
+    TYPE_SERVICE_REQUEST = 
+        MingleTypeReference.get( :"service@v1/ServiceRequest" )
+
+    TYPE_SERVICE_RESPONSE =
+        MingleTypeReference.get( :"service@v1/ServiceResponse" )
+
+    module_function
+
+    def check_type( ms, typ_expct, err_type )
+        
+        ( typ = ms.type ) == typ_expct or
+            raise "Invalid #{err_type} type: #{typ}"
+    end
+
+    def from_svc_req( req )
+        
+        flds = {
+            :namespace => req.namespace.external_form,
+            :service => req.service.external_form,
+            :operation => req.operation.external_form
+        }
+
+        if ( ( val = req.parameters ) && ( ! val.empty? ) )
+            flds[ :parameters ] = val 
+        end
+
+        if ( val = req.authentication ) then flds[ :authentication ] = val end
+
+        MingleStruct.new( :type => TYPE_SERVICE_REQUEST, :fields => flds )
+    end
+
+    def from_svc_resp( resp )
+        
+        flds = 
+            if resp.ok?
+                resp.result ? { :result => resp.result } : {}
+            else
+                { :exception => resp.error }
+            end
+ 
+        MingleStruct.new( :type => TYPE_SERVICE_RESPONSE, :fields => flds )
+    end
+
+    def as_mingle_struct( obj )
+        
+        not_nil( obj, :obj )
+
+        case obj
+            when MingleServiceRequest then from_svc_req( obj )
+            when MingleServiceResponse then from_svc_resp( obj )
+            else raise "Can't convert to mingle struct: #{obj}"
+        end
+    end
+
+    def as_service_request( ms )
+
+        not_nil( ms, :ms )
+        check_type( ms, TYPE_SERVICE_REQUEST, "service request" )
+
+        f = ms.fields
+
+        MingleServiceRequest.new( 
+            :namespace => MingleNamespace.get( f.expect_string( :namespace ) ),
+            :service => MingleIdentifier.get( f.expect_string( :service ) ),
+            :operation => MingleIdentifier.get( f.expect_string( :operation ) ),
+            :parameters => f[ :parameters ],
+            :authentication => f[ :authentication ]
+        )
+    end
+
+    def get_non_nil( val )
+
+        case val
+            when MingleNull then nil
+            else val
+        end
+    end
+
+    def as_service_response( ms )
+        
+        not_nil( ms, :ms )
+        check_type( ms, TYPE_SERVICE_RESPONSE, "service response" )
+
+        ex = get_non_nil( ms[ :exception ] )
+        res = get_non_nil( ms[ :result ] )
+
+        ( ex == nil || res == nil ) or 
+            raise "Response has non-nil result and exception"
+        
+        if ex 
+            MingleServiceResponse.create_failure( ex )
+        else
+            MingleServiceResponse.create_success( res )
+        end
+    end
+end
+
+end
+end

data/lib/mingle-em.rb

@@ -0,0 +1,92 @@
+require 'bitgirder/core'
+require 'mingle'
+
+module Mingle
+
+class EmHttpMingleRpcClient < BitGirder::Core::BitGirderClass
+    
+    require 'eventmachine'
+    require 'em-http'
+
+    HTTP_PRE_POST = :http_pre_post
+    HTTP_RESP_RECEIVED = :http_resp_received
+    MG_RESP_CREATED = :mg_resp_created
+
+    bg_attr :endpoint
+
+    bg_attr :identifier => :logger
+
+    @@codec = JsonMingleCodec.new
+
+    private
+    def cli_log( ev, obj )
+        
+        case @logger
+            
+            when Proc then @logger.call( ev, obj )
+
+            when BitGirder::Core::BitGirderLogger 
+                @logger.code( "#{self} logged event #{ev} with object #{obj}" )
+        end
+    end
+
+    private
+    def handle_response( resp, blk )
+
+        mg_resp, ex = [ nil, nil ]
+
+        begin
+            stat_str = resp.response_header.http_status
+
+            if stat_str.to_i == 200
+                mg_resp = @@codec.as_mingle_service_response( resp.response )
+                cli_log( MG_RESP_CREATED, mg_resp )
+            else
+                raise "http got non-success status: #{stat_str}"
+            end
+
+        rescue Exception => ex; end
+
+        begin
+            blk.call( mg_resp, ex )
+        rescue Exception => e
+            warn( "Response handler block failed: #{e}\n" +
+                  e.backtrace.join( "\n" ) )
+        end
+    end
+
+    public
+    def begin( mg_req, &blk )
+        
+        not_nil( mg_req, "mg_req" )
+        raise "Need a response handler block" unless blk
+
+        req = EM::HttpRequest.new( @endpoint )
+
+        post_args = { :body => @@codec.as_codec_object( mg_req ) }
+        cli_log( HTTP_PRE_POST, post_args )
+
+        http = req.post( post_args )
+
+        http.callback do |resp| 
+
+            cli_log( HTTP_RESP_RECEIVED, resp )
+            handle_response( resp, blk )
+        end
+    end
+
+    def call( ns, svc, op, params = nil, auth = nil, &blk )
+        
+        req =
+            MingleServiceRequest.new(
+                :namespace => ns,
+                :service => svc,
+                :operation => op,
+                :parameters => params,
+                :authentication => auth )
+    
+        self.begin( req, &blk )
+    end
+end
+
+end