def unmake_payload(payload):
"""Turn a payload back into a message given it's message type"""
if isinstance(payload, bytes):
decoded = RBACPayload()
decoded.ParseFromString(payload)
payload = decoded
if not isinstance(payload, RBACPayload):
raise Exception("Expected RBACPayload")
if not isinstance(payload.content, bytes):
raise Exception("Expected RBACPayload, no content found")
message_type = payload.message_type
message = None
inputs = list(payload.inputs)
outputs = list(payload.outputs)
if message_type == RBACPayload.CREATE_USER:
message = protobuf.user_transaction_pb2.CreateUser()
elif message_type == RBACPayload.CREATE_ROLE:
message = protobuf.role_transaction_pb2.CreateRole()
elif message_type == RBACPayload.PROPOSE_ADD_ROLE_MEMBER:
message = protobuf.role_transaction_pb2.ProposeAddRoleMember()
elif message_type == RBACPayload.PROPOSE_ADD_ROLE_OWNER:
message = protobuf.role_transaction_pb2.ProposeAddRoleOwner()
elif message_type == RBACPayload.PROPOSE_ADD_ROLE_ADMIN:
message = protobuf.role_transaction_pb2.ProposeAddRoleAdmin()
else:
raise Exception(
"unmake_payload doesn't support message type {}".format(
message_type))
message.ParseFromString(payload.content)
return message_type, message, inputs, outputs
def apply(self, transaction, state):
"""Applies the transaction"""
try:
if transaction.payload == "ping".encode("utf-8"):
LOGGER.info("Got a ping!")
return None
payload = RBACPayload()
payload.ParseFromString(transaction.payload)
if self._processor.has_message_handler(message_type=payload.message_type):
return self._processor.handle_message(
header=transaction.header, payload=payload, context=state
)
raise InvalidTransaction(
"Transaction processor has no registered handler for message type {}".format(
payload.message_type
)
)
except (ValueError, KeyError) as err:
raise InvalidTransaction(err)
except Exception as err: # pylint: disable=broad-except
LOGGER.exception("Unexpected processor %s exception", type(err))
LOGGER.exception(err)
raise InvalidTransaction(err)
return None
def unmake_payload(payload):
"""Turn a payload back into a message given it's message type
Use only for testing purposes.
"""
if isinstance(payload, bytes):
decoded = RBACPayload()
decoded.ParseFromString(payload)
payload = decoded
if not isinstance(payload, RBACPayload):
raise Exception("Expected RBACPayload")
if not isinstance(payload.content, bytes):
raise Exception("Expected RBACPayload, no content found")
message_type = payload.message_type
message = get_proto(message_type)
message.ParseFromString(payload.content)
message_payload = MessagePayload(
message_type=message_type,
inputs=set(list(payload.inputs)),
outputs=set(list(payload.outputs)),
signer=payload.signer,
now=payload.now,
)
return message, message_payload
def unmake_item(batch_object,
signer_public_key=None,
batcher_public_key=BATCHER_KEY_PAIR.public_key):
"""Will unmake_item a transaction or payload, and return a message.
Validation of signatures will occur if public keys are provided.
Only used for testing purposes.
"""
if isinstance(batch_object, transaction_pb2.Transaction):
header = transaction_pb2.TransactionHeader()
header.ParseFromString(batch_object.header)
assert header.payload_sha512 == sha512(
batch_object.payload).hexdigest()
if signer_public_key:
assert header.signer_public_key == signer_public_key
signer = Key(public_key=signer_public_key)
signer.verify(signature=batch_object.header_signature,
message=batch_object.header)
payload = RBACPayload()
payload.ParseFromString(batch_object.payload)
batch_object = payload
if isinstance(batch_object, RBACPayload):
_, message, _, _ = unmake_payload(payload=batch_object)
return message
raise Exception("unmake doesn't handle type {}\n{}".format(
type(batch_object), batch_object))
def assertValidPayload(self, payload, message, message_type):
if isinstance(payload, bytes):
decoded = RBACPayload()
decoded.ParseFromString(payload)
payload = decoded
self.assertIsInstance(payload, RBACPayload)
if message_type == RBACPayload.CREATE_USER:
self.assertIsInstance(message, user_transaction_pb2.CreateUser)
self.assertEqual(message_type, RBACPayload.CREATE_USER)
decoded = user_transaction_pb2.CreateUser()
decoded.ParseFromString(payload.content)
self.assertEqual(decoded, message)
self.assertEqual(decoded.name, message.name)
else:
raise Exception(
"assertValidPayload doesn't yet support {}".format(message_type)
)
def assertValidPayload(self, payload, message, message_type):
"""Check a payload the valid representation of a message given its type"""
if isinstance(payload, bytes):
decoded = RBACPayload()
decoded.ParseFromString(payload)
payload = decoded
self.assertIsInstance(payload, RBACPayload)
if message_type == RBACPayload.CREATE_USER:
self.assertIsInstance(message, user_transaction_pb2.CreateUser)
self.assertEqual(message_type, RBACPayload.CREATE_USER)
decoded = user_transaction_pb2.CreateUser()
decoded.ParseFromString(payload.content)
self.assertEqual(decoded, message)
self.assertEqual(decoded.name, message.name)
else:
raise Exception(
"BatchAssertions.assertValidPayload doesn't support message_type {}"
.format(message_type))
def apply(self, transaction, context):
"""Main entry point for the Sawtooth Transaction Processor
Transactions get submitted to this required interface method"""
try:
payload = RBACPayload()
payload.ParseFromString(transaction.payload)
return handle_message(header=transaction.header,
payload=payload,
context=context)
except ValueError as err:
raise InvalidTransaction(err)
except Exception as err: # pylint: disable=broad-except
LOGGER.exception("Unexpected processor error %s", err)
raise InvalidTransaction(err)
def apply(self, transaction, state):
try:
payload = RBACPayload()
payload.ParseFromString(transaction.payload)
if self._processor.has_message_handler(
message_type=payload.message_type):
return self._processor.handle_message(
header=transaction.header, payload=payload, context=state)
except (ValueError, KeyError) as err:
raise InvalidTransaction(err)
except Exception as err: # pylint: disable=broad-except
LOGGER.exception("Unexpected processor %s exception", type(err))
LOGGER.exception(err)
raise InvalidTransaction(err)
if payload.message_type in CREATE:
apply_create(transaction.header, payload, state)
elif payload.message_type in USER_PROPOSE:
apply_user_propose(transaction.header, payload, state)
elif payload.message_type in USER_CONFIRM:
apply_user_confirm(transaction.header, payload, state)
elif payload.message_type in USER_REJECT:
apply_user_reject(transaction.header, payload, state)
elif payload.message_type in ROLE_PROPOSE:
apply_role_propose(transaction.header, payload, state)
elif payload.message_type in ROLE_CONFIRM:
apply_role_confirm(transaction.header, payload, state)
elif payload.message_type in ROLE_REJECT:
apply_role_reject(transaction.header, payload, state)
elif payload.message_type in TASK_PROPOSE:
apply_task_propose(transaction.header, payload, state)
elif payload.message_type in TASK_CONFIRM:
apply_task_confirm(transaction.header, payload, state)
elif payload.message_type in TASK_REJECT:
apply_task_reject(transaction.header, payload, state)
else:
raise InvalidTransaction("Message type unknown.")
def apply(self, transaction, state):
payload = RBACPayload()
payload.ParseFromString(transaction.payload)
if payload.message_type in CREATE:
apply_create(transaction.header, payload, state)
elif payload.message_type in USER_PROPOSE:
apply_user_propose(transaction.header, payload, state)
elif payload.message_type in USER_CONFIRM:
apply_user_confirm(transaction.header, payload, state)
elif payload.message_type in USER_REJECT:
apply_user_reject(transaction.header, payload, state)
elif payload.message_type in ROLE_PROPOSE:
apply_role_propose(transaction.header, payload, state)
elif payload.message_type in ROLE_CONFIRM:
apply_role_confirm(transaction.header, payload, state)
elif payload.message_type in ROLE_REJECT:
apply_role_reject(transaction.header, payload, state)
elif payload.message_type in TASK_PROPOSE:
apply_task_propose(transaction.header, payload, state)
elif payload.message_type in TASK_CONFIRM:
apply_task_confirm(transaction.header, payload, state)
elif payload.message_type in TASK_REJECT:
apply_task_reject(transaction.header, payload, state)
else:
raise InvalidTransaction("Message type unknown.")
