def connectToIS(self, currency_description_document): """sets up the isMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.isMessageType = MessageType(client) # Add handlers for all the messages using isMessages if it continues the conversation self.isMessageType.addMessageHandler(MintingKeyFetchKeyID()) self.isMessageType.addMessageHandler(MintingKeyFetchDenomination()) #self.isMessageType.addMessageHandler(self.isMessages.MKP) #self.isMessageType.addMessageHandler(self.isMessages.MKF) self.isMessageType.addMessageHandler( MintingKeyPass() ) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler( MintingKeyFailure() ) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler(MintRequest()) self.isMessageType.addMessageHandler(self.isMessages.MA) self.isMessageType.addMessageHandler(self.isMessages.MR) self.isMessageType.addMessageHandler(FetchMintedRequest()) self.isMessageType.addMessageHandler(self.isMessages.FMF) self.isMessageType.addMessageHandler(self.isMessages.FMW) self.isMessageType.addMessageHandler(self.isMessages.FMA) self.isMessageType.addMessageHandler(RedeemCoinsRequest()) self.isMessageType.addMessageHandler(self.isMessages.RCR) self.isMessageType.addMessageHandler(self.isMessages.RCA) self.entity.connectToIS(self.isMessageType, currency_description_document)
def connectToDSDB(self, dsdb_certificate): """sets up the dsdbMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.dsdbMessageType = MessageType(client) # Add handlers for all the messages using dsdbMessages if it continues conversation self.dsdbMessageType.addMessageHandler(LockCoinsRequest()) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.LCF) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.LCA) self.dsdbMessageType.addMessageHandler(UnlockCoinsRequest()) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.UCF) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.UCP) self.entity.connectToDSDB(self.dsdbMessageType, dsdb_certificate)
def connectToIS(self, currency_description_document): """sets up the isMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.isMessageType = MessageType(client) # Add handlers for all the messages, using isMessages if continues conversation self.isMessageType.addMessageHandler(DSDBKeyRequest()) self.isMessageType.addMessageHandler(self.isMessages.DKP) self.entity.connectToIS(self.isMessageType, currency_description_document) #FIXME: This is one of many places we enforce the one currency at a time self.cdd = currency_description_document
def decode_frame(raw_data): """ Try to create a frame instance from the raw data. It's assumed that raw_data is a buffer and can still be incomplete to create a valid frame or it has multiple frames packed into it. Arguments: raw_data - byte() with the raw data of the buffer Returns (bytes consumed, frame instance) or (0, None) if no complete frame is in the buffer Raises FrameException if an invalid frame was detected. """ log.debug("RAW DATA: %r" % raw_data) try: msg_type, payload_size = struct.unpack(FRAME_HEADER_STRUCT, raw_data[:FRAME_HEADER_SIZE]) except struct.error: log.debug("Invalid frame - couldn't unpack headers") return 0, None frame_end = FRAME_HEADER_SIZE + payload_size + FRAME_END_SIZE if len(raw_data) < frame_end: log.debug("Invalid frame - incomplete frame (%d, %d)" % \ (len(raw_data), frame_end)) return 0, None if raw_data[frame_end - FRAME_END_SIZE] != FRAME_END: raise FrameException( "Frame doesn't end with the expected FRAME_END marker") payload = raw_data[FRAME_HEADER_SIZE:frame_end-FRAME_END_SIZE] log.debug("PAYLOAD: %r" % payload) if msg_type not in MessageType.values(): raise FrameException("Frame has invalid message type") return frame_end, Frame(msg_type, payload)
def connectToIS(self, currency_description_document): """sets up the isMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.isMessageType = MessageType(client) # Add handlers for all the messages using isMessages if it continues the conversation self.isMessageType.addMessageHandler(MintingKeyFetchKeyID()) self.isMessageType.addMessageHandler(MintingKeyFetchDenomination()) #self.isMessageType.addMessageHandler(self.isMessages.MKP) #self.isMessageType.addMessageHandler(self.isMessages.MKF) self.isMessageType.addMessageHandler(MintingKeyPass()) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler(MintingKeyFailure()) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler(MintRequest()) self.isMessageType.addMessageHandler(self.isMessages.MA) self.isMessageType.addMessageHandler(self.isMessages.MR) self.isMessageType.addMessageHandler(FetchMintedRequest()) self.isMessageType.addMessageHandler(self.isMessages.FMF) self.isMessageType.addMessageHandler(self.isMessages.FMW) self.isMessageType.addMessageHandler(self.isMessages.FMA) self.isMessageType.addMessageHandler(RedeemCoinsRequest()) self.isMessageType.addMessageHandler(self.isMessages.RCR) self.isMessageType.addMessageHandler(self.isMessages.RCA) self.entity.connectToIS(self.isMessageType, currency_description_document)
def answer(self): if DEBUG and not MessageType.is_output(self.msg.type): return [MessageTransfer(who=self.msg.who, body='unknown command', type=MessageType.output), ]
class MerchantWalletManager(object): def __init__(self, walletMessageType, entity): # isMessageType, dsdbMessageType, amount): self.walletMessageType = walletMessageType self.entity = entity #self.isMessageType = isMessageType #self.dsdbMessageType = dsdbMessageType if not self.walletMessageType.globals.status.can( MessageStatuses.PrivilegeServer): raise MessageError( 'given messageType does not have PrivilegeServer') class messages: pass self.walletMessages = messages() self.isMessages = messages() self.dsdbMessages = messages() del messages # All the responses we can get from the IS (we are client) #self.isMessages.MKP = MintingKeyPass(self.resumeConversation) # this are being handled elsewhere (BlankAndMintingKey) #self.isMessages.MKF = MintingKeyFailure(self.resumeConversation) # this is being handled elsewhere (BlankAndMintingKey) self.isMessages.MA = MintAccept(self.resumeConversation) self.isMessages.MR = MintReject(self.resumeConversation) self.isMessages.FMF = FetchMintedFailure(self.resumeConversation) self.isMessages.FMW = FetchMintedWait(self.resumeConversation) self.isMessages.FMA = FetchMintedAccept(self.resumeConversation) self.isMessages.RCR = RedeemCoinsReject(self.resumeConversation) self.isMessages.RCA = RedeemCoinsAccept(self.resumeConversation) # All messages can get from the other wallet (we are server) self.walletMessages.CR = CoinsRedeem(self.resumeConversation) self.walletMessages.BP = BlankPresent(self.resumeConversation) # All the responses we can get from the DSDB self.dsdbMessages.LCA = LockCoinsAccept(self.resumeConversation) self.dsdbMessages.LCF = LockCoinsFailure(self.resumeConversation) self.dsdbMessages.UCP = UnlockCoinsPass(self.resumeConversation) self.dsdbMessages.UCF = UnlockCoinsFailure(self.resumeConversation) # Add handlers for all the messages using walletMessages if starts conversation self.walletMessageType.addMessageHandler(self.walletMessages.BP) self.walletMessageType.addMessageHandler(BlankReject()) self.walletMessageType.addMessageHandler(BlankFailure()) self.walletMessageType.addMessageHandler(BlankAccept()) self.walletMessageType.addMessageHandler(self.walletMessages.CR) self.walletMessageType.addMessageHandler(CoinsReject()) self.walletMessageType.addMessageHandler(CoinsAccept()) class state: __slots__ = ( 'blanks', # the blanks given in BlankPresent 'dsdb_certificate', # the dsdb certificate given in BlankPresent 'mintBlanks', # blanks we created for use with a MintRequest (to make new coins) 'dsdb_lock', # the lock we receive when we perform a LockRequest 'coins', # the coins received from the other wallet with a CoinsRedeem 'mintingKeysKeyID', # the minting key certificates for all coins received 'mintingKeysDenomination', # the minting key certificates for all denominations of all coins received 'mintRequestID', # the request id generated for the MintRequest 'target', # the target for the MintRequest 'signatures', # the signatures returned from IS via FetchMintedRequest 'newCoins', # our newly minted coins after 'mintingFailures' # any coins where the signature was invalid. Nothing we can really do with this though. ) self.persistant = state() del state self.lastMessageIdentifier = None # an explaination of how this class treats the exchange. We first wait for a BlankPresent from the wallet. We look at the issuer and # let the client decide if he wants to accept. # if he does, we make matching blanks and depending on the issuer, MintRequest now (may do after RedeemCoins. # we verify the blanks against the DSDB and then BlankAccept. We get the CoinsRedeem, test them, then CoinsAccept. # now we RedeemCoinsRequest, and potentially MintRequest at this point. Finally, we FetchMintedRequest to get the new coins. Done. Whew! # More information. If isRequiresMRbeforeRCR is true, the chain when the wallet accepts the coins goes: # MINT_REQUEST -> (MINT_ACCEPT) -> REDEEM_COINS_REQUEST -> (REDEEM_COINS_ACCEPT) -> FETCH_MINTED_REQUEST -> (FETCH_MINTED_ACCEPT) # If isRequiresMRbeforeRCR is false, the chain when the wallet sends the COINS_REQUEST goes: # REDEEM_COINS_REQUEST -> (REDEEM_COINS_ACCEPT) -> MINT_REQUEST -> (MINT_ACCEPT) -> FETCH_MINTED_REQUEST -> (FETCH_MINTED_ACCEPT def resumeConversation(self, message, result): if isinstance(message, BlankPresent): self.setHandler(BlankAndMintingKey( self, message)) # First we receive the blanks elif isinstance(message, MintAccept) or isinstance( message, MintReject): self.setHandler(Mint( self, message)) # Then we (may) try to mint our own blanks elif isinstance(message, LockCoinsFailure) or isinstance( message, LockCoinsAccept): self.setHandler(LockCoins( self, message)) # We also have to try to lock the coins... elif isinstance(message, CoinsRedeem): self.setHandler( Coins(self, message) ) # We locked the coins, and they are valid. We sent a BlankAccept. Next we get told to redeem them elif isinstance(message, RedeemCoinsReject) or isinstance( message, RedeemCoinsAccept): self.setHandler( RedeemCoins(self, message) ) # Now we redeem them (note: the next step may be to try to mint them...) elif isinstance(message, FetchMintedWait) or isinstance( message, FetchMintedFailure) or isinstance( message, FetchMintedAccept): self.setHandler(FetchMinted( self, message)) # And finally, get the coins. elif isinstance(message, UnlockCoinsPass) or isinstance( message, UnlockCoinsFailure): self.setHandler(UnlockCoins( self, message)) # If we erred, we unlock to be nice else: raise MessageError('Message %s does not continue a conversation' % message.identifier) def setHandler(self, handler): self.handler = handler def connectToDSDB(self, dsdb_certificate): """sets up the dsdbMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.dsdbMessageType = MessageType(client) # Add handlers for all the messages using dsdbMessages if it continues conversation self.dsdbMessageType.addMessageHandler(LockCoinsRequest()) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.LCF) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.LCA) self.dsdbMessageType.addMessageHandler(UnlockCoinsRequest()) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.UCF) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.UCP) self.entity.connectToDSDB(self.dsdbMessageType, dsdb_certificate) def connectToIS(self, currency_description_document): """sets up the isMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.isMessageType = MessageType(client) # Add handlers for all the messages using isMessages if it continues the conversation self.isMessageType.addMessageHandler(MintingKeyFetchKeyID()) self.isMessageType.addMessageHandler(MintingKeyFetchDenomination()) #self.isMessageType.addMessageHandler(self.isMessages.MKP) #self.isMessageType.addMessageHandler(self.isMessages.MKF) self.isMessageType.addMessageHandler( MintingKeyPass() ) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler( MintingKeyFailure() ) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler(MintRequest()) self.isMessageType.addMessageHandler(self.isMessages.MA) self.isMessageType.addMessageHandler(self.isMessages.MR) self.isMessageType.addMessageHandler(FetchMintedRequest()) self.isMessageType.addMessageHandler(self.isMessages.FMF) self.isMessageType.addMessageHandler(self.isMessages.FMW) self.isMessageType.addMessageHandler(self.isMessages.FMA) self.isMessageType.addMessageHandler(RedeemCoinsRequest()) self.isMessageType.addMessageHandler(self.isMessages.RCR) self.isMessageType.addMessageHandler(self.isMessages.RCA) self.entity.connectToIS(self.isMessageType, currency_description_document) def success(self, message, handler): print 'Received a success! Message class: %s. Handler class: %s' % ( message.__class__, handler.__class__) def failure(self, message, handler): print 'Receive a failure. :( Message %s Sentence: %s' % ( message.identifier, message.sentence) print 'We should do something like un-hook ourselves or something.' def waitForFetchMint(self, message, handler): print 'We were told to wait on our FetchMintedRequest. Reason: %s' % message.messageLayer.globals.reason
class MerchantWalletManager(object): def __init__(self, walletMessageType, entity): # isMessageType, dsdbMessageType, amount): self.walletMessageType = walletMessageType self.entity = entity #self.isMessageType = isMessageType #self.dsdbMessageType = dsdbMessageType if not self.walletMessageType.globals.status.can(MessageStatuses.PrivilegeServer): raise MessageError('given messageType does not have PrivilegeServer') class messages: pass self.walletMessages = messages() self.isMessages = messages() self.dsdbMessages = messages() del messages # All the responses we can get from the IS (we are client) #self.isMessages.MKP = MintingKeyPass(self.resumeConversation) # this are being handled elsewhere (BlankAndMintingKey) #self.isMessages.MKF = MintingKeyFailure(self.resumeConversation) # this is being handled elsewhere (BlankAndMintingKey) self.isMessages.MA = MintAccept(self.resumeConversation) self.isMessages.MR = MintReject(self.resumeConversation) self.isMessages.FMF = FetchMintedFailure(self.resumeConversation) self.isMessages.FMW = FetchMintedWait(self.resumeConversation) self.isMessages.FMA = FetchMintedAccept(self.resumeConversation) self.isMessages.RCR = RedeemCoinsReject(self.resumeConversation) self.isMessages.RCA = RedeemCoinsAccept(self.resumeConversation) # All messages can get from the other wallet (we are server) self.walletMessages.CR = CoinsRedeem(self.resumeConversation) self.walletMessages.BP = BlankPresent(self.resumeConversation) # All the responses we can get from the DSDB self.dsdbMessages.LCA = LockCoinsAccept(self.resumeConversation) self.dsdbMessages.LCF = LockCoinsFailure(self.resumeConversation) self.dsdbMessages.UCP = UnlockCoinsPass(self.resumeConversation) self.dsdbMessages.UCF = UnlockCoinsFailure(self.resumeConversation) # Add handlers for all the messages using walletMessages if starts conversation self.walletMessageType.addMessageHandler(self.walletMessages.BP) self.walletMessageType.addMessageHandler(BlankReject()) self.walletMessageType.addMessageHandler(BlankFailure()) self.walletMessageType.addMessageHandler(BlankAccept()) self.walletMessageType.addMessageHandler(self.walletMessages.CR) self.walletMessageType.addMessageHandler(CoinsReject()) self.walletMessageType.addMessageHandler(CoinsAccept()) class state: __slots__ = ('blanks', # the blanks given in BlankPresent 'dsdb_certificate', # the dsdb certificate given in BlankPresent 'mintBlanks', # blanks we created for use with a MintRequest (to make new coins) 'dsdb_lock', # the lock we receive when we perform a LockRequest 'coins', # the coins received from the other wallet with a CoinsRedeem 'mintingKeysKeyID', # the minting key certificates for all coins received 'mintingKeysDenomination', # the minting key certificates for all denominations of all coins received 'mintRequestID', # the request id generated for the MintRequest 'target', # the target for the MintRequest 'signatures', # the signatures returned from IS via FetchMintedRequest 'newCoins', # our newly minted coins after 'mintingFailures' # any coins where the signature was invalid. Nothing we can really do with this though. ) self.persistant = state() del state self.lastMessageIdentifier = None # an explaination of how this class treats the exchange. We first wait for a BlankPresent from the wallet. We look at the issuer and # let the client decide if he wants to accept. # if he does, we make matching blanks and depending on the issuer, MintRequest now (may do after RedeemCoins. # we verify the blanks against the DSDB and then BlankAccept. We get the CoinsRedeem, test them, then CoinsAccept. # now we RedeemCoinsRequest, and potentially MintRequest at this point. Finally, we FetchMintedRequest to get the new coins. Done. Whew! # More information. If isRequiresMRbeforeRCR is true, the chain when the wallet accepts the coins goes: # MINT_REQUEST -> (MINT_ACCEPT) -> REDEEM_COINS_REQUEST -> (REDEEM_COINS_ACCEPT) -> FETCH_MINTED_REQUEST -> (FETCH_MINTED_ACCEPT) # If isRequiresMRbeforeRCR is false, the chain when the wallet sends the COINS_REQUEST goes: # REDEEM_COINS_REQUEST -> (REDEEM_COINS_ACCEPT) -> MINT_REQUEST -> (MINT_ACCEPT) -> FETCH_MINTED_REQUEST -> (FETCH_MINTED_ACCEPT def resumeConversation(self, message, result): if isinstance(message, BlankPresent): self.setHandler(BlankAndMintingKey(self, message)) # First we receive the blanks elif isinstance(message, MintAccept) or isinstance(message, MintReject): self.setHandler(Mint(self, message)) # Then we (may) try to mint our own blanks elif isinstance(message, LockCoinsFailure) or isinstance(message, LockCoinsAccept): self.setHandler(LockCoins(self, message)) # We also have to try to lock the coins... elif isinstance(message, CoinsRedeem): self.setHandler(Coins(self, message)) # We locked the coins, and they are valid. We sent a BlankAccept. Next we get told to redeem them elif isinstance(message, RedeemCoinsReject) or isinstance(message, RedeemCoinsAccept): self.setHandler(RedeemCoins(self, message)) # Now we redeem them (note: the next step may be to try to mint them...) elif isinstance(message, FetchMintedWait) or isinstance(message, FetchMintedFailure) or isinstance(message, FetchMintedAccept): self.setHandler(FetchMinted(self, message)) # And finally, get the coins. elif isinstance(message, UnlockCoinsPass) or isinstance(message, UnlockCoinsFailure): self.setHandler(UnlockCoins(self, message)) # If we erred, we unlock to be nice else: raise MessageError('Message %s does not continue a conversation' % message.identifier) def setHandler(self, handler): self.handler = handler def connectToDSDB(self, dsdb_certificate): """sets up the dsdbMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.dsdbMessageType = MessageType(client) # Add handlers for all the messages using dsdbMessages if it continues conversation self.dsdbMessageType.addMessageHandler(LockCoinsRequest()) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.LCF) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.LCA) self.dsdbMessageType.addMessageHandler(UnlockCoinsRequest()) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.UCF) self.dsdbMessageType.addMessageHandler(self.dsdbMessages.UCP) self.entity.connectToDSDB(self.dsdbMessageType, dsdb_certificate) def connectToIS(self, currency_description_document): """sets up the isMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.isMessageType = MessageType(client) # Add handlers for all the messages using isMessages if it continues the conversation self.isMessageType.addMessageHandler(MintingKeyFetchKeyID()) self.isMessageType.addMessageHandler(MintingKeyFetchDenomination()) #self.isMessageType.addMessageHandler(self.isMessages.MKP) #self.isMessageType.addMessageHandler(self.isMessages.MKF) self.isMessageType.addMessageHandler(MintingKeyPass()) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler(MintingKeyFailure()) # These normally would continue, but are folded into BlankAndMintingKey self.isMessageType.addMessageHandler(MintRequest()) self.isMessageType.addMessageHandler(self.isMessages.MA) self.isMessageType.addMessageHandler(self.isMessages.MR) self.isMessageType.addMessageHandler(FetchMintedRequest()) self.isMessageType.addMessageHandler(self.isMessages.FMF) self.isMessageType.addMessageHandler(self.isMessages.FMW) self.isMessageType.addMessageHandler(self.isMessages.FMA) self.isMessageType.addMessageHandler(RedeemCoinsRequest()) self.isMessageType.addMessageHandler(self.isMessages.RCR) self.isMessageType.addMessageHandler(self.isMessages.RCA) self.entity.connectToIS(self.isMessageType, currency_description_document) def success(self, message, handler): print 'Received a success! Message class: %s. Handler class: %s' % (message.__class__, handler.__class__) def failure(self, message, handler): print 'Receive a failure. :( Message %s Sentence: %s' % (message.identifier, message.sentence) print 'We should do something like un-hook ourselves or something.' def waitForFetchMint(self, message, handler): print 'We were told to wait on our FetchMintedRequest. Reason: %s' % message.messageLayer.globals.reason
def __str__(self): return "Frame(%s, len(payload)=%d)" % \ (MessageType.key_of(self.msg_type), len(self.payload))
class ConsumerWalletManager(object): def __init__(self, walletMessageType, entity, coins): self.walletMessageType = walletMessageType self.entity = entity #self.isMessageType = isMessageType if not self.walletMessageType.globals.status.can( MessageStatuses.PrivilegeClient): raise MessageError( 'given messageType does not have PrivilegeClient') class messages: pass self.walletMessages = messages() self.isMessages = messages() del messages # All the responses we can get from the IS self.isMessages.DKP = DSDBKeyPass(self.resumeConversation) # All the responses we can get from the other wallet self.walletMessages.BR = BlankReject(self.resumeConversation) self.walletMessages.BF = BlankFailure(self.resumeConversation) self.walletMessages.BA = BlankAccept(self.resumeConversation) self.walletMessages.CR = CoinsReject(self.resumeConversation) self.walletMessages.CA = CoinsAccept(self.resumeConversation) # Add handlers for all the messages using walletMessages if continues conversation self.walletMessageType.addMessageHandler(BlankPresent()) self.walletMessageType.addMessageHandler(self.walletMessages.BR) self.walletMessageType.addMessageHandler(self.walletMessages.BF) self.walletMessageType.addMessageHandler(self.walletMessages.BA) self.walletMessageType.addMessageHandler(CoinsRedeem()) self.walletMessageType.addMessageHandler(self.walletMessages.CR) self.walletMessageType.addMessageHandler(self.walletMessages.CA) self.coins = coins class state: pass self.persistant = state() del state self.lastMessageIdentifier = None def resumeConversation(self, message, result): if isinstance(message, DSDBKeyPass): self.setHandler(DSDBKey(self, message)) elif isinstance(message, BlankReject) or isinstance( message, BlankFailure) or isinstance(message, BlankAccept): self.setHandler(Blank(self, message)) elif isinstance(message, CoinsReject) or isinstance( message, CoinsAccept): self.setHandler(Coins(self, message)) else: raise MessageError('Message %s does not continue a conversation' % message.identifier) def setHandler(self, handler): self.handler = handler def startConversation(self): #this is kind of a hack. Okay. A lot of a hack self.connectToIS(self.entity.cdds[self.coins[0].currency_identifier]) dkr = DSDBKeyRequest() self.isMessageType.addOutput( dkr) # and so it starts. Flow follows to DSDBKey def success(self, message, handler): print 'Received a success! Message class: %s. Handler class: %s' % ( message.__class__, handler.__class__) def failure(self, message, handler): print 'Received a failure. Message %s Sentence: %s' % ( message.identifier, message.sentence) print 'We should do something like un-hook ourselves or something.' def connectToIS(self, currency_description_document): """sets up the isMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.isMessageType = MessageType(client) # Add handlers for all the messages, using isMessages if continues conversation self.isMessageType.addMessageHandler(DSDBKeyRequest()) self.isMessageType.addMessageHandler(self.isMessages.DKP) self.entity.connectToIS(self.isMessageType, currency_description_document) #FIXME: This is one of many places we enforce the one currency at a time self.cdd = currency_description_document
class ConsumerWalletManager(object): def __init__(self, walletMessageType, entity, coins): self.walletMessageType = walletMessageType self.entity = entity #self.isMessageType = isMessageType if not self.walletMessageType.globals.status.can(MessageStatuses.PrivilegeClient): raise MessageError('given messageType does not have PrivilegeClient') class messages: pass self.walletMessages = messages() self.isMessages = messages() del messages # All the responses we can get from the IS self.isMessages.DKP = DSDBKeyPass(self.resumeConversation) # All the responses we can get from the other wallet self.walletMessages.BR = BlankReject(self.resumeConversation) self.walletMessages.BF = BlankFailure(self.resumeConversation) self.walletMessages.BA = BlankAccept(self.resumeConversation) self.walletMessages.CR = CoinsReject(self.resumeConversation) self.walletMessages.CA = CoinsAccept(self.resumeConversation) # Add handlers for all the messages using walletMessages if continues conversation self.walletMessageType.addMessageHandler(BlankPresent()) self.walletMessageType.addMessageHandler(self.walletMessages.BR) self.walletMessageType.addMessageHandler(self.walletMessages.BF) self.walletMessageType.addMessageHandler(self.walletMessages.BA) self.walletMessageType.addMessageHandler(CoinsRedeem()) self.walletMessageType.addMessageHandler(self.walletMessages.CR) self.walletMessageType.addMessageHandler(self.walletMessages.CA) self.coins = coins class state: pass self.persistant = state() del state self.lastMessageIdentifier = None def resumeConversation(self, message, result): if isinstance(message, DSDBKeyPass): self.setHandler(DSDBKey(self, message)) elif isinstance(message, BlankReject) or isinstance(message, BlankFailure) or isinstance(message, BlankAccept): self.setHandler(Blank(self, message)) elif isinstance(message, CoinsReject) or isinstance(message, CoinsAccept): self.setHandler(Coins(self, message)) else: raise MessageError('Message %s does not continue a conversation' % message.identifier) def setHandler(self, handler): self.handler = handler def startConversation(self): #this is kind of a hack. Okay. A lot of a hack self.connectToIS(self.entity.cdds[self.coins[0].currency_identifier]) dkr = DSDBKeyRequest() self.isMessageType.addOutput(dkr) # and so it starts. Flow follows to DSDBKey def success(self, message, handler): print 'Received a success! Message class: %s. Handler class: %s' % (message.__class__, handler.__class__) def failure(self, message, handler): print 'Received a failure. Message %s Sentence: %s' % (message.identifier, message.sentence) print 'We should do something like un-hook ourselves or something.' def connectToIS(self, currency_description_document): """sets up the isMessageType and links the callbacks.""" client = MessageStatuses.getBaseClient() self.isMessageType = MessageType(client) # Add handlers for all the messages, using isMessages if continues conversation self.isMessageType.addMessageHandler(DSDBKeyRequest()) self.isMessageType.addMessageHandler(self.isMessages.DKP) self.entity.connectToIS(self.isMessageType, currency_description_document) #FIXME: This is one of many places we enforce the one currency at a time self.cdd = currency_description_document