def connect_to_blockchain(configuration, recompile_contracts: bool = False):
try:
configuration.connect_to_blockchain(
recompile_contracts=recompile_contracts)
configuration.connect_to_contracts()
except EthereumContractRegistry.NoRegistry:
message = "Cannot configure blockchain character: No contract registry found; " \
"Did you mean to pass --federated-only?"
raise EthereumContractRegistry.NoRegistry(message)
def connect_to_blockchain(self, character_configuration, recompile_contracts: bool = False):
try:
character_configuration.connect_to_blockchain(recompile_contracts=recompile_contracts)
character_configuration.connect_to_contracts()
except EthereumContractRegistry.NoRegistry:
message = "No contract registry found; Did you mean to pass --federated-only?"
raise EthereumContractRegistry.NoRegistry(message)
else:
self.blockchain = character_configuration.blockchain
self.accounts = self.blockchain.interface.w3.eth.accounts
def ursula(
click_config,
action,
debug,
dev,
quiet,
dry_run,
force,
lonely,
network,
teacher_uri,
min_stake,
rest_host,
rest_port,
db_filepath,
checksum_address,
federated_only,
poa,
config_root,
config_file,
metadata_dir, # TODO: Start nodes from an additional existing metadata dir
provider_uri,
no_registry,
registry_filepath) -> None:
"""
Manage and run an "Ursula" PRE node.
\b
Actions
-------------------------------------------------
\b
run Run an "Ursula" node.
init Create a new Ursula node configuration.
view View the Ursula node's configuration.
forget Forget all known nodes.
save-metadata Manually write node metadata to disk without running
destroy Delete Ursula node configuration.
"""
#
# Boring Setup Stuff
#
if not quiet:
click.secho(URSULA_BANNER)
log = Logger('ursula.cli')
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
globalLogPublisher.removeObserver(logToSentry) # Sentry
GlobalConsoleLogger.set_log_level("debug")
elif quiet:
globalLogPublisher.removeObserver(logToSentry)
globalLogPublisher.removeObserver(SimpleObserver)
globalLogPublisher.removeObserver(getJsonFileObserver())
#
# Pre-Launch Warnings
#
if not quiet:
if dev:
click.secho("WARNING: Running in development mode", fg='yellow')
if force:
click.secho("WARNING: Force is enabled", fg='yellow')
#
# Unauthenticated Configurations
#
if action == "init":
"""Create a brand-new persistent Ursula"""
if dev and not quiet:
click.secho("WARNING: Using temporary storage area", fg='yellow')
if not config_root: # Flag
config_root = click_config.config_file # Envvar
if not rest_host:
rest_host = click.prompt(
"Enter Ursula's public-facing IPv4 address")
ursula_config = UrsulaConfiguration.generate(
password=click_config.get_password(confirm=True),
config_root=config_root,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath,
domains={network} if network else None,
federated_only=federated_only,
checksum_public_address=checksum_address,
no_registry=federated_only or no_registry,
registry_filepath=registry_filepath,
provider_uri=provider_uri,
poa=poa)
if not quiet:
click.secho("Generated keyring {}".format(
ursula_config.keyring_dir),
fg='green')
click.secho("Saved configuration file {}".format(
ursula_config.config_file_location),
fg='green')
# Give the use a suggestion as to what to do next...
how_to_run_message = "\nTo run an Ursula node from the default configuration filepath run: \n\n'{}'\n"
suggested_command = 'nucypher ursula run'
if config_root is not None:
config_file_location = os.path.join(
config_root, config_file
or UrsulaConfiguration.CONFIG_FILENAME)
suggested_command += ' --config-file {}'.format(
config_file_location)
click.secho(how_to_run_message.format(suggested_command),
fg='green')
return # FIN
else:
click.secho("OK")
elif action == "destroy":
"""Delete all configuration files from the disk"""
if dev:
message = "'nucypher ursula destroy' cannot be used in --dev mode"
raise click.BadOptionUsage(option_name='--dev', message=message)
destroy_system_configuration(config_class=UrsulaConfiguration,
config_file=config_file,
network=network,
config_root=config_root,
force=force,
log=log)
if not quiet:
click.secho("Destroyed {}".format(config_root))
return
# Development Configuration
if dev:
ursula_config = UrsulaConfiguration(
dev_mode=True,
domains={TEMPORARY_DOMAIN},
poa=poa,
registry_filepath=registry_filepath,
provider_uri=provider_uri,
checksum_public_address=checksum_address,
federated_only=federated_only,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath)
# Authenticated Configurations
else:
# Deserialize network domain name if override passed
if network:
domain_constant = getattr(constants, network.upper())
domains = {domain_constant}
else:
domains = None
ursula_config = UrsulaConfiguration.from_configuration_file(
filepath=config_file,
domains=domains,
registry_filepath=registry_filepath,
provider_uri=provider_uri,
rest_host=rest_host,
rest_port=rest_port,
db_filepath=db_filepath,
# TODO: Handle Boolean overrides
# poa=poa,
# federated_only=federated_only,
)
try: # Unlock Keyring
if not quiet:
click.secho('Decrypting keyring...', fg='blue')
ursula_config.keyring.unlock(password=click_config.get_password()
) # Takes ~3 seconds, ~1GB Ram
except CryptoError:
raise ursula_config.keyring.AuthenticationFailed
if not ursula_config.federated_only:
try:
ursula_config.connect_to_blockchain(recompile_contracts=False)
ursula_config.connect_to_contracts()
except EthereumContractRegistry.NoRegistry:
message = "Cannot configure blockchain character: No contract registry found; " \
"Did you mean to pass --federated-only?"
raise EthereumContractRegistry.NoRegistry(message)
click_config.ursula_config = ursula_config # Pass Ursula's config onto staking sub-command
#
# Launch Warnings
#
if not quiet:
if ursula_config.federated_only:
click.secho("WARNING: Running in Federated mode", fg='yellow')
#
# Action Switch
#
if action == 'run':
"""Seed, Produce, Run!"""
#
# Seed - Step 1
#
teacher_nodes = list()
if teacher_uri:
node = Ursula.from_teacher_uri(
teacher_uri=teacher_uri,
min_stake=min_stake,
federated_only=ursula_config.federated_only)
teacher_nodes.append(node)
#
# Produce - Step 2
#
ursula = ursula_config(known_nodes=teacher_nodes, lonely=lonely)
# GO!
try:
#
# Run - Step 3
#
click.secho("Connecting to {}".format(','.join(
str(d) for d in ursula_config.domains)),
fg='blue',
bold=True)
click.secho("Running Ursula {} on {}".format(
ursula, ursula.rest_interface),
fg='green',
bold=True)
if not debug:
stdio.StandardIO(UrsulaCommandProtocol(ursula=ursula))
if dry_run:
# That's all folks!
return
ursula.get_deployer().run() # <--- Blocking Call (Reactor)
except Exception as e:
ursula_config.log.critical(str(e))
click.secho("{} {}".format(e.__class__.__name__, str(e)), fg='red')
raise # Crash :-(
finally:
if not quiet:
click.secho("Stopping Ursula")
ursula_config.cleanup()
if not quiet:
click.secho("Ursula Stopped", fg='red')
return
elif action == "save-metadata":
"""Manually save a node self-metadata file"""
ursula = ursula_config.produce(ursula_config=ursula_config)
metadata_path = ursula.write_node_metadata(node=ursula)
if not quiet:
click.secho("Successfully saved node metadata to {}.".format(
metadata_path),
fg='green')
return
elif action == "view":
"""Paint an existing configuration to the console"""
paint_configuration(
config_filepath=config_file or ursula_config.config_file_location)
return
elif action == "forget":
"""Forget all known nodes via storages"""
click.confirm("Permanently delete all known node data?", abort=True)
ursula_config.forget_nodes()
message = "Removed all stored node node metadata and certificates"
click.secho(message=message, fg='red')
return
else:
raise click.BadArgumentUsage("No such argument {}".format(action))