def enact(self, network_middleware, publish=True) -> dict:
"""
Assign kfrags to ursulas_on_network, and distribute them via REST,
populating enacted_arrangements
"""
for arrangement in self.__assign_kfrags():
policy_message_kit = arrangement.encrypt_payload_for_ursula()
response = network_middleware.enact_policy(arrangement.ursula,
arrangement.id,
policy_message_kit.to_bytes())
if not response:
pass # TODO: Parse response for confirmation.
# Assuming response is what we hope for.
self.treasure_map.add_arrangement(arrangement)
else: # ...After *all* the policies are enacted
# Create Alice's revocation kit
self.revocation_kit = RevocationKit(self, self.alice.stamp)
self.alice.add_active_policy(self)
if publish is True:
return self.publish(network_middleware=network_middleware)
def enact(
self,
network_middleware: RestMiddleware,
handpicked_ursulas: Optional[Iterable[Ursula]] = None,
publish_treasure_map: bool = True,
) -> 'EnactedPolicy':
"""
Attempts to enact the policy, returns an `EnactedPolicy` object on success.
"""
arrangements = self._make_arrangements(
network_middleware=network_middleware,
handpicked_ursulas=handpicked_ursulas)
self._enact_arrangements(network_middleware=network_middleware,
arrangements=arrangements,
publish_treasure_map=publish_treasure_map)
treasure_map = self._make_treasure_map(
network_middleware=network_middleware, arrangements=arrangements)
treasure_map_publisher = self._make_publisher(
treasure_map=treasure_map, network_middleware=network_middleware)
revocation_kit = RevocationKit(treasure_map, self.alice.stamp)
enacted_policy = EnactedPolicy(self._id, self.hrac, self.label,
self.public_key, treasure_map,
treasure_map_publisher, revocation_kit,
self.alice.stamp)
if publish_treasure_map is True:
enacted_policy.publish_treasure_map()
return enacted_policy
def enact(self, network_middleware, publish_treasure_map=True) -> dict:
"""
Assign kfrags to ursulas_on_network, and distribute them via REST,
populating enacted_arrangements
"""
for arrangement in self.__assign_kfrags():
arrangement_message_kit = arrangement.encrypt_payload_for_ursula()
try:
# TODO: Concurrency
response = network_middleware.enact_policy(
arrangement.ursula, arrangement.id,
arrangement_message_kit.to_bytes())
except network_middleware.UnexpectedResponse as e:
arrangement.status = e.status
else:
arrangement.status = response.status_code
# TODO: Handle problem here - if the arrangement is bad, deal with it.
self.treasure_map.add_arrangement(arrangement)
else:
# OK, let's check: if two or more Ursulas claimed we didn't pay,
# we need to re-evaulate our situation here.
arrangement_statuses = [
a.status for a in self._accepted_arrangements
]
number_of_claims_of_freeloading = sum(
status == 402 for status in arrangement_statuses)
if number_of_claims_of_freeloading > 2:
raise self.alice.NotEnoughNodes # TODO: Clean this up and enable re-tries.
self.treasure_map.check_for_sufficient_destinations()
# TODO: Leave a note to try any failures later.
pass
# ...After *all* the arrangements are enacted
# Create Alice's revocation kit
self.revocation_kit = RevocationKit(self, self.alice.stamp)
self.alice.add_active_policy(self)
if publish_treasure_map is True:
return self.publish_treasure_map(
network_middleware=network_middleware
) # TODO: blockchain_signer?
