def crawl( general_config, teacher_uri, registry_filepath, min_stake, network, learn_on_launch, provider_uri, influx_host, influx_port, http_port, dry_run, eager, poa, ): """ Gather NuCypher network information. """ # Banner emitter = general_config.emitter emitter.clear() emitter.banner(MONITOR_BANNER.format(CRAWLER)) # Setup BlockchainInterfaceFactory.initialize_interface(provider_uri=provider_uri, poa=poa) registry = _get_registry(registry_filepath, network) # Teacher Ursula teacher_uris = [teacher_uri] if teacher_uri else None teacher_nodes = actions.load_seednodes( emitter, teacher_uris=teacher_uris, min_stake=min_stake, federated_only=False, network_domains={network} if network else None, network_middleware=RestMiddleware()) crawler = Crawler(domains={network} if network else None, network_middleware=RestMiddleware(), known_nodes=teacher_nodes, registry=registry, start_learning_now=eager, learn_on_same_thread=learn_on_launch, influx_host=influx_host, influx_port=influx_port) emitter.message(f"Network: {network.capitalize()}", color='blue') emitter.message(f"InfluxDB: {influx_host}:{influx_port}", color='blue') emitter.message(f"Provider: {provider_uri}", color='blue') emitter.message(f"Refresh Rate: {crawler._refresh_rate}s", color='blue') message = f"Running Nucypher Crawler JSON endpoint at http://localhost:{http_port}/stats" emitter.message(message, color='green', bold=True) if not dry_run: crawler.start(eager=eager) reactor.run()
def from_seed_and_stake_info(cls, host, certificates_directory, federated_only, port=9151, checksum_address=None, minimum_stake=0, network_middleware=None, *args, **kwargs ): if network_middleware is None: network_middleware = RestMiddleware() certificate = network_middleware.get_certificate(host=host, port=port) real_host = certificate.subject.get_attributes_for_oid(NameOID.COMMON_NAME)[0].value # Write certificate; this is really only for temporary purposes. Ideally, we'd use # it in-memory here but there's no obvious way to do that. filename = '{}.{}'.format(checksum_address, Encoding.PEM.name.lower()) certificate_filepath = os.path.join(certificates_directory, filename) _write_tls_certificate(certificate=certificate, full_filepath=certificate_filepath, force=True) cls.log.info("Saved seednode {} TLS certificate".format(checksum_address)) potential_seed_node = cls.from_rest_url( host=real_host, port=port, network_middleware=network_middleware, certificate_filepath=certificate_filepath, federated_only=True, *args, **kwargs) # TODO: 466 if checksum_address: if not checksum_address == potential_seed_node.checksum_public_address: raise potential_seed_node.SuspiciousActivity( "This seed node has a different wallet address: {} (was hoping for {}). Are you sure this is a seed node?".format( potential_seed_node.checksum_public_address, checksum_address)) else: if minimum_stake > 0: # TODO: check the blockchain to verify that address has more then minimum_stake. #511 raise NotImplementedError("Stake checking is not implemented yet.") try: potential_seed_node.verify_node( network_middleware=network_middleware, accept_federated_only=federated_only, certificate_filepath=certificate_filepath) except potential_seed_node.InvalidNode: raise # TODO: What if our seed node fails verification? return potential_seed_node
def crawl(click_config, teacher_uri, registry_filepath, min_stake, network, learn_on_launch, provider_uri, influx_host, influx_port, dry_run): """ Gather NuCypher network information. """ # Banner emitter = click_config.emitter emitter.clear() emitter.banner(MONITOR_BANNER.format(CRAWLER)) registry = _get_registry(provider_uri, registry_filepath) # Teacher Ursula teacher_uris = [teacher_uri] if teacher_uri else None teacher_nodes = actions.load_seednodes( emitter, teacher_uris=teacher_uris, min_stake=min_stake, federated_only=False, network_domains={network} if network else None, network_middleware=click_config.middleware) # Configure Storage crawler = Crawler(domains={network} if network else None, network_middleware=RestMiddleware(), known_nodes=teacher_nodes, registry=registry, start_learning_now=True, learn_on_same_thread=learn_on_launch, blockchain_db_host=influx_host, blockchain_db_port=influx_port) if not dry_run: crawler.start() reactor.run()
def test_get_cert_from_running_seed_node(ursula_federated_test_config): lonely_ursula_maker = partial(make_federated_ursulas, ursula_config=ursula_federated_test_config, quantity=1, know_each_other=False) firstula = lonely_ursula_maker().pop() node_deployer = firstula.get_deployer() node_deployer.addServices() node_deployer.catalogServers(node_deployer.hendrix) node_deployer.start() certificate_as_deployed = node_deployer.cert.to_cryptography() firstula_as_seed_node = firstula.seed_node_metadata() any_other_ursula = lonely_ursula_maker( seed_nodes=[firstula_as_seed_node], network_middleware=RestMiddleware()).pop() assert not any_other_ursula.known_nodes def start_lonely_learning_loop(): any_other_ursula.start_learning_loop() start = maya.now() while not firstula in any_other_ursula.known_nodes.values(): passed = maya.now() - start if passed.seconds > 2: pytest.fail("Didn't find the seed node.") yield deferToThread(start_lonely_learning_loop) assert firstula in any_other_ursula.known_nodes.values() certificate_as_learned = list( any_other_ursula.known_nodes.values())[0].certificate assert certificate_as_learned == certificate_as_deployed any_other_ursula.stop_learning_loop()
def nucypher_cli(click_config, verbose, mock_networking, json_ipc, no_logs, quiet, debug, no_registry, log_level): # Session Emitter for pre and post character control engagement. if json_ipc: emitter = JSONRPCStdoutEmitter( quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout) else: emitter = StdoutEmitter( quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout) click_config.attach_emitter(emitter) if not json_ipc: click_config.emit(message=NUCYPHER_BANNER) if log_level: GlobalConsoleLogger.set_log_level(log_level_name=log_level) globalLogPublisher.addObserver(SimpleObserver()) if debug and quiet: raise click.BadOptionUsage( option_name="quiet", message="--debug and --quiet cannot be used at the same time.") if debug: click_config.log_to_sentry = False click_config.log_to_file = True # File Logging globalLogPublisher.addObserver(SimpleObserver()) # Console Logging globalLogPublisher.removeObserver(logToSentry) # No Sentry GlobalConsoleLogger.set_log_level(log_level_name='debug') elif quiet: # Disable Logging globalLogPublisher.removeObserver(logToSentry) globalLogPublisher.removeObserver(SimpleObserver) globalLogPublisher.removeObserver(getJsonFileObserver()) # Logging if not no_logs: GlobalConsoleLogger.start_if_not_started() # CLI Session Configuration click_config.verbose = verbose click_config.mock_networking = mock_networking click_config.json_ipc = json_ipc click_config.no_logs = no_logs click_config.quiet = quiet click_config.no_registry = no_registry click_config.debug = debug # Only used for testing outputs; # Redirects outputs to in-memory python containers. if mock_networking: click_config.emit(message="WARNING: Mock networking is enabled") click_config.middleware = MockRestMiddleware() else: click_config.middleware = RestMiddleware() # Global Warnings if click_config.verbose: click_config.emit(message="Verbose mode is enabled", color='blue')
def moe(click_config, teacher_uri, min_stake, network, ws_port, dry_run, http_port, learn_on_launch): """ "Moe" NuCypher node monitor CLI. """ if not click_config.json_ipc and not click_config.quiet: click.secho(MOE_BANNER) # Teacher Ursula teacher_uris = [teacher_uri] if teacher_uri else list() teacher_nodes = actions.load_seednodes(teacher_uris=teacher_uris, min_stake=min_stake, federated_only=True, # TODO: hardcoded for now network_middleware=click_config.middleware) # Deserialize network domain name if override passed if network: domain_constant = getattr(constants, network.upper()) domains = {domain_constant} else: domains = None monitor = Moe( domains=domains, network_middleware=RestMiddleware(), known_nodes=teacher_nodes, federated_only=True) monitor.start_learning_loop(now=learn_on_launch) monitor.start(http_port=http_port, ws_port=ws_port, dry_run=dry_run)
def _propose_arrangement( self, address: ChecksumAddress, network_middleware: RestMiddleware, ) -> Tuple[Ursula, Arrangement]: """ Attempt to propose an arrangement to the node with the given address. """ if address not in self.alice.known_nodes: raise RuntimeError(f"{address} is not known") ursula = self.alice.known_nodes[address] arrangement = Arrangement.from_alice(alice=self.alice, expiration=self.expiration) self.log.debug(f"Proposing arrangement {arrangement} to {ursula}") negotiation_response = network_middleware.propose_arrangement( ursula, arrangement) status = negotiation_response.status_code if status == 200: self.log.debug(f"Arrangement accepted by {ursula}") else: message = f"Proposing arrangement to {ursula} failed with {status}" self.log.debug(message) raise RuntimeError(message) # We could just return the arrangement and get the Ursula object # from `known_nodes` later, but when we introduce slashing in FleetSensor, # the address can already disappear from `known_nodes` by that time. return (ursula, arrangement)
def publish_treasure_map(self, network_middleware: RestMiddleware) -> dict: self.treasure_map.prepare_for_publication(self.bob.public_keys(DecryptingPower), self.bob.public_keys(SigningPower), self.alice.stamp, self.label) if not self.alice.known_nodes: # TODO: Optionally, block. raise RuntimeError("Alice hasn't learned of any nodes. Thus, she can't push the TreasureMap.") responses = dict() for node in self.alice.known_nodes: # TODO: # 342 - It's way overkill to push this to every node we know about. Come up with a system. try: treasure_map_id = self.treasure_map.public_id() # TODO: Certificate filepath needs to be looked up and passed here response = network_middleware.put_treasure_map_on_node(node=node, map_id=treasure_map_id, map_payload=bytes(self.treasure_map)) except NodeSeemsToBeDown: # TODO: Introduce good failure mode here if too few nodes receive the map. continue if response.status_code == 202: # TODO: #341 - Handle response wherein node already had a copy of this TreasureMap. responses[node] = response else: # TODO: Do something useful here. raise RuntimeError return responses
def test_get_cert_from_running_seed_node(lonely_ursula_maker): firstula = lonely_ursula_maker().pop() node_deployer = firstula.get_deployer() node_deployer.addServices() node_deployer.catalogServers(node_deployer.hendrix) node_deployer.start( ) # If this port happens not to be open, we'll get an error here. THis might be one of the few sane places to reintroduce a check. certificate_as_deployed = node_deployer.cert.to_cryptography() firstula_as_seed_node = firstula.seed_node_metadata() any_other_ursula = lonely_ursula_maker( seed_nodes=[firstula_as_seed_node], network_middleware=RestMiddleware()).pop() assert not any_other_ursula.known_nodes yield deferToThread(any_other_ursula.load_seednodes) assert firstula in any_other_ursula.known_nodes firstula_as_learned = any_other_ursula.known_nodes[ firstula.checksum_address] firstula_as_learned.mature() assert certificate_as_deployed == firstula_as_learned.certificate
def initialize_bob(bob_privkeys): ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URI, federated_only=True, minimum_stake=0) TEMP_DOCTOR_DIR = "{}/listener-files".format( os.path.dirname(os.path.abspath(__file__))) # Remove previous demo files and create new ones shutil.rmtree(TEMP_DOCTOR_DIR, ignore_errors=True) bob_enc_keypair = DecryptingKeypair(private_key=bob_privkeys["enc"]) bob_sig_keypair = SigningKeypair(private_key=bob_privkeys["sig"]) enc_power = DecryptingPower(keypair=bob_enc_keypair) sig_power = SigningPower(keypair=bob_sig_keypair) power_ups = [enc_power, sig_power] print("Creating the Listener ...") listener = Bob( domains={TEMPORARY_DOMAIN}, federated_only=True, crypto_power_ups=power_ups, start_learning_now=True, abort_on_learning_error=True, known_nodes=[ursula], save_metadata=False, network_middleware=RestMiddleware(), ) print("Listener = ", listener) return listener
def mock_node_information_endpoint(middleware, port, *args, **kwargs): ursula_were_looking_for = ursula.rest_interface.port == port if ursula_were_looking_for: raise RestMiddleware.NotFound("Fake Reason") # Make this node unreachable else: response = Response(response=bytes(ursula), mimetype='application/octet-stream') return response
def publish_treasure_map(self, network_middleware: RestMiddleware) -> dict: self.treasure_map.prepare_for_publication(self.bob.public_keys(DecryptingPower), self.bob.public_keys(SigningPower), self.alice.stamp, self.label ) if not self.alice.known_nodes: # TODO: Optionally block. raise RuntimeError("Alice hasn't learned of any nodes. Thus, she can't push the TreasureMap.") responses = dict() for node in self.alice.known_nodes: # TODO: It's way overkill to push this to every node we know about. Come up with a system. 342 response = network_middleware.put_treasure_map_on_node(node, self.treasure_map.public_id(), bytes(self.treasure_map) ) # TODO: Certificate filepath needs to be looked up and passed here if response.status_code == 202: responses[node] = response # TODO: Handle response wherein node already had a copy of this TreasureMap. 341 else: # TODO: Do something useful here. raise RuntimeError return responses
def moe(click_config, teacher_uri, min_stake, network, ws_port, dry_run, http_port, learn_on_launch): """ "Moe the Monitor" management commands. """ emitter = click_config.emitter # Banner emitter.clear() emitter.banner(MOE_BANNER) # Teacher Ursula teacher_uris = [teacher_uri] if teacher_uri else None teacher_nodes = actions.load_seednodes(emitter, teacher_uris=teacher_uris, min_stake=min_stake, federated_only=True, # TODO: hardcoded for now. Is Moe a Character? network_domains={network} if network else None, network_middleware=click_config.middleware) # Make Moe MOE = Moe(domains={network} if network else None, network_middleware=RestMiddleware(), known_nodes=teacher_nodes, federated_only=True) # Run MOE.start_learning_loop(now=learn_on_launch) emitter.message(f"Running Moe on 127.0.0.1:{http_port}") MOE.start(http_port=http_port, ws_port=ws_port, dry_run=dry_run)
def process_middleware(mock_networking): if mock_networking: middleware = MockRestMiddleware() else: middleware = RestMiddleware() return 'middleware', middleware
def act_as_bob(self, name): print("act_as_bob") dirname = "accounts/" + name + "/" fname = dirname+"recipent.private.json" with open(fname) as data_file: data = json.load(data_file) enc_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["enc"])) sig_privkey = UmbralPrivateKey.from_bytes(bytes.fromhex(data["sig"])) bob_enc_keypair = DecryptingKeypair(private_key=enc_privkey) bob_sig_keypair = SigningKeypair(private_key=sig_privkey) enc_power = DecryptingPower(keypair=bob_enc_keypair) sig_power = SigningPower(keypair=bob_sig_keypair) power_ups = [enc_power, sig_power] bob = Bob( is_me=True, federated_only=True, crypto_power_ups=power_ups, start_learning_now=True, abort_on_learning_error=True, known_nodes=[self.ursula], save_metadata=False, network_middleware=RestMiddleware(), ) return bob
def create_crawler(node_db_filepath: str = IN_MEMORY_FILEPATH, dont_set_teacher: bool = False): registry = InMemoryContractRegistry() middleware = RestMiddleware() teacher_nodes = None if not dont_set_teacher: teacher_nodes = actions.load_seednodes( None, # TODO: Needs emitter teacher_uris=[DEFAULT_TEACHER], # TODO: Needs Cleanup min_stake=0, federated_only=False, network_domains={'gemini'}, # TODO: Needs Cleanup network_middleware=middleware) crawler = Crawler( domains={'goerli'}, # TODO: Needs Cleanup network_middleware=middleware, known_nodes=teacher_nodes, registry=registry, start_learning_now=True, learn_on_same_thread=False, influx_host='localhost', # TODO: Needs Cleanup influx_port=8086, # TODO: Needs Cleanup node_storage_filepath=node_db_filepath) return crawler
def configure_alice(self, path): return AliceConfiguration( config_root=os.path.join(path), known_nodes=[self.ursula, self.ursula2, self.ursula3], start_learning_now=False, federated_only=True, learn_on_same_thread=True, network_middleware=RestMiddleware(), )
def process_middleware(mock_networking): from nucypher.network.middleware import RestMiddleware from nucypher.utilities.sandbox.middleware import MockRestMiddleware if mock_networking: middleware = MockRestMiddleware() else: middleware = RestMiddleware() return 'middleware', middleware
def from_rest_url(cls, network_middleware: RestMiddleware, host: str, port: int, federated_only: bool = False) -> 'Ursula': response = network_middleware.node_information(host, port) if not response.status_code == 200: raise RuntimeError("Got a bad response: {}".format(response)) stranger_ursula_from_public_keys = cls.from_bytes(response.content, federated_only=federated_only) return stranger_ursula_from_public_keys
def create_policy(self, label: bytes, alice_privkey: UmbralPrivateKey, bob_pubkey: UmbralPublicKey, policy_expiration, m: int, n: int): """ Create a Policy with Alice granting Bob access to `label` DataSource :param label: A label to represent the policies data :param alice_privkey: Alice's private key :param bob_pubkey: Bob's public key :param policy_expiration: Datetime of policy expiration duration :param m: Minimum number of KFrags needed to rebuild ciphertext :param n: Total number of rekey shares to generate :return: The policy granted to Bob """ # This is not how this should be implemented, but I am still figuring out # the keying material and why it is randomly generated when a character is # initialized, instead of being derived from the keys like the other powers # or explained how it should be stored. d = DelegatingPower() d.umbral_keying_material = UmbralKeyingMaterial.from_bytes( alice_privkey.to_bytes() + alice_privkey.get_pubkey().to_bytes()) # Initialize Alice ALICE = Alice( crypto_power_ups=[ SigningPower(keypair=SigningKeypair(alice_privkey)), EncryptingPower(keypair=EncryptingKeypair(alice_privkey)), # DelegatingPower d ], network_middleware=RestMiddleware(), known_nodes=(self.ursula, ), federated_only=True, always_be_learning=True) # Initialize Bob BOB = Bob(crypto_power_ups=[ SigningPower(pubkey=bob_pubkey), EncryptingPower(pubkey=bob_pubkey) ], known_nodes=(self.ursula, ), federated_only=True, always_be_learning=True) # Alice grants a policy for Bob policy = ALICE.grant(BOB, label, m=m, n=n, expiration=policy_expiration) return policy
def create_crawler(node_db_filepath: str = IN_MEMORY_FILEPATH): registry = InMemoryContractRegistry() middleware = RestMiddleware() crawler = Crawler(domain='ibex', # TODO: Needs Cleanup network_middleware=middleware, registry=registry, start_learning_now=True, learn_on_same_thread=False, influx_host='localhost', # TODO: Needs Cleanup influx_port=8086, # TODO: Needs Cleanup node_storage_filepath=node_db_filepath ) return crawler
def generate_owner_policy_public_key(self, max_days): self.ursula = Ursula.from_seed_and_stake_info( seed_uri=self.URSULA_SEEDNODE_URI, federated_only=True, minimum_stake=0) policy_end_datetime = maya.now() + datetime.timedelta(days=max_days) self.ALICE = Alice(network_middleware=RestMiddleware(), known_nodes=[self.ursula], learn_on_same_thread=True, federated_only=True) policy_pubkey = self.ALICE.get_policy_pubkey_from_label(self.label) return policy_pubkey
def from_rest_url(cls, network_middleware: RestMiddleware, host: str, port: int, certificate_filepath, federated_only: bool = False, *args, **kwargs ): response_data = network_middleware.node_information(host, port, certificate_filepath=certificate_filepath) stranger_ursula_from_public_keys = cls.from_bytes(response_data, federated_only=federated_only, *args, **kwargs) return stranger_ursula_from_public_keys
def _ping_node(self, address: ChecksumAddress, network_middleware: RestMiddleware) -> 'Ursula': # Handles edge case when provided address is not a known peer. if address not in self.publisher.known_nodes: raise RuntimeError(f"{address} is not a known peer") ursula = self.publisher.known_nodes[address] response = network_middleware.ping(node=ursula) status_code = response.status_code if status_code == 200: return ursula else: raise RuntimeError( f"{ursula} is not available for selection ({status_code}).")
def process_middleware(mock_networking) -> tuple: ################# # MUST NOT RAISE! ################# try: from tests.utils.middleware import MockRestMiddleware except ImportError: # It's okay to not crash here despite not having the tests package available. logger = Logger("CLI-Middleware-Optional-Handler") logger.info('--mock-networking flag is unavailable without dev install.') if mock_networking: middleware = MockRestMiddleware() else: from nucypher.network.middleware import RestMiddleware middleware = RestMiddleware() return 'middleware', middleware
def generate_charlie(): shutil.rmtree(TEMP_CHARLIE_DIR, ignore_errors=True) ursula = Ursula.from_seed_and_stake_info(seed_uri=SEEDNODE_URL, federated_only=True, minimum_stake=0) # To create a Bob, we need the charlie's private keys previously generated. from charlie_keys import get_charlie_privkeys charlie_keys = get_charlie_privkeys() bob_enc_keypair = DecryptingKeypair(private_key=charlie_keys["enc"]) bob_sig_keypair = SigningKeypair(private_key=charlie_keys["sig"]) enc_power = DecryptingPower(keypair=bob_enc_keypair) sig_power = SigningPower(keypair=bob_sig_keypair) power_ups = [enc_power, sig_power] print("Creating the Charlie ...") charlie = Bob( is_me=True, federated_only=True, crypto_power_ups=power_ups, start_learning_now=True, abort_on_learning_error=True, known_nodes=[ursula], save_metadata=False, network_middleware=RestMiddleware(), ) print("Charlie = ", charlie) # Join policy generated by alice with open("policy-metadata.json", 'r') as f: policy_data = json.load(f) policy_pubkey = UmbralPublicKey.from_bytes( bytes.fromhex(policy_data["policy_pubkey"])) alices_sig_pubkey = UmbralPublicKey.from_bytes( bytes.fromhex(policy_data["alice_sig_pubkey"])) label = policy_data["label"].encode() print("The Charlie joins policy for label '{}'".format( label.decode("utf-8"))) charlie.join_policy(label, alices_sig_pubkey) return charlie, policy_pubkey, alices_sig_pubkey, label
def downloadFile(self, username, receipt, policy_info): hash = receipt['hash_key'] input = self.ipfs_gateway_api.cat(hash) enc_privkey, sig_privkey = self.reveal_private_keys(username) bob_enc_key = DecryptingKeypair(private_key=enc_privkey) bob_sig_keyp = SigningKeypair(private_key=sig_privkey) enc_power = DecryptingPower(keypair=bob_enc_key) sig_power = SigningPower(keypair=bob_sig_keyp) power_ups = [enc_power, sig_power] self.Bob = Bob( federated_only=True, crypto_power_ups=power_ups, start_learning_now=True, abort_on_learning_error=True, known_nodes=[self.ursula], save_metadata=False, network_middleware=RestMiddleware(), ) policy_pubkey = UmbralPublicKey.from_bytes(bytes.fromhex(policy_info["policy_pubkey"])) enrico = Enrico.from_public_keys( {SigningPower: UmbralPublicKey.from_bytes(bytes.fromhex(receipt['data_source_public_key']))}, policy_encrypting_key=policy_pubkey ) alice_pubkey_restored = UmbralPublicKey.from_bytes(base58.b58decode(policy_info['alice_sig_pubkey'])) self.Bob.join_policy(policy_info['label'].encode(), alice_pubkey_restored) data = msgpack.loads(input, raw=False) message_kits = (UmbralMessageKit.from_bytes(k) for k in data['kits']) message_kit = next(message_kits) retrieved_plaintexts = self.Bob.retrieve( message_kit, enrico=enrico, alice_verifying_key=alice_pubkey_restored, label=policy_info['label'].encode(), ) plaintext = msgpack.loads(retrieved_plaintexts[0], raw=False) print(plaintext) decrypted_data = plaintext['data'] return decrypted_data
def _get_alice(self): # Gets an Alice instance #print('Getting an Alice') try: # If we had an existing Alicia in disk, let's get it from there alice_config_file = os.path.join(self.TEMP_ALICE_DIR, "config_root", "alice.config") new_alice_config = AliceConfiguration.from_configuration_file( filepath=alice_config_file, known_nodes=[self.ursula], network_middleware=RestMiddleware(), start_learning_now=False, save_metadata=False, ) #new_alice_config.keyring.unlock(password=self.passphrase) alicia = new_alice_config.produce() except: # If anything fails, let's create Alicia from scratch # Remove previous demo files and create new ones #print("Creating ALICE") shutil.rmtree(self.TEMP_ALICE_DIR, ignore_errors=True) os.mkdir(self.TEMP_ALICE_DIR) os.mkdir(self.TEMP_ALICE_URSULA_DIR) alice_config = AliceConfiguration( config_root=os.path.join(self.TEMP_ALICE_DIR, "config_root"), is_me=True, known_nodes=[self.ursula], start_learning_now=False, federated_only=True, learn_on_same_thread=True, ) alice_config.initialize(password=self.passphrase) alice_config.keyring.unlock(password=self.passphrase) alicia = alice_config.produce() # We will save Alicia's config to a file for later use alice_config_file = alice_config.to_configuration_file() # Let's get to learn about the NuCypher network alicia.start_learning_loop(now=True) return alicia
def nucypher_cli(click_config, verbose, mock_networking, json_ipc, no_logs, quiet, debug, no_registry): # Session Emitter for pre and post character control engagement. if json_ipc: emitter = IPCStdoutEmitter(quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout) else: emitter = StdoutEmitter(quiet=quiet, capture_stdout=NucypherClickConfig.capture_stdout) NucypherClickConfig.emitter = emitter click_config.emitter(message=NUCYPHER_BANNER) # Logging if not no_logs: GlobalConsoleLogger.start_if_not_started() # CLI Session Configuration click_config.verbose = verbose click_config.mock_networking = mock_networking click_config.json_ipc = json_ipc click_config.no_logs = no_logs click_config.quiet = quiet click_config.no_registry = no_registry click_config.debug = debug # only used for testing outputs; # Redirects outputs to in-memory python containers. if mock_networking: click_config.emitter(message="WARNING: Mock networking is enabled") click_config.middleware = MockRestMiddleware() else: click_config.middleware = RestMiddleware() # Global Warnings if click_config.verbose: click_config.emitter("Verbose mode is enabled", color='blue')
def _get_bob(self, passphrase) -> object: ''' :param passphrase: Passpharse for new Bob instance :return: None ''' try: bob_config_file = os.path.join(self.TEMP_BOB_DIR, "config_root", "bob.config") bob_config = BobConfiguration.from_configuration_file( filepath=bob_config_file, network_middleware=RestMiddleware(), start_learning_now=False, save_metadata=False, ) bob_config.keyring.unlock(password=passphrase) bob = bob_config.produce() except: shutil.rmtree(self.TEMP_BOB_DIR, ignore_errors=True) os.mkdir(self.TEMP_BOB_DIR) bob_config = BobConfiguration( config_root=os.path.join(self.TEMP_BOB_DIR, "config_root"), is_me=True, known_nodes={self.ursula}, start_learning_now=True, federated_only=True, learn_on_same_thread=True, ) bob_config.initialize(password=passphrase) bob_config.keyring.unlock(password=passphrase) bob = bob_config.produce() bob_config_file = bob_config.to_configuration_file() return bob