def getReplyFor(self, request):
result = self.secondaryStorage.getReply(
request.identifier,
request.reqId,
type=request.operation[TXN_TYPE])
if result:
if request.operation[TXN_TYPE] == ATTRIB:
result = self.hashAttribTxn(result)
return Reply(result)
else:
return None
def generateReply(self, ppTime: float, req: Request):
operation = req.operation
txnId = self.genTxnId(req.identifier, req.reqId)
result = {TXN_ID: txnId, TXN_TIME: int(ppTime)}
result.update(operation)
result.update({
f.IDENTIFIER.nm: req.identifier,
f.REQ_ID.nm: req.reqId,
})
return Reply(result)
def processGetIssuerKeyReq(self, request: Request, frm: str):
self.transmitToClient(RequestAck(*request.key), frm)
keys = self.graphStore.getIssuerKeys(request.operation[ORIGIN],
request.operation[REF])
result = {TXN_ID: self.genTxnId(request.identifier, request.reqId)}
result.update(request.operation)
result[DATA] = json.dumps(keys, sort_keys=True)
result.update({
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
})
self.transmitToClient(Reply(result), frm)
def storeTxnAndSendToClient(self, reply):
"""
Does 4 things in following order
1. Add reply to ledger.
2. Send the reply to client.
3. Add the reply to identity graph if needed.
4. Add the reply to storage so it can be served later if the
client requests it.
"""
txnWithMerkleInfo = self.storeTxnInLedger(reply.result)
self.sendReplyToClient(Reply(txnWithMerkleInfo))
reply.result[F.seqNo.name] = txnWithMerkleInfo.get(F.seqNo.name)
self.storeTxnInGraph(reply.result)
def processGetClaimDefReq(self, request: Request, frm: str):
issuerNym = request.operation[TARGET_NYM]
name = request.operation[DATA][NAME]
version = request.operation[DATA][VERSION]
claimDef = self.graphStore.getClaimDef(issuerNym, name, version)
result = {TXN_ID: self.genTxnId(request.identifier, request.reqId)}
result.update(request.operation)
result[DATA] = json.dumps(claimDef, sort_keys=True)
result.update({
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
})
self.transmitToClient(Reply(result), frm)
def processGetNymReq(self, request: Request, frm: str):
self.transmitToClient(RequestAck(request.reqId), frm)
nym = request.operation[TARGET_NYM]
txn = self.graphStore.getAddNymTxn(nym)
txnId = self.genTxnId(request.identifier, request.reqId)
result = {
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
DATA: json.dumps(txn) if txn else None,
TXN_ID: txnId
}
result.update(request.operation)
self.transmitToClient(Reply(result), frm)
def getReplyFor(self, request):
typ = request.operation.get(TXN_TYPE)
if typ in IDENTITY_TXN_TYPES:
result = self.secondaryStorage.getReply(request.identifier,
request.reqId,
type=request.operation[TXN_TYPE])
if result:
if request.operation[TXN_TYPE] == ATTRIB:
result = self.hashAttribTxn(result)
return Reply(result)
else:
return None
if typ in CONFIG_TXN_TYPES:
return self.getReplyFromLedger(self.configLedger, request)
def processGetNymReq(self, request: Request, frm: str):
self.transmitToClient(RequestAck(*request.key), frm)
nym = request.operation[TARGET_NYM]
txn = self.graphStore.getAddNymTxn(nym)
txnId = self.genTxnId(request.identifier, request.reqId)
# TODO: We should have a single JSON encoder which does the
# encoding for us, like sorting by keys, handling datetime objects.
result = {f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
DATA: json.dumps(txn, sort_keys=True) if txn else None,
TXN_ID: txnId
}
result.update(request.operation)
self.transmitToClient(Reply(result), frm)
def processGetIssuerKeyReq(self, request: Request, frm: str):
self.transmitToClient(RequestAck(request.reqId), frm)
keys = self.graphStore.getIssuerKeys(request.operation[ORIGIN],
request.operation[REFERENCE])
# attrNames = request.operation[RAW]
# nym = request.operation[TARGET_NYM]
# attrs = self.graphStore.getRawAttrs(nym, attrNames)
result = {TXN_ID: self.genTxnId(request.identifier, request.reqId)}
result.update(request.operation)
result[DATA] = json.dumps(keys)
result.update({
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
})
self.transmitToClient(Reply(result), frm)
def processGetAttrsReq(self, request: Request, frm: str):
self.transmitToClient(RequestAck(*request.key), frm)
attrName = request.operation[RAW]
nym = request.operation[TARGET_NYM]
attrWithSeqNo = self.graphStore.getRawAttrs(nym, attrName)
result = {TXN_ID: self.genTxnId(request.identifier, request.reqId)}
if attrWithSeqNo:
attr = {attrName: attrWithSeqNo[attrName][0]}
result[DATA] = json.dumps(attr, sort_keys=True)
result[F.seqNo.name] = attrWithSeqNo[attrName][1]
result.update(request.operation)
result.update({
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
})
self.transmitToClient(Reply(result), frm)
def storeTxnAndSendToClient(self, reply):
"""
Does 4 things in following order
1. Add reply to ledger.
2. Send the reply to client.
3. Add the reply to identity graph if needed.
4. Add the reply to storage so it can be served later if the
client requests it.
"""
result = reply.result
txnWithMerkleInfo = self.storeTxnInLedger(result)
if result[TXN_TYPE] == NODE_UPGRADE:
logger.info('{} processed {}'.format(self, NODE_UPGRADE))
# Returning since NODE_UPGRADE is not sent to client and neither
# goes in graph
return
self.sendReplyToClient(Reply(txnWithMerkleInfo),
(result[f.IDENTIFIER.nm], result[f.REQ_ID.nm]))
reply.result[F.seqNo.name] = txnWithMerkleInfo.get(F.seqNo.name)
self.storeTxnInGraph(reply.result)
def processGetTxnReq(self, request: Request, frm: str):
nym = request.operation[TARGET_NYM]
origin = request.identifier
if nym != origin:
# TODO not sure this is correct; why does it matter?
msg = "You can only receive transactions for yourself"
self.transmitToClient(RequestNack(*request.key, msg), frm)
else:
self.transmitToClient(RequestAck(*request.key), frm)
data = request.operation.get(DATA)
addNymTxn = self.graphStore.getAddNymTxn(origin)
txnIds = [addNymTxn[TXN_ID], ] + self.graphStore. \
getAddAttributeTxnIds(origin)
# If sending transactions to a user then should send user's
# sponsor creation transaction also
if addNymTxn.get(ROLE) == USER:
sponsorNymTxn = self.graphStore.getAddNymTxn(
addNymTxn.get(f.IDENTIFIER.nm))
txnIds = [
sponsorNymTxn[TXN_ID],
] + txnIds
# TODO: Remove this log statement
logger.debug("{} getting replies for {}".format(self, txnIds))
result = self.secondaryStorage.getReplies(*txnIds, seqNo=data)
txns = sorted(list(result.values()), key=itemgetter(F.seqNo.name))
lastTxn = str(txns[-1][F.seqNo.name]) if len(txns) > 0 else data
result = {TXN_ID: self.genTxnId(request.identifier, request.reqId)}
result.update(request.operation)
# TODO: We should have a single JSON encoder which does the
# encoding for us, like sorting by keys, handling datetime objects.
result[DATA] = json.dumps({
LAST_TXN: lastTxn,
TXNS: txns
},
default=dateTimeEncoding,
sort_keys=True)
result.update({
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
})
self.transmitToClient(Reply(result), frm)
def getReplyFor(self, request):
txn = self.ledger.get(identifier=request.identifier,
reqId=request.reqId)
if txn:
txn.update(self.ledger.merkleInfo(txn.get(F.seqNo.name)))
return Reply(txn)
def getReplyFor(self, request):
result = self.secondaryStorage.getReply(
request.identifier,
request.reqId,
type=request.operation[TXN_TYPE])
return Reply(result) if result else None