def _add_node(self, node, lib_name, args, target_node=None):
forwarded_args = {
arg: getattr(args, arg) for arg in infra.ccf.Network.node_args_to_forward
}
# Contact primary if no target node is set
if target_node is None:
target_node, _ = self.find_primary()
node.join(
lib_name=lib_name,
workspace=args.workspace,
label=args.label,
target_rpc_address=f"{target_node.host}:{target_node.rpc_port}",
**forwarded_args,
)
# If the network is opening, node are trusted without consortium approval
if self.status == ServiceStatus.OPENING:
if args.consensus != "pbft":
try:
node.wait_for_node_to_join(timeout=JOIN_TIMEOUT)
except TimeoutError:
LOG.error(f"New node {node.node_id} failed to join the network")
raise
node.network_state = infra.node.NodeNetworkState.joined
def _add_node(
self,
node,
lib_name,
args,
target_node=None,
recovery=False,
from_snapshot=False,
snapshot_dir=None,
copy_ledger_read_only=False,
):
forwarded_args = {
arg: getattr(args, arg)
for arg in infra.network.Network.node_args_to_forward
}
# Contact primary if no target node is set
if target_node is None:
target_node, _ = self.find_primary(
timeout=args.ledger_recovery_timeout if recovery else 3)
LOG.info(f"Joining from target node {target_node.node_id}")
# Only retrieve snapshot from target node if the snapshot directory is not
# specified
if from_snapshot and snapshot_dir is None:
snapshot_dir = target_node.get_committed_snapshots()
assert (
len(os.listdir(snapshot_dir)) > 0
), f"There are no snapshots to resume from in directory {snapshot_dir}"
read_only_ledger_dirs = []
if snapshot_dir is not None:
LOG.info(f"Joining from snapshot: {snapshot_dir}")
if copy_ledger_read_only:
read_only_ledger_dirs = target_node.get_ledger(
include_read_only_dirs=True)
LOG.info(
f"Copying target node ledger to read-only ledger directory {read_only_ledger_dirs}"
)
node.join(
lib_name=lib_name,
workspace=args.workspace,
label=args.label,
common_dir=self.common_dir,
target_rpc_address=f"{target_node.host}:{target_node.rpc_port}",
snapshot_dir=snapshot_dir,
read_only_ledger_dirs=read_only_ledger_dirs,
**forwarded_args,
)
# If the network is opening, node are trusted without consortium approval
if self.status == ServiceStatus.OPENING:
try:
node.wait_for_node_to_join(timeout=JOIN_TIMEOUT)
except TimeoutError:
LOG.error(
f"New node {node.node_id} failed to join the network")
raise
node.network_state = infra.node.NodeNetworkState.joined
def _add_node(
self,
node,
lib_name,
args,
target_node=None,
recovery=False,
from_snapshot=False,
):
forwarded_args = {
arg: getattr(args, arg)
for arg in infra.network.Network.node_args_to_forward
}
# Contact primary if no target node is set
if target_node is None:
target_node, _ = self.find_primary(
timeout=args.ledger_recovery_timeout if recovery else 3)
snapshot_dir = None
if from_snapshot:
LOG.info("Joining from snapshot")
snapshot_dir = target_node.get_snapshots()
# For now, we must have a snapshot to resume from when attempting
# to join from one
assert (
len(os.listdir(snapshot_dir)) > 0
), f"There are no snapshots to resume from in directory {snapshot_dir}"
node.join(
lib_name=lib_name,
workspace=args.workspace,
label=args.label,
common_dir=self.common_dir,
target_rpc_address=f"{target_node.host}:{target_node.rpc_port}",
snapshot_dir=snapshot_dir,
**forwarded_args,
)
# If the network is opening, node are trusted without consortium approval
if self.status == ServiceStatus.OPENING:
try:
node.wait_for_node_to_join(timeout=JOIN_TIMEOUT)
except TimeoutError:
LOG.error(
f"New node {node.node_id} failed to join the network")
raise
node.network_state = infra.node.NodeNetworkState.joined
def trust_node(self,
node,
args,
valid_from=None,
validity_period_days=None,
no_wait=False):
primary, _ = self.find_primary()
try:
if self.status is ServiceStatus.OPEN:
valid_from = valid_from or str(
infra.crypto.datetime_to_X509time(datetime.now()))
self.consortium.trust_node(
primary,
node.node_id,
valid_from=valid_from,
validity_period_days=validity_period_days,
timeout=ceil(args.join_timer * 2 / 1000),
)
if not no_wait:
# Here, quote verification has already been run when the node
# was added as pending. Only wait for the join timer for the
# joining node to retrieve network secrets.
node.wait_for_node_to_join(timeout=ceil(args.join_timer * 2 /
1000))
except (ValueError, TimeoutError):
LOG.error(
f"New trusted node {node.node_id} failed to join the network")
node.stop()
raise
node.network_state = infra.node.NodeNetworkState.joined
node.set_certificate_validity_period(
valid_from, validity_period_days
or args.max_allowed_node_cert_validity_days)
if not no_wait:
self.wait_for_all_nodes_to_commit(primary=primary)
def _add_node(
self,
node,
lib_name,
args,
target_node=None,
recovery=False,
ledger_dir=None,
copy_ledger_read_only=False,
read_only_ledger_dir=None,
from_snapshot=True,
snapshot_dir=None,
):
forwarded_args = {
arg: getattr(args, arg)
for arg in infra.network.Network.node_args_to_forward
}
# Contact primary if no target node is set
if target_node is None:
target_node, _ = self.find_primary(
timeout=args.ledger_recovery_timeout if recovery else 3)
LOG.info(f"Joining from target node {target_node.node_id}")
# Only retrieve snapshot from target node if the snapshot directory is not
# specified
if from_snapshot and snapshot_dir is None:
snapshot_dir = self.get_committed_snapshots(target_node)
committed_ledger_dir = None
current_ledger_dir = None
if from_snapshot:
if os.listdir(snapshot_dir):
LOG.info(f"Joining from snapshot directory: {snapshot_dir}")
# Only when joining from snapshot, retrieve ledger dirs from target node
# if the ledger directories are not specified. When joining without snapshot,
# the entire ledger will be retransmitted by primary node
current_ledger_dir = ledger_dir or None
committed_ledger_dir = read_only_ledger_dir or None
if copy_ledger_read_only and read_only_ledger_dir is None:
current_ledger_dir, committed_ledger_dir = target_node.get_ledger(
include_read_only_dirs=True)
else:
LOG.warning(
f"Attempting to join from snapshot but {snapshot_dir} is empty: defaulting to complete replay of transaction history"
)
else:
LOG.info(
"Joining without snapshot: complete transaction history will be replayed"
)
node.join(
lib_name=lib_name,
workspace=args.workspace,
label=args.label,
common_dir=self.common_dir,
target_rpc_address=f"{target_node.host}:{target_node.rpc_port}",
snapshot_dir=snapshot_dir,
ledger_dir=current_ledger_dir,
read_only_ledger_dir=committed_ledger_dir,
**forwarded_args,
)
# If the network is opening, node are trusted without consortium approval
if self.status == ServiceStatus.OPENING:
try:
node.wait_for_node_to_join(timeout=JOIN_TIMEOUT)
except TimeoutError:
LOG.error(
f"New node {node.node_id} failed to join the network")
raise
node.network_state = infra.node.NodeNetworkState.joined
def _add_node(
self,
node,
lib_name,
args,
target_node=None,
recovery=False,
ledger_dir=None,
copy_ledger_read_only=False,
read_only_ledger_dir=None,
from_snapshot=False,
snapshot_dir=None,
):
# Contact primary if no target node is set
if target_node is None:
target_node, _ = self.find_primary(
timeout=args.ledger_recovery_timeout if recovery else 3)
LOG.info(f"Joining from target node {target_node.local_node_id}")
committed_ledger_dir = read_only_ledger_dir
current_ledger_dir = ledger_dir
# By default, only copy historical ledger if node is started from snapshot
if read_only_ledger_dir is None and (from_snapshot
or copy_ledger_read_only):
LOG.info(
f"Copying ledger from target node {target_node.local_node_id}")
current_ledger_dir, committed_ledger_dir = target_node.get_ledger(
include_read_only_dirs=True)
if from_snapshot:
# Only retrieve snapshot from target node if the snapshot directory is not
# specified
snapshot_dir = snapshot_dir or self.get_committed_snapshots(
target_node)
if os.listdir(snapshot_dir):
LOG.info(f"Joining from snapshot directory: {snapshot_dir}")
else:
LOG.warning(
f"Attempting to join from snapshot but {snapshot_dir} is empty: defaulting to complete replay of transaction history"
)
else:
LOG.info(
"Joining without snapshot: complete transaction history will be replayed"
)
forwarded_args = {
arg: getattr(args, arg)
for arg in infra.network.Network.node_args_to_forward
}
node.join(
lib_name=lib_name,
workspace=args.workspace,
label=args.label,
common_dir=self.common_dir,
target_rpc_address=
f"{target_node.get_public_rpc_host()}:{target_node.rpc_port}",
snapshot_dir=snapshot_dir,
ledger_dir=current_ledger_dir,
read_only_ledger_dir=committed_ledger_dir,
**forwarded_args,
)
# If the network is opening, node are trusted without consortium approval
if self.status == ServiceStatus.OPENING:
try:
node.wait_for_node_to_join(timeout=JOIN_TIMEOUT)
except TimeoutError:
LOG.error(
f"New node {node.local_node_id} failed to join the network"
)
raise
