def __init__(self,
name: str = None,
basedirpath: str = None,
client: Client = None,
port: int = None,
loop=None,
config=None,
endpointArgs=None):
self.endpoint = None
if port:
checkPortAvailable(HA("0.0.0.0", port))
Motor.__init__(self)
self.loop = loop or asyncio.get_event_loop()
self._eventListeners = {} # Dict[str, set(Callable)]
self._name = name or 'Agent'
self._port = port
self.config = config or getConfig()
self.basedirpath = basedirpath or os.path.expanduser(
self.config.baseDir)
self.endpointArgs = endpointArgs
# Client used to connect to Sovrin and forward on owner's txns
self._client = client # type: Client
# known identifiers of this agent's owner
self.ownerIdentifiers = {} # type: Dict[Identifier, Identity]
def __init__(self,
name: str=None,
basedirpath: str=None,
client: Client=None,
port: int=None,
loop=None,
config=None,
endpointArgs=None):
self.endpoint = None
if port:
checkPortAvailable(HA("0.0.0.0", port))
Motor.__init__(self)
self.loop = loop or asyncio.get_event_loop()
self._eventListeners = {} # Dict[str, set(Callable)]
self._name = name or 'Agent'
self._port = port
self.config = config or getConfig()
self.basedirpath = basedirpath or os.path.expanduser(
self.config.CLI_BASE_DIR)
self.endpointArgs = endpointArgs
# Client used to connect to Indy and forward on owner's txns
self._client = client # type: Client
# known identifiers of this agent's owner
self.ownerIdentifiers = {} # type: Dict[Identifier, Identity]
self.logger = logger
def __init__(self,
clientId: str,
nodeReg: Dict[str, HA]=None,
ha: Union[HA, Tuple[str, int]]=None,
lastReqId: int = 0,
signer: Signer=None,
basedirpath: str=None):
"""
Creates a new client.
:param clientId: unique identifier for the client
:param nodeReg: names and host addresses of all nodes in the pool
:param lastReqId: Request Id of the last request sent by client
:param stack: node stack or dictionary of node constructor kwargs
:param signer: Helper for signer (defines sign method)
"""
self.clientId = clientId
self.lastReqId = lastReqId
self._clientStack = None
self.minimumNodes = getMaxFailures(len(nodeReg)) + 1
cha = ha if isinstance(ha, HA) else HA(*ha)
stackargs = dict(name=clientId,
ha=cha,
main=False, # stops incoming vacuous joins
auto=AutoMode.always)
if basedirpath:
stackargs['basedirpath'] = basedirpath
self.created = time.perf_counter()
NodeStacked.__init__(self,
stackParams=stackargs,
nodeReg=nodeReg)
logger.info("Client initialized with the following node registry:")
lengths = [max(x) for x in zip(*[
(len(name), len(host), len(str(port)))
for name, (host, port) in nodeReg.items()])]
fmt = " {{:<{}}} listens at {{:<{}}} on port {{:>{}}}".format(
*lengths)
for name, (host, port) in nodeReg.items():
logger.info(fmt.format(name, host, port))
Motor.__init__(self)
self.inBox = deque()
self.signer = signer if signer else SimpleSigner(self.clientId)
self.connectNicelyUntil = 0 # don't need to connect nicely as a client
def __init__(self,
name: str,
basedirpath: str,
client: Client = None,
port: int = None):
Motor.__init__(self)
self._observers = set()
self._eventListeners = {} # Dict[str, set(Callable)]
self._name = name
AgentNet.__init__(self,
name=self._name.replace(" ", ""),
port=port,
basedirpath=basedirpath,
msgHandler=self.handleEndpointMessage)
# Client used to connect to Sovrin and forward on owner's txns
self.client = client
# known identifiers of this agent's owner
self.ownerIdentifiers = {} # type: Dict[Identifier, Identity]
def __init__(self,
name: str,
nodeReg: Dict[str, HA] = None,
ha: Union[HA, Tuple[str, int]] = None,
basedirpath: str = None,
genesis_dir: str = None,
ledger_dir: str = None,
keys_dir: str = None,
plugins_dir: str = None,
config=None,
sighex: str = None):
"""
Creates a new client.
:param name: unique identifier for the client
:param nodeReg: names and host addresses of all nodes in the pool
:param ha: tuple of host and port
"""
self.config = config or getConfig()
dataDir = self.config.clientDataDir or "data/clients"
self.basedirpath = basedirpath or self.config.CLI_BASE_DIR
self.basedirpath = os.path.expanduser(self.basedirpath)
signer = Signer(sighex)
sighex = signer.keyraw
verkey = rawToFriendly(signer.verraw)
self.stackName = verkey
# TODO: Have a way for a client to have a user friendly name. Does it
# matter now, it used to matter in some CLI exampples in the past.
# self.name = name
self.name = self.stackName or 'Client~' + str(id(self))
self.genesis_dir = genesis_dir or self.basedirpath
self.ledger_dir = ledger_dir or os.path.join(self.basedirpath, dataDir, self.name)
self.plugins_dir = plugins_dir or self.basedirpath
_keys_dir = keys_dir or self.basedirpath
self.keys_dir = os.path.join(_keys_dir, "keys")
cha = None
if self.exists(self.stackName, self.keys_dir):
cha = self.nodeStackClass.getHaFromLocal(
self.stackName, self.keys_dir)
if cha:
cha = HA(*cha)
logger.debug("Client {} ignoring given ha {} and using {}".
format(self.name, ha, cha))
if not cha:
cha = ha if isinstance(ha, HA) else HA(*ha)
self.reqRepStore = self.getReqRepStore()
self.txnLog = self.getTxnLogStore()
HasFileStorage.__init__(self, self.ledger_dir)
# TODO: Find a proper name
self.alias = name
if not nodeReg:
self.mode = None
HasPoolManager.__init__(self)
self.ledgerManager = LedgerManager(self, ownedByNode=False)
self.ledgerManager.addLedger(
POOL_LEDGER_ID,
self.ledger,
preCatchupStartClbk=self.prePoolLedgerCatchup,
postCatchupCompleteClbk=self.postPoolLedgerCaughtUp,
postTxnAddedToLedgerClbk=self.postTxnFromCatchupAddedToLedger)
else:
cliNodeReg = OrderedDict()
for nm, (ip, port) in nodeReg.items():
cliNodeReg[nm] = HA(ip, port)
self.nodeReg = cliNodeReg
self.mode = Mode.discovered
HasActionQueue.__init__(self)
self.setPoolParams()
stackargs = dict(name=self.stackName,
ha=cha,
main=False, # stops incoming vacuous joins
auth_mode=AuthMode.ALLOW_ANY.value)
stackargs['basedirpath'] = self.keys_dir
self.created = time.perf_counter()
# noinspection PyCallingNonCallable
# TODO I think this is a bug here, sighex is getting passed in the seed
# parameter
self.nodestack = self.nodeStackClass(stackargs,
self.handleOneNodeMsg,
self.nodeReg,
sighex)
self.nodestack.onConnsChanged = self.onConnsChanged
if self.nodeReg:
logger.info(
"Client {} initialized with the following node registry:".format(
self.alias))
lengths = [max(x) for x in zip(*[
(len(name), len(host), len(str(port)))
for name, (host, port) in self.nodeReg.items()])]
fmt = " {{:<{}}} listens at {{:<{}}} on port {{:>{}}}".format(
*lengths)
for name, (host, port) in self.nodeReg.items():
logger.info(fmt.format(name, host, port))
else:
logger.info(
"Client {} found an empty node registry:".format(self.alias))
Motor.__init__(self)
self.inBox = deque()
self.nodestack.connectNicelyUntil = 0 # don't need to connect
# nicely as a client
# TODO: Need to have couple of tests around `reqsPendingConnection`
# where we check with and without pool ledger
# Stores the requests that need to be sent to the nodes when the client
# has made sufficient connections to the nodes.
self.reqsPendingConnection = deque()
# Tuple of identifier and reqId as key and value as tuple of set of
# nodes which are expected to send REQACK
self.expectingAcksFor = {}
# Tuple of identifier and reqId as key and value as tuple of set of
# nodes which are expected to send REPLY
self.expectingRepliesFor = {}
self._observers = {} # type Dict[str, Callable]
self._observerSet = set() # makes it easier to guard against duplicates
plugins_to_load = self.config.PluginsToLoad if hasattr(self.config, "PluginsToLoad") else None
tp = loadPlugins(self.plugins_dir, plugins_to_load)
logger.debug("total plugins loaded in client: {}".format(tp))
self._multi_sig_verifier = self._create_multi_sig_verifier()
self._read_only_requests = set()
def __init__(self,
name: str,
nodeReg: Dict[str, HA] = None,
ha: Union[HA, Tuple[str, int]] = None,
basedirpath: str = None,
config=None):
"""
Creates a new client.
:param name: unique identifier for the client
:param nodeReg: names and host addresses of all nodes in the pool
:param ha: tuple of host and port
:param lastReqId: Request Id of the last request sent by client
"""
self.config = config or getConfig()
basedirpath = self.config.baseDir if not basedirpath else basedirpath
self.basedirpath = basedirpath
cha = None
# If client information already exists is RAET then use that
if self.exists(name, basedirpath):
logger.debug("Client {} ignoring given ha".format(ha))
cha = getHaFromLocalEstate(name, basedirpath)
if cha:
cha = HA(*cha)
if not cha:
cha = ha if isinstance(ha, HA) else HA(*ha)
self.name = name
self.reqRepStore = self.getReqRepStore()
self.txnLog = self.getTxnLogStore()
self.dataDir = self.config.clientDataDir or "data/clients"
HasFileStorage.__init__(self,
self.name,
baseDir=self.basedirpath,
dataDir=self.dataDir)
self._ledger = None
if not nodeReg:
self.mode = None
HasPoolManager.__init__(self)
self.ledgerManager = LedgerManager(self, ownedByNode=False)
self.ledgerManager.addLedger(
0,
self.ledger,
postCatchupCompleteClbk=self.postPoolLedgerCaughtUp,
postTxnAddedToLedgerClbk=self.postTxnFromCatchupAddedToLedger)
else:
cliNodeReg = OrderedDict()
for nm, (ip, port) in nodeReg.items():
cliNodeReg[nm] = HA(ip, port)
self.nodeReg = cliNodeReg
self.mode = Mode.discovered
self.setF()
stackargs = dict(
name=name,
ha=cha,
main=False, # stops incoming vacuous joins
auto=AutoMode.always)
stackargs['basedirpath'] = basedirpath
self.created = time.perf_counter()
# noinspection PyCallingNonCallable
self.nodestack = self.nodeStackClass(stackargs, self.handleOneNodeMsg,
self.nodeReg)
self.nodestack.onConnsChanged = self.onConnsChanged
logger.info(
"Client {} initialized with the following node registry:".format(
name))
lengths = [
max(x)
for x in zip(*[(len(name), len(host), len(str(port)))
for name, (host, port) in self.nodeReg.items()])
]
fmt = " {{:<{}}} listens at {{:<{}}} on port {{:>{}}}".format(
*lengths)
for name, (host, port) in self.nodeReg.items():
logger.info(fmt.format(name, host, port))
Motor.__init__(self)
self.inBox = deque()
self.nodestack.connectNicelyUntil = 0 # don't need to connect
# nicely as a client
# TODO: Need to have couple of tests around `reqsPendingConnection`
# where we check with and without pool ledger
# Stores the requests that need to be sent to the nodes when the client
# has made sufficient connections to the nodes.
self.reqsPendingConnection = deque()
tp = loadPlugins(self.basedirpath)
logger.debug("total plugins loaded in client: {}".format(tp))
def __init__(self,
name: str,
nodeReg: Dict[str, HA] = None,
ha: Union[HA, Tuple[str, int]] = None,
lastReqId: int = 0,
signer: Signer = None,
signers: Dict[str, Signer] = None,
basedirpath: str = None):
"""
Creates a new client.
:param name: unique identifier for the client
:param nodeReg: names and host addresses of all nodes in the pool
:param ha: tuple of host and port
:param lastReqId: Request Id of the last request sent by client
:param signer: Signer; mutually exclusive of signers
:param signers: Dict of identifier -> Signer; useful for clients that
need to support multiple signers
"""
self.lastReqId = lastReqId
self._clientStack = None
self.minimumNodes = getMaxFailures(len(nodeReg)) + 1
cliNodeReg = OrderedDict()
for nm in nodeReg:
val = nodeReg[nm]
if len(val) == 3:
((ip, port), verkey, pubkey) = val
else:
ip, port = val
cliNodeReg[nm] = HA(ip, port)
nodeReg = cliNodeReg
cha = ha if isinstance(ha, HA) else HA(*ha)
stackargs = dict(
name=name,
ha=cha,
main=False, # stops incoming vacuous joins
auto=AutoMode.always)
if basedirpath:
stackargs['basedirpath'] = basedirpath
self.created = time.perf_counter()
NodeStacked.__init__(self, stackParams=stackargs, nodeReg=nodeReg)
logger.info("Client initialized with the following node registry:")
lengths = [
max(x) for x in zip(*[(len(name), len(host), len(str(port)))
for name, (host, port) in nodeReg.items()])
]
fmt = " {{:<{}}} listens at {{:<{}}} on port {{:>{}}}".format(
*lengths)
for name, (host, port) in nodeReg.items():
logger.info(fmt.format(name, host, port))
Motor.__init__(self)
self.inBox = deque()
if signer and signers:
raise ValueError("only one of 'signer' or 'signers' can be used")
self.signers = None
self.defaultIdentifier = None
if signer:
self.signers = {signer.identifier: signer}
self.defaultIdentifier = signer.identifier
elif signers:
self.signers = signers
else:
self.setupDefaultSigner()
self.connectNicelyUntil = 0 # don't need to connect nicely as a client
def __init__(self, name):
self.name = name
self.results = {}
Motor.__init__(self)
HasActionQueue.__init__(self)
def __init__(self, name):
self.name = name
self.results = {}
Motor.__init__(self)
HasActionQueue.__init__(self)
def __init__(self,
name: str,
nodeRegistry: Dict[str, HA],
clientAuthNr: ClientAuthNr=None,
ha: HA=None,
cliname: str=None,
cliha: HA=None,
basedirpath: str=None,
primaryDecider: PrimaryDecider = None,
opVerifiers: Iterable[Any]=None):
"""
Create a new node.
:param nodeRegistry: names and host addresses of all nodes in the pool
:param clientAuthNr: client authenticator implementation to be used
:param basedirpath: path to the base directory used by `nstack` and
`cstack`
:param primaryDecider: the mechanism to be used to decide the primary
of a protocol instance
"""
self.opVerifiers = opVerifiers or []
self.primaryDecider = primaryDecider
me = nodeRegistry[name]
self.allNodeNames = list(nodeRegistry.keys())
if isinstance(me, NodeDetail):
sha = me.ha
scliname = me.cliname
scliha = me.cliha
nodeReg = {k: v.ha for k, v in nodeRegistry.items()}
else:
sha = me if isinstance(me, HA) else HA(*me)
scliname = None
scliha = None
nodeReg = {k: HA(*v) for k, v in nodeRegistry.items()}
if not ha: # pull it from the registry
ha = sha
if not cliname: # default to the name plus the suffix
cliname = scliname if scliname else name + CLIENT_STACK_SUFFIX
if not cliha: # default to same ip, port + 1
cliha = scliha if scliha else HA(ha[0], ha[1]+1)
nstack = dict(name=name,
ha=ha,
main=True,
auto=AutoMode.never)
cstack = dict(name=cliname,
ha=cliha,
main=True,
auto=AutoMode.always)
if basedirpath:
nstack['basedirpath'] = basedirpath
cstack['basedirpath'] = basedirpath
self.clientAuthNr = clientAuthNr or SimpleAuthNr()
self.nodeInBox = deque()
self.clientInBox = deque()
self.created = time.perf_counter()
HasActionQueue.__init__(self)
NodeStacked.__init__(self, nstack, nodeReg)
ClientStacked.__init__(self, cstack)
Motor.__init__(self)
Propagator.__init__(self)
self.totalNodes = len(nodeRegistry)
self.f = getMaxFailures(self.totalNodes)
self.requiredNumberOfInstances = self.f + 1 # per RBFT
self.minimumNodes = (2 * self.f) + 1 # minimum for a functional pool
self.txnStore = TransactionStore()
self.replicas = [] # type: List[replica.Replica]
self.instanceChanges = InstanceChanges()
self.viewNo = 0 # type: int
self.rank = self.getRank(self.name, nodeRegistry)
self.elector = None # type: PrimaryDecider
self.forwardedRequests = set() # type: Set[Tuple[(str, int)]]
self.instances = Instances()
self.monitor = Monitor(self.name,
Delta=.8, Lambda=60, Omega=5,
instances=self.instances)
# Requests that are to be given to the replicas by the node. Each
# element of the list is a deque for the replica with number equal to
# its index in the list and each element of the deque is a named tuple
self.msgsToReplicas = [] # type: List[deque]
# Requests that are to be given to the elector by the node
self.msgsToElector = deque()
nodeRoutes = [(Propagate, self.processPropagate),
(InstanceChange, self.processInstanceChange)]
nodeRoutes.extend((msgTyp, self.sendToElector) for msgTyp in
[Nomination, Primary, Reelection])
nodeRoutes.extend((msgTyp, self.sendToReplica) for msgTyp in
[PrePrepare, Prepare, Commit])
self.nodeMsgRouter = Router(*nodeRoutes)
self.clientMsgRouter = Router((Request,
self.processRequest))
self.perfCheckFreq = 10
self._schedule(self.checkPerformance, self.perfCheckFreq)
self.clientBlacklister = SimpleBlacklister(
self.name + CLIENT_BLACKLISTER_SUFFIX) # type: Blacklister
self.nodeBlacklister = SimpleBlacklister(
self.name + NODE_BLACKLISTER_SUFFIX) # type: Blacklister
# BE CAREFUL HERE
# This controls which message types are excluded from signature
# verification. These are still subject to RAET's signature verification
# but client signatures will not be checked on these. Expressly
# prohibited from being in this is ClientRequest and Propagation,
# which both require client signature verification
self.authnWhitelist = (Nomination, Primary, Reelection,
Batch,
PrePrepare, Prepare,
Commit, InstanceChange)
self.addReplicas()
def __init__(self, name: str):
Motor.__init__(self)
Logic.__init__(self)
self._last_loop = None
self._name = name
self.interfaces = {} # type: Dict[str, Interface]
def __init__(self,
name: str,
nodeReg: Dict[str, HA]=None,
ha: Union[HA, Tuple[str, int]]=None,
lastReqId: int = 0,
signer: Signer=None,
signers: Dict[str, Signer]=None,
basedirpath: str=None):
"""
Creates a new client.
:param name: unique identifier for the client
:param nodeReg: names and host addresses of all nodes in the pool
:param ha: tuple of host and port
:param lastReqId: Request Id of the last request sent by client
:param signer: Signer; mutually exclusive of signers
:param signers: Dict of identifier -> Signer; useful for clients that
need to support multiple signers
"""
self.lastReqId = lastReqId
self._clientStack = None
self.minimumNodes = getMaxFailures(len(nodeReg)) + 1
cliNodeReg = OrderedDict()
for nm in nodeReg:
val = nodeReg[nm]
if len(val) == 3:
((ip, port), verkey, pubkey) = val
else:
ip, port = val
cliNodeReg[nm] = HA(ip, port)
nodeReg = cliNodeReg
cha = ha if isinstance(ha, HA) else HA(*ha)
stackargs = dict(name=name,
ha=cha,
main=False, # stops incoming vacuous joins
auto=AutoMode.always)
if basedirpath:
stackargs['basedirpath'] = basedirpath
self.created = time.perf_counter()
NodeStacked.__init__(self,
stackParams=stackargs,
nodeReg=nodeReg)
logger.info("Client initialized with the following node registry:")
lengths = [max(x) for x in zip(*[
(len(name), len(host), len(str(port)))
for name, (host, port) in nodeReg.items()])]
fmt = " {{:<{}}} listens at {{:<{}}} on port {{:>{}}}".format(
*lengths)
for name, (host, port) in nodeReg.items():
logger.info(fmt.format(name, host, port))
Motor.__init__(self)
self.inBox = deque()
if signer and signers:
raise ValueError("only one of 'signer' or 'signers' can be used")
self.signers = None
self.defaultIdentifier = None
if signer:
self.signers = {signer.identifier: signer}
self.defaultIdentifier = signer.identifier
elif signers:
self.signers = signers
else:
self.setupDefaultSigner()
self.connectNicelyUntil = 0 # don't need to connect nicely as a client
def __init__(self,
name: str,
nodeReg: Dict[str, HA]=None,
ha: Union[HA, Tuple[str, int]]=None,
basedirpath: str=None,
config=None,
sighex: str=None):
"""
Creates a new client.
:param name: unique identifier for the client
:param nodeReg: names and host addresses of all nodes in the pool
:param ha: tuple of host and port
"""
self.config = config or getConfig()
basedirpath = self.config.baseDir if not basedirpath else basedirpath
self.basedirpath = basedirpath
signer = Signer(sighex)
sighex = signer.keyhex
verkey = rawToFriendly(signer.verraw)
self.name = name
self.stackName = verkey
cha = None
# If client information already exists is RAET then use that
if self.exists(self.stackName, basedirpath):
cha = getHaFromLocalEstate(self.stackName, basedirpath)
if cha:
cha = HA(*cha)
logger.debug("Client {} ignoring given ha {} and using {}".
format(self.name, ha, cha))
if not cha:
cha = ha if isinstance(ha, HA) else HA(*ha)
self.reqRepStore = self.getReqRepStore()
self.txnLog = self.getTxnLogStore()
self.dataDir = self.config.clientDataDir or "data/clients"
HasFileStorage.__init__(self, self.name, baseDir=self.basedirpath,
dataDir=self.dataDir)
self._ledger = None
if not nodeReg:
self.mode = None
HasPoolManager.__init__(self)
self.ledgerManager = LedgerManager(self, ownedByNode=False)
self.ledgerManager.addLedger(0, self.ledger,
postCatchupCompleteClbk=self.postPoolLedgerCaughtUp,
postTxnAddedToLedgerClbk=self.postTxnFromCatchupAddedToLedger)
else:
cliNodeReg = OrderedDict()
for nm, (ip, port) in nodeReg.items():
cliNodeReg[nm] = HA(ip, port)
self.nodeReg = cliNodeReg
self.mode = Mode.discovered
HasActionQueue.__init__(self)
self.setF()
stackargs = dict(name=self.stackName,
ha=cha,
main=False, # stops incoming vacuous joins
auto=AutoMode.always)
stackargs['basedirpath'] = basedirpath
self.created = time.perf_counter()
# noinspection PyCallingNonCallable
self.nodestack = self.nodeStackClass(stackargs,
self.handleOneNodeMsg,
self.nodeReg,
sighex)
self.nodestack.onConnsChanged = self.onConnsChanged
if self.nodeReg:
logger.info("Client {} initialized with the following node registry:"
.format(self.name))
lengths = [max(x) for x in zip(*[
(len(name), len(host), len(str(port)))
for name, (host, port) in self.nodeReg.items()])]
fmt = " {{:<{}}} listens at {{:<{}}} on port {{:>{}}}".format(
*lengths)
for name, (host, port) in self.nodeReg.items():
logger.info(fmt.format(name, host, port))
else:
logger.info(
"Client {} found an empty node registry:".format(self.name))
Motor.__init__(self)
self.inBox = deque()
self.nodestack.connectNicelyUntil = 0 # don't need to connect
# nicely as a client
# TODO: Need to have couple of tests around `reqsPendingConnection`
# where we check with and without pool ledger
# Stores the requests that need to be sent to the nodes when the client
# has made sufficient connections to the nodes.
self.reqsPendingConnection = deque()
# Tuple of identifier and reqId as key and value as tuple of set of
# nodes which are expected to send REQACK
self.expectingAcksFor = {}
# Tuple of identifier and reqId as key and value as tuple of set of
# nodes which are expected to send REPLY
self.expectingRepliesFor = {}
tp = loadPlugins(self.basedirpath)
logger.debug("total plugins loaded in client: {}".format(tp))
def __init__(self,
name: str,
nodeReg: Dict[str, HA] = None,
ha: Union[HA, Tuple[str, int]] = None,
basedirpath: str = None,
config=None,
sighex: str = None):
"""
Creates a new client.
:param name: unique identifier for the client
:param nodeReg: names and host addresses of all nodes in the pool
:param ha: tuple of host and port
"""
self.config = config or getConfig()
basedirpath = self.config.baseDir if not basedirpath else basedirpath
self.basedirpath = basedirpath
signer = Signer(sighex)
sighex = signer.keyraw
verkey = rawToFriendly(signer.verraw)
self.stackName = verkey
# TODO: Have a way for a client to have a user friendly name. Does it
# matter now, it used to matter in some CLI exampples in the past.
# self.name = name
self.name = self.stackName
cha = None
# If client information already exists is RAET then use that
if self.exists(self.stackName, basedirpath):
cha = getHaFromLocalEstate(self.stackName, basedirpath)
if cha:
cha = HA(*cha)
logger.debug(
"Client {} ignoring given ha {} and using {}".format(
self.name, ha, cha))
if not cha:
cha = ha if isinstance(ha, HA) else HA(*ha)
self.reqRepStore = self.getReqRepStore()
self.txnLog = self.getTxnLogStore()
self.dataDir = self.config.clientDataDir or "data/clients"
HasFileStorage.__init__(self,
self.name,
baseDir=self.basedirpath,
dataDir=self.dataDir)
# TODO: Find a proper name
self.alias = name
self._ledger = None
if not nodeReg:
self.mode = None
HasPoolManager.__init__(self)
self.ledgerManager = LedgerManager(self, ownedByNode=False)
self.ledgerManager.addLedger(
0,
self.ledger,
postCatchupCompleteClbk=self.postPoolLedgerCaughtUp,
postTxnAddedToLedgerClbk=self.postTxnFromCatchupAddedToLedger)
else:
cliNodeReg = OrderedDict()
for nm, (ip, port) in nodeReg.items():
cliNodeReg[nm] = HA(ip, port)
self.nodeReg = cliNodeReg
self.mode = Mode.discovered
HasActionQueue.__init__(self)
self.setF()
stackargs = dict(
name=self.stackName,
ha=cha,
main=False, # stops incoming vacuous joins
auto=2)
stackargs['basedirpath'] = basedirpath
self.created = time.perf_counter()
# noinspection PyCallingNonCallable
self.nodestack = self.nodeStackClass(stackargs, self.handleOneNodeMsg,
self.nodeReg, sighex)
self.nodestack.onConnsChanged = self.onConnsChanged
if self.nodeReg:
logger.info(
"Client {} initialized with the following node registry:".
format(self.alias))
lengths = [
max(x)
for x in zip(*[(len(name), len(host), len(str(port)))
for name, (host, port) in self.nodeReg.items()])
]
fmt = " {{:<{}}} listens at {{:<{}}} on port {{:>{}}}".format(
*lengths)
for name, (host, port) in self.nodeReg.items():
logger.info(fmt.format(name, host, port))
else:
logger.info("Client {} found an empty node registry:".format(
self.alias))
Motor.__init__(self)
self.inBox = deque()
self.nodestack.connectNicelyUntil = 0 # don't need to connect
# nicely as a client
# TODO: Need to have couple of tests around `reqsPendingConnection`
# where we check with and without pool ledger
# Stores the requests that need to be sent to the nodes when the client
# has made sufficient connections to the nodes.
self.reqsPendingConnection = deque()
# Tuple of identifier and reqId as key and value as tuple of set of
# nodes which are expected to send REQACK
self.expectingAcksFor = {}
# Tuple of identifier and reqId as key and value as tuple of set of
# nodes which are expected to send REPLY
self.expectingRepliesFor = {}
tp = loadPlugins(self.basedirpath)
logger.debug("total plugins loaded in client: {}".format(tp))