id
int32 0
252k
| repo
stringlengths 7
55
| path
stringlengths 4
127
| func_name
stringlengths 1
88
| original_string
stringlengths 75
19.8k
| language
stringclasses 1
value | code
stringlengths 75
19.8k
| code_tokens
list | docstring
stringlengths 3
17.3k
| docstring_tokens
list | sha
stringlengths 40
40
| url
stringlengths 87
242
|
|---|---|---|---|---|---|---|---|---|---|---|---|
234,200
|
hyperledger/indy-plenum
|
plenum/common/batched.py
|
Batched._enqueueIntoAllRemotes
|
def _enqueueIntoAllRemotes(self, msg: Any, signer: Signer) -> None:
"""
Enqueue the specified message into all the remotes in the nodestack.
:param msg: the message to enqueue
"""
for rid in self.remotes.keys():
self._enqueue(msg, rid, signer)
|
python
|
def _enqueueIntoAllRemotes(self, msg: Any, signer: Signer) -> None:
"""
Enqueue the specified message into all the remotes in the nodestack.
:param msg: the message to enqueue
"""
for rid in self.remotes.keys():
self._enqueue(msg, rid, signer)
|
[
"def",
"_enqueueIntoAllRemotes",
"(",
"self",
",",
"msg",
":",
"Any",
",",
"signer",
":",
"Signer",
")",
"->",
"None",
":",
"for",
"rid",
"in",
"self",
".",
"remotes",
".",
"keys",
"(",
")",
":",
"self",
".",
"_enqueue",
"(",
"msg",
",",
"rid",
",",
"signer",
")"
] |
Enqueue the specified message into all the remotes in the nodestack.
:param msg: the message to enqueue
|
[
"Enqueue",
"the",
"specified",
"message",
"into",
"all",
"the",
"remotes",
"in",
"the",
"nodestack",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/batched.py#L47-L54
|
234,201
|
hyperledger/indy-plenum
|
plenum/common/batched.py
|
Batched.send
|
def send(self,
msg: Any, *
rids: Iterable[int],
signer: Signer = None,
message_splitter=None) -> None:
"""
Enqueue the given message into the outBoxes of the specified remotes
or into the outBoxes of all the remotes if rids is None
:param msg: the message to enqueue
:param rids: ids of the remotes to whose outBoxes
this message must be enqueued
:param message_splitter: callable that splits msg on
two smaller messages
"""
# Signing (if required) and serializing before enqueueing otherwise
# each call to `_enqueue` will have to sign it and `transmit` will try
# to serialize it which is waste of resources
message_parts, err_msg = \
self.prepare_for_sending(msg, signer, message_splitter)
# TODO: returning breaks contract of super class
if err_msg is not None:
return False, err_msg
if rids:
for r in rids:
for part in message_parts:
self._enqueue(part, r, signer)
else:
for part in message_parts:
self._enqueueIntoAllRemotes(part, signer)
return True, None
|
python
|
def send(self,
msg: Any, *
rids: Iterable[int],
signer: Signer = None,
message_splitter=None) -> None:
"""
Enqueue the given message into the outBoxes of the specified remotes
or into the outBoxes of all the remotes if rids is None
:param msg: the message to enqueue
:param rids: ids of the remotes to whose outBoxes
this message must be enqueued
:param message_splitter: callable that splits msg on
two smaller messages
"""
# Signing (if required) and serializing before enqueueing otherwise
# each call to `_enqueue` will have to sign it and `transmit` will try
# to serialize it which is waste of resources
message_parts, err_msg = \
self.prepare_for_sending(msg, signer, message_splitter)
# TODO: returning breaks contract of super class
if err_msg is not None:
return False, err_msg
if rids:
for r in rids:
for part in message_parts:
self._enqueue(part, r, signer)
else:
for part in message_parts:
self._enqueueIntoAllRemotes(part, signer)
return True, None
|
[
"def",
"send",
"(",
"self",
",",
"msg",
":",
"Any",
",",
"*",
"rids",
":",
"Iterable",
"[",
"int",
"]",
",",
"signer",
":",
"Signer",
"=",
"None",
",",
"message_splitter",
"=",
"None",
")",
"->",
"None",
":",
"# Signing (if required) and serializing before enqueueing otherwise",
"# each call to `_enqueue` will have to sign it and `transmit` will try",
"# to serialize it which is waste of resources",
"message_parts",
",",
"err_msg",
"=",
"self",
".",
"prepare_for_sending",
"(",
"msg",
",",
"signer",
",",
"message_splitter",
")",
"# TODO: returning breaks contract of super class",
"if",
"err_msg",
"is",
"not",
"None",
":",
"return",
"False",
",",
"err_msg",
"if",
"rids",
":",
"for",
"r",
"in",
"rids",
":",
"for",
"part",
"in",
"message_parts",
":",
"self",
".",
"_enqueue",
"(",
"part",
",",
"r",
",",
"signer",
")",
"else",
":",
"for",
"part",
"in",
"message_parts",
":",
"self",
".",
"_enqueueIntoAllRemotes",
"(",
"part",
",",
"signer",
")",
"return",
"True",
",",
"None"
] |
Enqueue the given message into the outBoxes of the specified remotes
or into the outBoxes of all the remotes if rids is None
:param msg: the message to enqueue
:param rids: ids of the remotes to whose outBoxes
this message must be enqueued
:param message_splitter: callable that splits msg on
two smaller messages
|
[
"Enqueue",
"the",
"given",
"message",
"into",
"the",
"outBoxes",
"of",
"the",
"specified",
"remotes",
"or",
"into",
"the",
"outBoxes",
"of",
"all",
"the",
"remotes",
"if",
"rids",
"is",
"None"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/batched.py#L56-L88
|
234,202
|
hyperledger/indy-plenum
|
plenum/common/batched.py
|
Batched.flushOutBoxes
|
def flushOutBoxes(self) -> None:
"""
Clear the outBoxes and transmit batched messages to remotes.
"""
removedRemotes = []
for rid, msgs in self.outBoxes.items():
try:
dest = self.remotes[rid].name
except KeyError:
removedRemotes.append(rid)
continue
if msgs:
if self._should_batch(msgs):
logger.trace(
"{} batching {} msgs to {} into fewer transmissions".
format(self, len(msgs), dest))
logger.trace(" messages: {}".format(msgs))
batches = split_messages_on_batches(list(msgs),
self._make_batch,
self._test_batch_len,
)
msgs.clear()
if batches:
for batch, size in batches:
logger.trace("{} sending payload to {}: {}".format(
self, dest, batch))
self.metrics.add_event(MetricsName.TRANSPORT_BATCH_SIZE, size)
# Setting timeout to never expire
self.transmit(
batch,
rid,
timeout=self.messageTimeout,
serialized=True)
else:
logger.error("{} cannot create batch(es) for {}".format(self, dest))
else:
while msgs:
msg = msgs.popleft()
logger.trace(
"{} sending msg {} to {}".format(self, msg, dest))
self.metrics.add_event(MetricsName.TRANSPORT_BATCH_SIZE, 1)
# Setting timeout to never expire
self.transmit(msg, rid, timeout=self.messageTimeout,
serialized=True)
for rid in removedRemotes:
logger.warning("{}{} has removed rid {}"
.format(CONNECTION_PREFIX, self,
z85_to_friendly(rid)),
extra={"cli": False})
msgs = self.outBoxes[rid]
if msgs:
self.discard(msgs,
"{}rid {} no longer available"
.format(CONNECTION_PREFIX,
z85_to_friendly(rid)),
logMethod=logger.debug)
del self.outBoxes[rid]
|
python
|
def flushOutBoxes(self) -> None:
"""
Clear the outBoxes and transmit batched messages to remotes.
"""
removedRemotes = []
for rid, msgs in self.outBoxes.items():
try:
dest = self.remotes[rid].name
except KeyError:
removedRemotes.append(rid)
continue
if msgs:
if self._should_batch(msgs):
logger.trace(
"{} batching {} msgs to {} into fewer transmissions".
format(self, len(msgs), dest))
logger.trace(" messages: {}".format(msgs))
batches = split_messages_on_batches(list(msgs),
self._make_batch,
self._test_batch_len,
)
msgs.clear()
if batches:
for batch, size in batches:
logger.trace("{} sending payload to {}: {}".format(
self, dest, batch))
self.metrics.add_event(MetricsName.TRANSPORT_BATCH_SIZE, size)
# Setting timeout to never expire
self.transmit(
batch,
rid,
timeout=self.messageTimeout,
serialized=True)
else:
logger.error("{} cannot create batch(es) for {}".format(self, dest))
else:
while msgs:
msg = msgs.popleft()
logger.trace(
"{} sending msg {} to {}".format(self, msg, dest))
self.metrics.add_event(MetricsName.TRANSPORT_BATCH_SIZE, 1)
# Setting timeout to never expire
self.transmit(msg, rid, timeout=self.messageTimeout,
serialized=True)
for rid in removedRemotes:
logger.warning("{}{} has removed rid {}"
.format(CONNECTION_PREFIX, self,
z85_to_friendly(rid)),
extra={"cli": False})
msgs = self.outBoxes[rid]
if msgs:
self.discard(msgs,
"{}rid {} no longer available"
.format(CONNECTION_PREFIX,
z85_to_friendly(rid)),
logMethod=logger.debug)
del self.outBoxes[rid]
|
[
"def",
"flushOutBoxes",
"(",
"self",
")",
"->",
"None",
":",
"removedRemotes",
"=",
"[",
"]",
"for",
"rid",
",",
"msgs",
"in",
"self",
".",
"outBoxes",
".",
"items",
"(",
")",
":",
"try",
":",
"dest",
"=",
"self",
".",
"remotes",
"[",
"rid",
"]",
".",
"name",
"except",
"KeyError",
":",
"removedRemotes",
".",
"append",
"(",
"rid",
")",
"continue",
"if",
"msgs",
":",
"if",
"self",
".",
"_should_batch",
"(",
"msgs",
")",
":",
"logger",
".",
"trace",
"(",
"\"{} batching {} msgs to {} into fewer transmissions\"",
".",
"format",
"(",
"self",
",",
"len",
"(",
"msgs",
")",
",",
"dest",
")",
")",
"logger",
".",
"trace",
"(",
"\" messages: {}\"",
".",
"format",
"(",
"msgs",
")",
")",
"batches",
"=",
"split_messages_on_batches",
"(",
"list",
"(",
"msgs",
")",
",",
"self",
".",
"_make_batch",
",",
"self",
".",
"_test_batch_len",
",",
")",
"msgs",
".",
"clear",
"(",
")",
"if",
"batches",
":",
"for",
"batch",
",",
"size",
"in",
"batches",
":",
"logger",
".",
"trace",
"(",
"\"{} sending payload to {}: {}\"",
".",
"format",
"(",
"self",
",",
"dest",
",",
"batch",
")",
")",
"self",
".",
"metrics",
".",
"add_event",
"(",
"MetricsName",
".",
"TRANSPORT_BATCH_SIZE",
",",
"size",
")",
"# Setting timeout to never expire",
"self",
".",
"transmit",
"(",
"batch",
",",
"rid",
",",
"timeout",
"=",
"self",
".",
"messageTimeout",
",",
"serialized",
"=",
"True",
")",
"else",
":",
"logger",
".",
"error",
"(",
"\"{} cannot create batch(es) for {}\"",
".",
"format",
"(",
"self",
",",
"dest",
")",
")",
"else",
":",
"while",
"msgs",
":",
"msg",
"=",
"msgs",
".",
"popleft",
"(",
")",
"logger",
".",
"trace",
"(",
"\"{} sending msg {} to {}\"",
".",
"format",
"(",
"self",
",",
"msg",
",",
"dest",
")",
")",
"self",
".",
"metrics",
".",
"add_event",
"(",
"MetricsName",
".",
"TRANSPORT_BATCH_SIZE",
",",
"1",
")",
"# Setting timeout to never expire",
"self",
".",
"transmit",
"(",
"msg",
",",
"rid",
",",
"timeout",
"=",
"self",
".",
"messageTimeout",
",",
"serialized",
"=",
"True",
")",
"for",
"rid",
"in",
"removedRemotes",
":",
"logger",
".",
"warning",
"(",
"\"{}{} has removed rid {}\"",
".",
"format",
"(",
"CONNECTION_PREFIX",
",",
"self",
",",
"z85_to_friendly",
"(",
"rid",
")",
")",
",",
"extra",
"=",
"{",
"\"cli\"",
":",
"False",
"}",
")",
"msgs",
"=",
"self",
".",
"outBoxes",
"[",
"rid",
"]",
"if",
"msgs",
":",
"self",
".",
"discard",
"(",
"msgs",
",",
"\"{}rid {} no longer available\"",
".",
"format",
"(",
"CONNECTION_PREFIX",
",",
"z85_to_friendly",
"(",
"rid",
")",
")",
",",
"logMethod",
"=",
"logger",
".",
"debug",
")",
"del",
"self",
".",
"outBoxes",
"[",
"rid",
"]"
] |
Clear the outBoxes and transmit batched messages to remotes.
|
[
"Clear",
"the",
"outBoxes",
"and",
"transmit",
"batched",
"messages",
"to",
"remotes",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/batched.py#L90-L147
|
234,203
|
hyperledger/indy-plenum
|
stp_core/loop/looper.py
|
Looper.prodAllOnce
|
async def prodAllOnce(self):
"""
Call `prod` once for each Prodable in this Looper
:return: the sum of the number of events executed successfully
"""
# TODO: looks like limit is always None???
limit = None
s = 0
for n in self.prodables:
s += await n.prod(limit)
return s
|
python
|
async def prodAllOnce(self):
"""
Call `prod` once for each Prodable in this Looper
:return: the sum of the number of events executed successfully
"""
# TODO: looks like limit is always None???
limit = None
s = 0
for n in self.prodables:
s += await n.prod(limit)
return s
|
[
"async",
"def",
"prodAllOnce",
"(",
"self",
")",
":",
"# TODO: looks like limit is always None???",
"limit",
"=",
"None",
"s",
"=",
"0",
"for",
"n",
"in",
"self",
".",
"prodables",
":",
"s",
"+=",
"await",
"n",
".",
"prod",
"(",
"limit",
")",
"return",
"s"
] |
Call `prod` once for each Prodable in this Looper
:return: the sum of the number of events executed successfully
|
[
"Call",
"prod",
"once",
"for",
"each",
"Prodable",
"in",
"this",
"Looper"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/loop/looper.py#L142-L153
|
234,204
|
hyperledger/indy-plenum
|
stp_core/loop/looper.py
|
Looper.add
|
def add(self, prodable: Prodable) -> None:
"""
Add one Prodable object to this Looper's list of Prodables
:param prodable: the Prodable object to add
"""
if prodable.name in [p.name for p in self.prodables]:
raise ProdableAlreadyAdded("Prodable {} already added.".
format(prodable.name))
self.prodables.append(prodable)
if self.autoStart:
prodable.start(self.loop)
|
python
|
def add(self, prodable: Prodable) -> None:
"""
Add one Prodable object to this Looper's list of Prodables
:param prodable: the Prodable object to add
"""
if prodable.name in [p.name for p in self.prodables]:
raise ProdableAlreadyAdded("Prodable {} already added.".
format(prodable.name))
self.prodables.append(prodable)
if self.autoStart:
prodable.start(self.loop)
|
[
"def",
"add",
"(",
"self",
",",
"prodable",
":",
"Prodable",
")",
"->",
"None",
":",
"if",
"prodable",
".",
"name",
"in",
"[",
"p",
".",
"name",
"for",
"p",
"in",
"self",
".",
"prodables",
"]",
":",
"raise",
"ProdableAlreadyAdded",
"(",
"\"Prodable {} already added.\"",
".",
"format",
"(",
"prodable",
".",
"name",
")",
")",
"self",
".",
"prodables",
".",
"append",
"(",
"prodable",
")",
"if",
"self",
".",
"autoStart",
":",
"prodable",
".",
"start",
"(",
"self",
".",
"loop",
")"
] |
Add one Prodable object to this Looper's list of Prodables
:param prodable: the Prodable object to add
|
[
"Add",
"one",
"Prodable",
"object",
"to",
"this",
"Looper",
"s",
"list",
"of",
"Prodables"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/loop/looper.py#L155-L166
|
234,205
|
hyperledger/indy-plenum
|
stp_core/loop/looper.py
|
Looper.removeProdable
|
def removeProdable(self, prodable: Prodable=None, name: str=None) -> Optional[Prodable]:
"""
Remove the specified Prodable object from this Looper's list of Prodables
:param prodable: the Prodable to remove
"""
if prodable:
self.prodables.remove(prodable)
return prodable
elif name:
for p in self.prodables:
if hasattr(p, "name") and getattr(p, "name") == name:
prodable = p
break
if prodable:
self.prodables.remove(prodable)
return prodable
else:
logger.warning("Trying to remove a prodable {} which is not present"
.format(prodable))
else:
logger.error("Provide a prodable object or a prodable name")
|
python
|
def removeProdable(self, prodable: Prodable=None, name: str=None) -> Optional[Prodable]:
"""
Remove the specified Prodable object from this Looper's list of Prodables
:param prodable: the Prodable to remove
"""
if prodable:
self.prodables.remove(prodable)
return prodable
elif name:
for p in self.prodables:
if hasattr(p, "name") and getattr(p, "name") == name:
prodable = p
break
if prodable:
self.prodables.remove(prodable)
return prodable
else:
logger.warning("Trying to remove a prodable {} which is not present"
.format(prodable))
else:
logger.error("Provide a prodable object or a prodable name")
|
[
"def",
"removeProdable",
"(",
"self",
",",
"prodable",
":",
"Prodable",
"=",
"None",
",",
"name",
":",
"str",
"=",
"None",
")",
"->",
"Optional",
"[",
"Prodable",
"]",
":",
"if",
"prodable",
":",
"self",
".",
"prodables",
".",
"remove",
"(",
"prodable",
")",
"return",
"prodable",
"elif",
"name",
":",
"for",
"p",
"in",
"self",
".",
"prodables",
":",
"if",
"hasattr",
"(",
"p",
",",
"\"name\"",
")",
"and",
"getattr",
"(",
"p",
",",
"\"name\"",
")",
"==",
"name",
":",
"prodable",
"=",
"p",
"break",
"if",
"prodable",
":",
"self",
".",
"prodables",
".",
"remove",
"(",
"prodable",
")",
"return",
"prodable",
"else",
":",
"logger",
".",
"warning",
"(",
"\"Trying to remove a prodable {} which is not present\"",
".",
"format",
"(",
"prodable",
")",
")",
"else",
":",
"logger",
".",
"error",
"(",
"\"Provide a prodable object or a prodable name\"",
")"
] |
Remove the specified Prodable object from this Looper's list of Prodables
:param prodable: the Prodable to remove
|
[
"Remove",
"the",
"specified",
"Prodable",
"object",
"from",
"this",
"Looper",
"s",
"list",
"of",
"Prodables"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/loop/looper.py#L168-L189
|
234,206
|
hyperledger/indy-plenum
|
stp_core/loop/looper.py
|
Looper.runOnceNicely
|
async def runOnceNicely(self):
"""
Execute `runOnce` with a small tolerance of 0.01 seconds so that the Prodables
can complete their other asynchronous tasks not running on the event-loop.
"""
start = time.perf_counter()
msgsProcessed = await self.prodAllOnce()
if msgsProcessed == 0:
# if no let other stuff run
await asyncio.sleep(0.01, loop=self.loop)
dur = time.perf_counter() - start
if dur >= 15:
logger.info("it took {:.3f} seconds to run once nicely".
format(dur), extra={"cli": False})
|
python
|
async def runOnceNicely(self):
"""
Execute `runOnce` with a small tolerance of 0.01 seconds so that the Prodables
can complete their other asynchronous tasks not running on the event-loop.
"""
start = time.perf_counter()
msgsProcessed = await self.prodAllOnce()
if msgsProcessed == 0:
# if no let other stuff run
await asyncio.sleep(0.01, loop=self.loop)
dur = time.perf_counter() - start
if dur >= 15:
logger.info("it took {:.3f} seconds to run once nicely".
format(dur), extra={"cli": False})
|
[
"async",
"def",
"runOnceNicely",
"(",
"self",
")",
":",
"start",
"=",
"time",
".",
"perf_counter",
"(",
")",
"msgsProcessed",
"=",
"await",
"self",
".",
"prodAllOnce",
"(",
")",
"if",
"msgsProcessed",
"==",
"0",
":",
"# if no let other stuff run",
"await",
"asyncio",
".",
"sleep",
"(",
"0.01",
",",
"loop",
"=",
"self",
".",
"loop",
")",
"dur",
"=",
"time",
".",
"perf_counter",
"(",
")",
"-",
"start",
"if",
"dur",
">=",
"15",
":",
"logger",
".",
"info",
"(",
"\"it took {:.3f} seconds to run once nicely\"",
".",
"format",
"(",
"dur",
")",
",",
"extra",
"=",
"{",
"\"cli\"",
":",
"False",
"}",
")"
] |
Execute `runOnce` with a small tolerance of 0.01 seconds so that the Prodables
can complete their other asynchronous tasks not running on the event-loop.
|
[
"Execute",
"runOnce",
"with",
"a",
"small",
"tolerance",
"of",
"0",
".",
"01",
"seconds",
"so",
"that",
"the",
"Prodables",
"can",
"complete",
"their",
"other",
"asynchronous",
"tasks",
"not",
"running",
"on",
"the",
"event",
"-",
"loop",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/loop/looper.py#L204-L217
|
234,207
|
hyperledger/indy-plenum
|
stp_core/loop/looper.py
|
Looper.run
|
def run(self, *coros: CoroWrapper):
"""
Runs an arbitrary list of coroutines in order and then quits the loop,
if not running as a context manager.
"""
if not self.running:
raise RuntimeError("not running!")
async def wrapper():
results = []
for coro in coros:
try:
if inspect.isawaitable(coro):
results.append(await coro)
elif inspect.isfunction(coro):
res = coro()
if inspect.isawaitable(res):
results.append(await res)
else:
results.append(res)
else:
raise RuntimeError(
"don't know how to run {}".format(coro))
except Exception as ex:
logger.error("Error while running coroutine {}: {}".format(coro.__name__, ex.__repr__()))
raise ex
if len(results) == 1:
return results[0]
return results
if coros:
what = wrapper()
else:
# if no coros supplied, then assume we run forever
what = self.runFut
return self.loop.run_until_complete(what)
|
python
|
def run(self, *coros: CoroWrapper):
"""
Runs an arbitrary list of coroutines in order and then quits the loop,
if not running as a context manager.
"""
if not self.running:
raise RuntimeError("not running!")
async def wrapper():
results = []
for coro in coros:
try:
if inspect.isawaitable(coro):
results.append(await coro)
elif inspect.isfunction(coro):
res = coro()
if inspect.isawaitable(res):
results.append(await res)
else:
results.append(res)
else:
raise RuntimeError(
"don't know how to run {}".format(coro))
except Exception as ex:
logger.error("Error while running coroutine {}: {}".format(coro.__name__, ex.__repr__()))
raise ex
if len(results) == 1:
return results[0]
return results
if coros:
what = wrapper()
else:
# if no coros supplied, then assume we run forever
what = self.runFut
return self.loop.run_until_complete(what)
|
[
"def",
"run",
"(",
"self",
",",
"*",
"coros",
":",
"CoroWrapper",
")",
":",
"if",
"not",
"self",
".",
"running",
":",
"raise",
"RuntimeError",
"(",
"\"not running!\"",
")",
"async",
"def",
"wrapper",
"(",
")",
":",
"results",
"=",
"[",
"]",
"for",
"coro",
"in",
"coros",
":",
"try",
":",
"if",
"inspect",
".",
"isawaitable",
"(",
"coro",
")",
":",
"results",
".",
"append",
"(",
"await",
"coro",
")",
"elif",
"inspect",
".",
"isfunction",
"(",
"coro",
")",
":",
"res",
"=",
"coro",
"(",
")",
"if",
"inspect",
".",
"isawaitable",
"(",
"res",
")",
":",
"results",
".",
"append",
"(",
"await",
"res",
")",
"else",
":",
"results",
".",
"append",
"(",
"res",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"\"don't know how to run {}\"",
".",
"format",
"(",
"coro",
")",
")",
"except",
"Exception",
"as",
"ex",
":",
"logger",
".",
"error",
"(",
"\"Error while running coroutine {}: {}\"",
".",
"format",
"(",
"coro",
".",
"__name__",
",",
"ex",
".",
"__repr__",
"(",
")",
")",
")",
"raise",
"ex",
"if",
"len",
"(",
"results",
")",
"==",
"1",
":",
"return",
"results",
"[",
"0",
"]",
"return",
"results",
"if",
"coros",
":",
"what",
"=",
"wrapper",
"(",
")",
"else",
":",
"# if no coros supplied, then assume we run forever",
"what",
"=",
"self",
".",
"runFut",
"return",
"self",
".",
"loop",
".",
"run_until_complete",
"(",
"what",
")"
] |
Runs an arbitrary list of coroutines in order and then quits the loop,
if not running as a context manager.
|
[
"Runs",
"an",
"arbitrary",
"list",
"of",
"coroutines",
"in",
"order",
"and",
"then",
"quits",
"the",
"loop",
"if",
"not",
"running",
"as",
"a",
"context",
"manager",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/loop/looper.py#L229-L263
|
234,208
|
hyperledger/indy-plenum
|
stp_core/loop/looper.py
|
Looper.shutdown
|
async def shutdown(self):
"""
Shut down this Looper.
"""
logger.display("Looper shutting down now...", extra={"cli": False})
self.running = False
start = time.perf_counter()
if not self.runFut.done():
await self.runFut
self.stopall()
logger.display("Looper shut down in {:.3f} seconds.".
format(time.perf_counter() - start), extra={"cli": False})
# Unset signal handlers, bug: https://bugs.python.org/issue23548
for sig_name in self.signals:
logger.debug("Unsetting handler for {}".format(sig_name))
sig_num = getattr(signal, sig_name)
self.loop.remove_signal_handler(sig_num)
|
python
|
async def shutdown(self):
"""
Shut down this Looper.
"""
logger.display("Looper shutting down now...", extra={"cli": False})
self.running = False
start = time.perf_counter()
if not self.runFut.done():
await self.runFut
self.stopall()
logger.display("Looper shut down in {:.3f} seconds.".
format(time.perf_counter() - start), extra={"cli": False})
# Unset signal handlers, bug: https://bugs.python.org/issue23548
for sig_name in self.signals:
logger.debug("Unsetting handler for {}".format(sig_name))
sig_num = getattr(signal, sig_name)
self.loop.remove_signal_handler(sig_num)
|
[
"async",
"def",
"shutdown",
"(",
"self",
")",
":",
"logger",
".",
"display",
"(",
"\"Looper shutting down now...\"",
",",
"extra",
"=",
"{",
"\"cli\"",
":",
"False",
"}",
")",
"self",
".",
"running",
"=",
"False",
"start",
"=",
"time",
".",
"perf_counter",
"(",
")",
"if",
"not",
"self",
".",
"runFut",
".",
"done",
"(",
")",
":",
"await",
"self",
".",
"runFut",
"self",
".",
"stopall",
"(",
")",
"logger",
".",
"display",
"(",
"\"Looper shut down in {:.3f} seconds.\"",
".",
"format",
"(",
"time",
".",
"perf_counter",
"(",
")",
"-",
"start",
")",
",",
"extra",
"=",
"{",
"\"cli\"",
":",
"False",
"}",
")",
"# Unset signal handlers, bug: https://bugs.python.org/issue23548",
"for",
"sig_name",
"in",
"self",
".",
"signals",
":",
"logger",
".",
"debug",
"(",
"\"Unsetting handler for {}\"",
".",
"format",
"(",
"sig_name",
")",
")",
"sig_num",
"=",
"getattr",
"(",
"signal",
",",
"sig_name",
")",
"self",
".",
"loop",
".",
"remove_signal_handler",
"(",
"sig_num",
")"
] |
Shut down this Looper.
|
[
"Shut",
"down",
"this",
"Looper",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/loop/looper.py#L271-L287
|
234,209
|
hyperledger/indy-plenum
|
plenum/bls/bls_bft_factory.py
|
create_default_bls_bft_factory
|
def create_default_bls_bft_factory(node):
'''
Creates a default BLS factory to instantiate BLS BFT classes.
:param node: Node instance
:return: BLS factory instance
'''
bls_keys_dir = os.path.join(node.keys_dir, node.name)
bls_crypto_factory = create_default_bls_crypto_factory(bls_keys_dir)
return BlsFactoryBftPlenum(bls_crypto_factory, node)
|
python
|
def create_default_bls_bft_factory(node):
'''
Creates a default BLS factory to instantiate BLS BFT classes.
:param node: Node instance
:return: BLS factory instance
'''
bls_keys_dir = os.path.join(node.keys_dir, node.name)
bls_crypto_factory = create_default_bls_crypto_factory(bls_keys_dir)
return BlsFactoryBftPlenum(bls_crypto_factory, node)
|
[
"def",
"create_default_bls_bft_factory",
"(",
"node",
")",
":",
"bls_keys_dir",
"=",
"os",
".",
"path",
".",
"join",
"(",
"node",
".",
"keys_dir",
",",
"node",
".",
"name",
")",
"bls_crypto_factory",
"=",
"create_default_bls_crypto_factory",
"(",
"bls_keys_dir",
")",
"return",
"BlsFactoryBftPlenum",
"(",
"bls_crypto_factory",
",",
"node",
")"
] |
Creates a default BLS factory to instantiate BLS BFT classes.
:param node: Node instance
:return: BLS factory instance
|
[
"Creates",
"a",
"default",
"BLS",
"factory",
"to",
"instantiate",
"BLS",
"BFT",
"classes",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/bls/bls_bft_factory.py#L32-L41
|
234,210
|
hyperledger/indy-plenum
|
stp_core/crypto/nacl_wrappers.py
|
SigningKey.sign
|
def sign(self, message, encoder=encoding.RawEncoder):
"""
Sign a message using this key.
:param message: [:class:`bytes`] The data to be signed.
:param encoder: A class that is used to encode the signed message.
:rtype: :class:`~SignedMessage`
"""
raw_signed = libnacl.crypto_sign(message, self._signing_key)
signature = encoder.encode(raw_signed[:libnacl.crypto_sign_BYTES])
message = encoder.encode(raw_signed[libnacl.crypto_sign_BYTES:])
signed = encoder.encode(raw_signed)
return SignedMessage._from_parts(signature, message, signed)
|
python
|
def sign(self, message, encoder=encoding.RawEncoder):
"""
Sign a message using this key.
:param message: [:class:`bytes`] The data to be signed.
:param encoder: A class that is used to encode the signed message.
:rtype: :class:`~SignedMessage`
"""
raw_signed = libnacl.crypto_sign(message, self._signing_key)
signature = encoder.encode(raw_signed[:libnacl.crypto_sign_BYTES])
message = encoder.encode(raw_signed[libnacl.crypto_sign_BYTES:])
signed = encoder.encode(raw_signed)
return SignedMessage._from_parts(signature, message, signed)
|
[
"def",
"sign",
"(",
"self",
",",
"message",
",",
"encoder",
"=",
"encoding",
".",
"RawEncoder",
")",
":",
"raw_signed",
"=",
"libnacl",
".",
"crypto_sign",
"(",
"message",
",",
"self",
".",
"_signing_key",
")",
"signature",
"=",
"encoder",
".",
"encode",
"(",
"raw_signed",
"[",
":",
"libnacl",
".",
"crypto_sign_BYTES",
"]",
")",
"message",
"=",
"encoder",
".",
"encode",
"(",
"raw_signed",
"[",
"libnacl",
".",
"crypto_sign_BYTES",
":",
"]",
")",
"signed",
"=",
"encoder",
".",
"encode",
"(",
"raw_signed",
")",
"return",
"SignedMessage",
".",
"_from_parts",
"(",
"signature",
",",
"message",
",",
"signed",
")"
] |
Sign a message using this key.
:param message: [:class:`bytes`] The data to be signed.
:param encoder: A class that is used to encode the signed message.
:rtype: :class:`~SignedMessage`
|
[
"Sign",
"a",
"message",
"using",
"this",
"key",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/crypto/nacl_wrappers.py#L162-L176
|
234,211
|
hyperledger/indy-plenum
|
stp_core/crypto/nacl_wrappers.py
|
Verifier.verify
|
def verify(self, signature, msg):
'''
Verify the message
'''
if not self.key:
return False
try:
self.key.verify(signature + msg)
except ValueError:
return False
return True
|
python
|
def verify(self, signature, msg):
'''
Verify the message
'''
if not self.key:
return False
try:
self.key.verify(signature + msg)
except ValueError:
return False
return True
|
[
"def",
"verify",
"(",
"self",
",",
"signature",
",",
"msg",
")",
":",
"if",
"not",
"self",
".",
"key",
":",
"return",
"False",
"try",
":",
"self",
".",
"key",
".",
"verify",
"(",
"signature",
"+",
"msg",
")",
"except",
"ValueError",
":",
"return",
"False",
"return",
"True"
] |
Verify the message
|
[
"Verify",
"the",
"message"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/crypto/nacl_wrappers.py#L232-L242
|
234,212
|
hyperledger/indy-plenum
|
stp_core/crypto/nacl_wrappers.py
|
Box.encrypt
|
def encrypt(self, plaintext, nonce, encoder=encoding.RawEncoder):
"""
Encrypts the plaintext message using the given `nonce` and returns
the ciphertext encoded with the encoder.
.. warning:: It is **VITALLY** important that the nonce is a nonce,
i.e. it is a number used only once for any given key. If you fail
to do this, you compromise the privacy of the messages encrypted.
:param plaintext: [:class:`bytes`] The plaintext message to encrypt
:param nonce: [:class:`bytes`] The nonce to use in the encryption
:param encoder: The encoder to use to encode the ciphertext
:rtype: [:class:`nacl.utils.EncryptedMessage`]
"""
if len(nonce) != self.NONCE_SIZE:
raise ValueError("The nonce must be exactly %s bytes long" %
self.NONCE_SIZE)
ciphertext = libnacl.crypto_box_afternm(
plaintext,
nonce,
self._shared_key,
)
encoded_nonce = encoder.encode(nonce)
encoded_ciphertext = encoder.encode(ciphertext)
return EncryptedMessage._from_parts(
encoded_nonce,
encoded_ciphertext,
encoder.encode(nonce + ciphertext),
)
|
python
|
def encrypt(self, plaintext, nonce, encoder=encoding.RawEncoder):
"""
Encrypts the plaintext message using the given `nonce` and returns
the ciphertext encoded with the encoder.
.. warning:: It is **VITALLY** important that the nonce is a nonce,
i.e. it is a number used only once for any given key. If you fail
to do this, you compromise the privacy of the messages encrypted.
:param plaintext: [:class:`bytes`] The plaintext message to encrypt
:param nonce: [:class:`bytes`] The nonce to use in the encryption
:param encoder: The encoder to use to encode the ciphertext
:rtype: [:class:`nacl.utils.EncryptedMessage`]
"""
if len(nonce) != self.NONCE_SIZE:
raise ValueError("The nonce must be exactly %s bytes long" %
self.NONCE_SIZE)
ciphertext = libnacl.crypto_box_afternm(
plaintext,
nonce,
self._shared_key,
)
encoded_nonce = encoder.encode(nonce)
encoded_ciphertext = encoder.encode(ciphertext)
return EncryptedMessage._from_parts(
encoded_nonce,
encoded_ciphertext,
encoder.encode(nonce + ciphertext),
)
|
[
"def",
"encrypt",
"(",
"self",
",",
"plaintext",
",",
"nonce",
",",
"encoder",
"=",
"encoding",
".",
"RawEncoder",
")",
":",
"if",
"len",
"(",
"nonce",
")",
"!=",
"self",
".",
"NONCE_SIZE",
":",
"raise",
"ValueError",
"(",
"\"The nonce must be exactly %s bytes long\"",
"%",
"self",
".",
"NONCE_SIZE",
")",
"ciphertext",
"=",
"libnacl",
".",
"crypto_box_afternm",
"(",
"plaintext",
",",
"nonce",
",",
"self",
".",
"_shared_key",
",",
")",
"encoded_nonce",
"=",
"encoder",
".",
"encode",
"(",
"nonce",
")",
"encoded_ciphertext",
"=",
"encoder",
".",
"encode",
"(",
"ciphertext",
")",
"return",
"EncryptedMessage",
".",
"_from_parts",
"(",
"encoded_nonce",
",",
"encoded_ciphertext",
",",
"encoder",
".",
"encode",
"(",
"nonce",
"+",
"ciphertext",
")",
",",
")"
] |
Encrypts the plaintext message using the given `nonce` and returns
the ciphertext encoded with the encoder.
.. warning:: It is **VITALLY** important that the nonce is a nonce,
i.e. it is a number used only once for any given key. If you fail
to do this, you compromise the privacy of the messages encrypted.
:param plaintext: [:class:`bytes`] The plaintext message to encrypt
:param nonce: [:class:`bytes`] The nonce to use in the encryption
:param encoder: The encoder to use to encode the ciphertext
:rtype: [:class:`nacl.utils.EncryptedMessage`]
|
[
"Encrypts",
"the",
"plaintext",
"message",
"using",
"the",
"given",
"nonce",
"and",
"returns",
"the",
"ciphertext",
"encoded",
"with",
"the",
"encoder",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/crypto/nacl_wrappers.py#L357-L388
|
234,213
|
hyperledger/indy-plenum
|
stp_core/crypto/nacl_wrappers.py
|
Box.decrypt
|
def decrypt(self, ciphertext, nonce=None, encoder=encoding.RawEncoder):
"""
Decrypts the ciphertext using the given nonce and returns the
plaintext message.
:param ciphertext: [:class:`bytes`] The encrypted message to decrypt
:param nonce: [:class:`bytes`] The nonce used when encrypting the
ciphertext
:param encoder: The encoder used to decode the ciphertext.
:rtype: [:class:`bytes`]
"""
# Decode our ciphertext
ciphertext = encoder.decode(ciphertext)
if nonce is None:
# If we were given the nonce and ciphertext combined, split them.
nonce = ciphertext[:self.NONCE_SIZE]
ciphertext = ciphertext[self.NONCE_SIZE:]
if len(nonce) != self.NONCE_SIZE:
raise ValueError("The nonce must be exactly %s bytes long" %
self.NONCE_SIZE)
plaintext = libnacl.crypto_box_open_afternm(
ciphertext,
nonce,
self._shared_key,
)
return plaintext
|
python
|
def decrypt(self, ciphertext, nonce=None, encoder=encoding.RawEncoder):
"""
Decrypts the ciphertext using the given nonce and returns the
plaintext message.
:param ciphertext: [:class:`bytes`] The encrypted message to decrypt
:param nonce: [:class:`bytes`] The nonce used when encrypting the
ciphertext
:param encoder: The encoder used to decode the ciphertext.
:rtype: [:class:`bytes`]
"""
# Decode our ciphertext
ciphertext = encoder.decode(ciphertext)
if nonce is None:
# If we were given the nonce and ciphertext combined, split them.
nonce = ciphertext[:self.NONCE_SIZE]
ciphertext = ciphertext[self.NONCE_SIZE:]
if len(nonce) != self.NONCE_SIZE:
raise ValueError("The nonce must be exactly %s bytes long" %
self.NONCE_SIZE)
plaintext = libnacl.crypto_box_open_afternm(
ciphertext,
nonce,
self._shared_key,
)
return plaintext
|
[
"def",
"decrypt",
"(",
"self",
",",
"ciphertext",
",",
"nonce",
"=",
"None",
",",
"encoder",
"=",
"encoding",
".",
"RawEncoder",
")",
":",
"# Decode our ciphertext",
"ciphertext",
"=",
"encoder",
".",
"decode",
"(",
"ciphertext",
")",
"if",
"nonce",
"is",
"None",
":",
"# If we were given the nonce and ciphertext combined, split them.",
"nonce",
"=",
"ciphertext",
"[",
":",
"self",
".",
"NONCE_SIZE",
"]",
"ciphertext",
"=",
"ciphertext",
"[",
"self",
".",
"NONCE_SIZE",
":",
"]",
"if",
"len",
"(",
"nonce",
")",
"!=",
"self",
".",
"NONCE_SIZE",
":",
"raise",
"ValueError",
"(",
"\"The nonce must be exactly %s bytes long\"",
"%",
"self",
".",
"NONCE_SIZE",
")",
"plaintext",
"=",
"libnacl",
".",
"crypto_box_open_afternm",
"(",
"ciphertext",
",",
"nonce",
",",
"self",
".",
"_shared_key",
",",
")",
"return",
"plaintext"
] |
Decrypts the ciphertext using the given nonce and returns the
plaintext message.
:param ciphertext: [:class:`bytes`] The encrypted message to decrypt
:param nonce: [:class:`bytes`] The nonce used when encrypting the
ciphertext
:param encoder: The encoder used to decode the ciphertext.
:rtype: [:class:`bytes`]
|
[
"Decrypts",
"the",
"ciphertext",
"using",
"the",
"given",
"nonce",
"and",
"returns",
"the",
"plaintext",
"message",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/crypto/nacl_wrappers.py#L390-L419
|
234,214
|
hyperledger/indy-plenum
|
stp_core/crypto/nacl_wrappers.py
|
Privateer.decrypt
|
def decrypt(self, cipher, nonce, pubkey, dehex=False):
'''
Return decrypted msg contained in cypher using nonce and shared key
generated from .key and pubkey.
If pubkey is hex encoded it is converted first
If dehex is True then use HexEncoder otherwise use RawEncoder
Intended for the owner of .key
cypher is string
nonce is string
pub is Publican instance
'''
if not isinstance(pubkey, PublicKey):
if len(pubkey) == 32:
pubkey = PublicKey(pubkey, encoding.RawEncoder)
else:
pubkey = PublicKey(pubkey, encoding.HexEncoder)
box = Box(self.key, pubkey)
decoder = encoding.HexEncoder if dehex else encoding.RawEncoder
if dehex and len(nonce) != box.NONCE_SIZE:
nonce = decoder.decode(nonce)
return box.decrypt(cipher, nonce, decoder)
|
python
|
def decrypt(self, cipher, nonce, pubkey, dehex=False):
'''
Return decrypted msg contained in cypher using nonce and shared key
generated from .key and pubkey.
If pubkey is hex encoded it is converted first
If dehex is True then use HexEncoder otherwise use RawEncoder
Intended for the owner of .key
cypher is string
nonce is string
pub is Publican instance
'''
if not isinstance(pubkey, PublicKey):
if len(pubkey) == 32:
pubkey = PublicKey(pubkey, encoding.RawEncoder)
else:
pubkey = PublicKey(pubkey, encoding.HexEncoder)
box = Box(self.key, pubkey)
decoder = encoding.HexEncoder if dehex else encoding.RawEncoder
if dehex and len(nonce) != box.NONCE_SIZE:
nonce = decoder.decode(nonce)
return box.decrypt(cipher, nonce, decoder)
|
[
"def",
"decrypt",
"(",
"self",
",",
"cipher",
",",
"nonce",
",",
"pubkey",
",",
"dehex",
"=",
"False",
")",
":",
"if",
"not",
"isinstance",
"(",
"pubkey",
",",
"PublicKey",
")",
":",
"if",
"len",
"(",
"pubkey",
")",
"==",
"32",
":",
"pubkey",
"=",
"PublicKey",
"(",
"pubkey",
",",
"encoding",
".",
"RawEncoder",
")",
"else",
":",
"pubkey",
"=",
"PublicKey",
"(",
"pubkey",
",",
"encoding",
".",
"HexEncoder",
")",
"box",
"=",
"Box",
"(",
"self",
".",
"key",
",",
"pubkey",
")",
"decoder",
"=",
"encoding",
".",
"HexEncoder",
"if",
"dehex",
"else",
"encoding",
".",
"RawEncoder",
"if",
"dehex",
"and",
"len",
"(",
"nonce",
")",
"!=",
"box",
".",
"NONCE_SIZE",
":",
"nonce",
"=",
"decoder",
".",
"decode",
"(",
"nonce",
")",
"return",
"box",
".",
"decrypt",
"(",
"cipher",
",",
"nonce",
",",
"decoder",
")"
] |
Return decrypted msg contained in cypher using nonce and shared key
generated from .key and pubkey.
If pubkey is hex encoded it is converted first
If dehex is True then use HexEncoder otherwise use RawEncoder
Intended for the owner of .key
cypher is string
nonce is string
pub is Publican instance
|
[
"Return",
"decrypted",
"msg",
"contained",
"in",
"cypher",
"using",
"nonce",
"and",
"shared",
"key",
"generated",
"from",
".",
"key",
"and",
"pubkey",
".",
"If",
"pubkey",
"is",
"hex",
"encoded",
"it",
"is",
"converted",
"first",
"If",
"dehex",
"is",
"True",
"then",
"use",
"HexEncoder",
"otherwise",
"use",
"RawEncoder"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/crypto/nacl_wrappers.py#L496-L518
|
234,215
|
hyperledger/indy-plenum
|
plenum/common/config_util.py
|
getInstalledConfig
|
def getInstalledConfig(installDir, configFile):
"""
Reads config from the installation directory of Plenum.
:param installDir: installation directory of Plenum
:param configFile: name of the configuration file
:raises: FileNotFoundError
:return: the configuration as a python object
"""
configPath = os.path.join(installDir, configFile)
if not os.path.exists(configPath):
raise FileNotFoundError("No file found at location {}".
format(configPath))
spec = spec_from_file_location(configFile, configPath)
config = module_from_spec(spec)
spec.loader.exec_module(config)
return config
|
python
|
def getInstalledConfig(installDir, configFile):
"""
Reads config from the installation directory of Plenum.
:param installDir: installation directory of Plenum
:param configFile: name of the configuration file
:raises: FileNotFoundError
:return: the configuration as a python object
"""
configPath = os.path.join(installDir, configFile)
if not os.path.exists(configPath):
raise FileNotFoundError("No file found at location {}".
format(configPath))
spec = spec_from_file_location(configFile, configPath)
config = module_from_spec(spec)
spec.loader.exec_module(config)
return config
|
[
"def",
"getInstalledConfig",
"(",
"installDir",
",",
"configFile",
")",
":",
"configPath",
"=",
"os",
".",
"path",
".",
"join",
"(",
"installDir",
",",
"configFile",
")",
"if",
"not",
"os",
".",
"path",
".",
"exists",
"(",
"configPath",
")",
":",
"raise",
"FileNotFoundError",
"(",
"\"No file found at location {}\"",
".",
"format",
"(",
"configPath",
")",
")",
"spec",
"=",
"spec_from_file_location",
"(",
"configFile",
",",
"configPath",
")",
"config",
"=",
"module_from_spec",
"(",
"spec",
")",
"spec",
".",
"loader",
".",
"exec_module",
"(",
"config",
")",
"return",
"config"
] |
Reads config from the installation directory of Plenum.
:param installDir: installation directory of Plenum
:param configFile: name of the configuration file
:raises: FileNotFoundError
:return: the configuration as a python object
|
[
"Reads",
"config",
"from",
"the",
"installation",
"directory",
"of",
"Plenum",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/config_util.py#L11-L27
|
234,216
|
hyperledger/indy-plenum
|
plenum/common/config_util.py
|
_getConfig
|
def _getConfig(general_config_dir: str = None):
"""
Reads a file called config.py in the project directory
:raises: FileNotFoundError
:return: the configuration as a python object
"""
stp_config = STPConfig()
plenum_config = import_module("plenum.config")
config = stp_config
config.__dict__.update(plenum_config.__dict__)
if general_config_dir:
config.GENERAL_CONFIG_DIR = general_config_dir
if not config.GENERAL_CONFIG_DIR:
raise Exception('GENERAL_CONFIG_DIR must be set')
extend_with_external_config(config, (config.GENERAL_CONFIG_DIR,
config.GENERAL_CONFIG_FILE))
# "unsafe" is a set of attributes that can set certain behaviors that
# are not safe, for example, 'disable_view_change' disables view changes
# from happening. This might be useful in testing scenarios, but never
# in a live network.
if not hasattr(config, 'unsafe'):
setattr(config, 'unsafe', set())
return config
|
python
|
def _getConfig(general_config_dir: str = None):
"""
Reads a file called config.py in the project directory
:raises: FileNotFoundError
:return: the configuration as a python object
"""
stp_config = STPConfig()
plenum_config = import_module("plenum.config")
config = stp_config
config.__dict__.update(plenum_config.__dict__)
if general_config_dir:
config.GENERAL_CONFIG_DIR = general_config_dir
if not config.GENERAL_CONFIG_DIR:
raise Exception('GENERAL_CONFIG_DIR must be set')
extend_with_external_config(config, (config.GENERAL_CONFIG_DIR,
config.GENERAL_CONFIG_FILE))
# "unsafe" is a set of attributes that can set certain behaviors that
# are not safe, for example, 'disable_view_change' disables view changes
# from happening. This might be useful in testing scenarios, but never
# in a live network.
if not hasattr(config, 'unsafe'):
setattr(config, 'unsafe', set())
return config
|
[
"def",
"_getConfig",
"(",
"general_config_dir",
":",
"str",
"=",
"None",
")",
":",
"stp_config",
"=",
"STPConfig",
"(",
")",
"plenum_config",
"=",
"import_module",
"(",
"\"plenum.config\"",
")",
"config",
"=",
"stp_config",
"config",
".",
"__dict__",
".",
"update",
"(",
"plenum_config",
".",
"__dict__",
")",
"if",
"general_config_dir",
":",
"config",
".",
"GENERAL_CONFIG_DIR",
"=",
"general_config_dir",
"if",
"not",
"config",
".",
"GENERAL_CONFIG_DIR",
":",
"raise",
"Exception",
"(",
"'GENERAL_CONFIG_DIR must be set'",
")",
"extend_with_external_config",
"(",
"config",
",",
"(",
"config",
".",
"GENERAL_CONFIG_DIR",
",",
"config",
".",
"GENERAL_CONFIG_FILE",
")",
")",
"# \"unsafe\" is a set of attributes that can set certain behaviors that",
"# are not safe, for example, 'disable_view_change' disables view changes",
"# from happening. This might be useful in testing scenarios, but never",
"# in a live network.",
"if",
"not",
"hasattr",
"(",
"config",
",",
"'unsafe'",
")",
":",
"setattr",
"(",
"config",
",",
"'unsafe'",
",",
"set",
"(",
")",
")",
"return",
"config"
] |
Reads a file called config.py in the project directory
:raises: FileNotFoundError
:return: the configuration as a python object
|
[
"Reads",
"a",
"file",
"called",
"config",
".",
"py",
"in",
"the",
"project",
"directory"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/config_util.py#L68-L95
|
234,217
|
hyperledger/indy-plenum
|
plenum/server/router.py
|
Router.getFunc
|
def getFunc(self, o: Any) -> Callable:
"""
Get the next function from the list of routes that is capable of
processing o's type.
:param o: the object to process
:return: the next function
"""
for cls, func in self.routes.items():
if isinstance(o, cls):
return func
logger.error("Unhandled msg {}, available handlers are:".format(o))
for cls in self.routes.keys():
logger.error(" {}".format(cls))
raise RuntimeError("unhandled msg: {}".format(o))
|
python
|
def getFunc(self, o: Any) -> Callable:
"""
Get the next function from the list of routes that is capable of
processing o's type.
:param o: the object to process
:return: the next function
"""
for cls, func in self.routes.items():
if isinstance(o, cls):
return func
logger.error("Unhandled msg {}, available handlers are:".format(o))
for cls in self.routes.keys():
logger.error(" {}".format(cls))
raise RuntimeError("unhandled msg: {}".format(o))
|
[
"def",
"getFunc",
"(",
"self",
",",
"o",
":",
"Any",
")",
"->",
"Callable",
":",
"for",
"cls",
",",
"func",
"in",
"self",
".",
"routes",
".",
"items",
"(",
")",
":",
"if",
"isinstance",
"(",
"o",
",",
"cls",
")",
":",
"return",
"func",
"logger",
".",
"error",
"(",
"\"Unhandled msg {}, available handlers are:\"",
".",
"format",
"(",
"o",
")",
")",
"for",
"cls",
"in",
"self",
".",
"routes",
".",
"keys",
"(",
")",
":",
"logger",
".",
"error",
"(",
"\" {}\"",
".",
"format",
"(",
"cls",
")",
")",
"raise",
"RuntimeError",
"(",
"\"unhandled msg: {}\"",
".",
"format",
"(",
"o",
")",
")"
] |
Get the next function from the list of routes that is capable of
processing o's type.
:param o: the object to process
:return: the next function
|
[
"Get",
"the",
"next",
"function",
"from",
"the",
"list",
"of",
"routes",
"that",
"is",
"capable",
"of",
"processing",
"o",
"s",
"type",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/router.py#L46-L60
|
234,218
|
hyperledger/indy-plenum
|
plenum/server/router.py
|
Router.handleSync
|
def handleSync(self, msg: Any) -> Any:
"""
Pass the message as an argument to the function defined in `routes`.
If the msg is a tuple, pass the values as multiple arguments to the function.
:param msg: tuple of object and callable
"""
# If a plain python tuple and not a named tuple, a better alternative
# would be to create a named entity with the 3 characteristics below
# TODO: non-obvious tuple, re-factor!
if isinstance(msg, tuple) and len(
msg) == 2 and not hasattr(msg, '_field_types'):
return self.getFunc(msg[0])(*msg)
else:
return self.getFunc(msg)(msg)
|
python
|
def handleSync(self, msg: Any) -> Any:
"""
Pass the message as an argument to the function defined in `routes`.
If the msg is a tuple, pass the values as multiple arguments to the function.
:param msg: tuple of object and callable
"""
# If a plain python tuple and not a named tuple, a better alternative
# would be to create a named entity with the 3 characteristics below
# TODO: non-obvious tuple, re-factor!
if isinstance(msg, tuple) and len(
msg) == 2 and not hasattr(msg, '_field_types'):
return self.getFunc(msg[0])(*msg)
else:
return self.getFunc(msg)(msg)
|
[
"def",
"handleSync",
"(",
"self",
",",
"msg",
":",
"Any",
")",
"->",
"Any",
":",
"# If a plain python tuple and not a named tuple, a better alternative",
"# would be to create a named entity with the 3 characteristics below",
"# TODO: non-obvious tuple, re-factor!",
"if",
"isinstance",
"(",
"msg",
",",
"tuple",
")",
"and",
"len",
"(",
"msg",
")",
"==",
"2",
"and",
"not",
"hasattr",
"(",
"msg",
",",
"'_field_types'",
")",
":",
"return",
"self",
".",
"getFunc",
"(",
"msg",
"[",
"0",
"]",
")",
"(",
"*",
"msg",
")",
"else",
":",
"return",
"self",
".",
"getFunc",
"(",
"msg",
")",
"(",
"msg",
")"
] |
Pass the message as an argument to the function defined in `routes`.
If the msg is a tuple, pass the values as multiple arguments to the function.
:param msg: tuple of object and callable
|
[
"Pass",
"the",
"message",
"as",
"an",
"argument",
"to",
"the",
"function",
"defined",
"in",
"routes",
".",
"If",
"the",
"msg",
"is",
"a",
"tuple",
"pass",
"the",
"values",
"as",
"multiple",
"arguments",
"to",
"the",
"function",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/router.py#L63-L77
|
234,219
|
hyperledger/indy-plenum
|
plenum/server/router.py
|
Router.handle
|
async def handle(self, msg: Any) -> Any:
"""
Handle both sync and async functions.
:param msg: a message
:return: the result of execution of the function corresponding to this message's type
"""
res = self.handleSync(msg)
if isawaitable(res):
return await res
else:
return res
|
python
|
async def handle(self, msg: Any) -> Any:
"""
Handle both sync and async functions.
:param msg: a message
:return: the result of execution of the function corresponding to this message's type
"""
res = self.handleSync(msg)
if isawaitable(res):
return await res
else:
return res
|
[
"async",
"def",
"handle",
"(",
"self",
",",
"msg",
":",
"Any",
")",
"->",
"Any",
":",
"res",
"=",
"self",
".",
"handleSync",
"(",
"msg",
")",
"if",
"isawaitable",
"(",
"res",
")",
":",
"return",
"await",
"res",
"else",
":",
"return",
"res"
] |
Handle both sync and async functions.
:param msg: a message
:return: the result of execution of the function corresponding to this message's type
|
[
"Handle",
"both",
"sync",
"and",
"async",
"functions",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/router.py#L79-L90
|
234,220
|
hyperledger/indy-plenum
|
plenum/server/router.py
|
Router.handleAll
|
async def handleAll(self, deq: deque, limit=None) -> int:
"""
Handle all items in a deque. Can call asynchronous handlers.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
"""
count = 0
while deq and (not limit or count < limit):
count += 1
item = deq.popleft()
await self.handle(item)
return count
|
python
|
async def handleAll(self, deq: deque, limit=None) -> int:
"""
Handle all items in a deque. Can call asynchronous handlers.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
"""
count = 0
while deq and (not limit or count < limit):
count += 1
item = deq.popleft()
await self.handle(item)
return count
|
[
"async",
"def",
"handleAll",
"(",
"self",
",",
"deq",
":",
"deque",
",",
"limit",
"=",
"None",
")",
"->",
"int",
":",
"count",
"=",
"0",
"while",
"deq",
"and",
"(",
"not",
"limit",
"or",
"count",
"<",
"limit",
")",
":",
"count",
"+=",
"1",
"item",
"=",
"deq",
".",
"popleft",
"(",
")",
"await",
"self",
".",
"handle",
"(",
"item",
")",
"return",
"count"
] |
Handle all items in a deque. Can call asynchronous handlers.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
|
[
"Handle",
"all",
"items",
"in",
"a",
"deque",
".",
"Can",
"call",
"asynchronous",
"handlers",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/router.py#L92-L105
|
234,221
|
hyperledger/indy-plenum
|
plenum/server/router.py
|
Router.handleAllSync
|
def handleAllSync(self, deq: deque, limit=None) -> int:
"""
Synchronously handle all items in a deque.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
"""
count = 0
while deq and (not limit or count < limit):
count += 1
msg = deq.popleft()
self.handleSync(msg)
return count
|
python
|
def handleAllSync(self, deq: deque, limit=None) -> int:
"""
Synchronously handle all items in a deque.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
"""
count = 0
while deq and (not limit or count < limit):
count += 1
msg = deq.popleft()
self.handleSync(msg)
return count
|
[
"def",
"handleAllSync",
"(",
"self",
",",
"deq",
":",
"deque",
",",
"limit",
"=",
"None",
")",
"->",
"int",
":",
"count",
"=",
"0",
"while",
"deq",
"and",
"(",
"not",
"limit",
"or",
"count",
"<",
"limit",
")",
":",
"count",
"+=",
"1",
"msg",
"=",
"deq",
".",
"popleft",
"(",
")",
"self",
".",
"handleSync",
"(",
"msg",
")",
"return",
"count"
] |
Synchronously handle all items in a deque.
:param deq: a deque of items to be handled by this router
:param limit: the number of items in the deque to the handled
:return: the number of items handled successfully
|
[
"Synchronously",
"handle",
"all",
"items",
"in",
"a",
"deque",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/router.py#L107-L120
|
234,222
|
hyperledger/indy-plenum
|
ledger/compact_merkle_tree.py
|
CompactMerkleTree.load
|
def load(self, other: merkle_tree.MerkleTree):
"""Load this tree from a dumb data object for serialisation.
The object must have attributes tree_size:int and hashes:list.
"""
self._update(other.tree_size, other.hashes)
|
python
|
def load(self, other: merkle_tree.MerkleTree):
"""Load this tree from a dumb data object for serialisation.
The object must have attributes tree_size:int and hashes:list.
"""
self._update(other.tree_size, other.hashes)
|
[
"def",
"load",
"(",
"self",
",",
"other",
":",
"merkle_tree",
".",
"MerkleTree",
")",
":",
"self",
".",
"_update",
"(",
"other",
".",
"tree_size",
",",
"other",
".",
"hashes",
")"
] |
Load this tree from a dumb data object for serialisation.
The object must have attributes tree_size:int and hashes:list.
|
[
"Load",
"this",
"tree",
"from",
"a",
"dumb",
"data",
"object",
"for",
"serialisation",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/compact_merkle_tree.py#L47-L52
|
234,223
|
hyperledger/indy-plenum
|
ledger/compact_merkle_tree.py
|
CompactMerkleTree.save
|
def save(self, other: merkle_tree.MerkleTree):
"""Save this tree into a dumb data object for serialisation.
The object must have attributes tree_size:int and hashes:list.
"""
other.__tree_size = self.__tree_size
other.__hashes = self.__hashes
|
python
|
def save(self, other: merkle_tree.MerkleTree):
"""Save this tree into a dumb data object for serialisation.
The object must have attributes tree_size:int and hashes:list.
"""
other.__tree_size = self.__tree_size
other.__hashes = self.__hashes
|
[
"def",
"save",
"(",
"self",
",",
"other",
":",
"merkle_tree",
".",
"MerkleTree",
")",
":",
"other",
".",
"__tree_size",
"=",
"self",
".",
"__tree_size",
"other",
".",
"__hashes",
"=",
"self",
".",
"__hashes"
] |
Save this tree into a dumb data object for serialisation.
The object must have attributes tree_size:int and hashes:list.
|
[
"Save",
"this",
"tree",
"into",
"a",
"dumb",
"data",
"object",
"for",
"serialisation",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/compact_merkle_tree.py#L54-L60
|
234,224
|
hyperledger/indy-plenum
|
ledger/compact_merkle_tree.py
|
CompactMerkleTree.append
|
def append(self, new_leaf: bytes) -> List[bytes]:
"""Append a new leaf onto the end of this tree and return the
audit path"""
auditPath = list(reversed(self.__hashes))
self._push_subtree([new_leaf])
return auditPath
|
python
|
def append(self, new_leaf: bytes) -> List[bytes]:
"""Append a new leaf onto the end of this tree and return the
audit path"""
auditPath = list(reversed(self.__hashes))
self._push_subtree([new_leaf])
return auditPath
|
[
"def",
"append",
"(",
"self",
",",
"new_leaf",
":",
"bytes",
")",
"->",
"List",
"[",
"bytes",
"]",
":",
"auditPath",
"=",
"list",
"(",
"reversed",
"(",
"self",
".",
"__hashes",
")",
")",
"self",
".",
"_push_subtree",
"(",
"[",
"new_leaf",
"]",
")",
"return",
"auditPath"
] |
Append a new leaf onto the end of this tree and return the
audit path
|
[
"Append",
"a",
"new",
"leaf",
"onto",
"the",
"end",
"of",
"this",
"tree",
"and",
"return",
"the",
"audit",
"path"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/compact_merkle_tree.py#L155-L160
|
234,225
|
hyperledger/indy-plenum
|
ledger/compact_merkle_tree.py
|
CompactMerkleTree.extend
|
def extend(self, new_leaves: List[bytes]):
"""Extend this tree with new_leaves on the end.
The algorithm works by using _push_subtree() as a primitive, calling
it with the maximum number of allowed leaves until we can add the
remaining leaves as a valid entire (non-full) subtree in one go.
"""
size = len(new_leaves)
final_size = self.tree_size + size
idx = 0
while True:
# keep pushing subtrees until mintree_size > remaining
max_h = self.__mintree_height
max_size = 1 << (max_h - 1) if max_h > 0 else 0
if max_h > 0 and size - idx >= max_size:
self._push_subtree(new_leaves[idx:idx + max_size])
idx += max_size
else:
break
# fill in rest of tree in one go, now that we can
if idx < size:
root_hash, hashes = self.__hasher._hash_full(new_leaves, idx, size)
self._update(final_size, self.hashes + hashes)
assert self.tree_size == final_size
|
python
|
def extend(self, new_leaves: List[bytes]):
"""Extend this tree with new_leaves on the end.
The algorithm works by using _push_subtree() as a primitive, calling
it with the maximum number of allowed leaves until we can add the
remaining leaves as a valid entire (non-full) subtree in one go.
"""
size = len(new_leaves)
final_size = self.tree_size + size
idx = 0
while True:
# keep pushing subtrees until mintree_size > remaining
max_h = self.__mintree_height
max_size = 1 << (max_h - 1) if max_h > 0 else 0
if max_h > 0 and size - idx >= max_size:
self._push_subtree(new_leaves[idx:idx + max_size])
idx += max_size
else:
break
# fill in rest of tree in one go, now that we can
if idx < size:
root_hash, hashes = self.__hasher._hash_full(new_leaves, idx, size)
self._update(final_size, self.hashes + hashes)
assert self.tree_size == final_size
|
[
"def",
"extend",
"(",
"self",
",",
"new_leaves",
":",
"List",
"[",
"bytes",
"]",
")",
":",
"size",
"=",
"len",
"(",
"new_leaves",
")",
"final_size",
"=",
"self",
".",
"tree_size",
"+",
"size",
"idx",
"=",
"0",
"while",
"True",
":",
"# keep pushing subtrees until mintree_size > remaining",
"max_h",
"=",
"self",
".",
"__mintree_height",
"max_size",
"=",
"1",
"<<",
"(",
"max_h",
"-",
"1",
")",
"if",
"max_h",
">",
"0",
"else",
"0",
"if",
"max_h",
">",
"0",
"and",
"size",
"-",
"idx",
">=",
"max_size",
":",
"self",
".",
"_push_subtree",
"(",
"new_leaves",
"[",
"idx",
":",
"idx",
"+",
"max_size",
"]",
")",
"idx",
"+=",
"max_size",
"else",
":",
"break",
"# fill in rest of tree in one go, now that we can",
"if",
"idx",
"<",
"size",
":",
"root_hash",
",",
"hashes",
"=",
"self",
".",
"__hasher",
".",
"_hash_full",
"(",
"new_leaves",
",",
"idx",
",",
"size",
")",
"self",
".",
"_update",
"(",
"final_size",
",",
"self",
".",
"hashes",
"+",
"hashes",
")",
"assert",
"self",
".",
"tree_size",
"==",
"final_size"
] |
Extend this tree with new_leaves on the end.
The algorithm works by using _push_subtree() as a primitive, calling
it with the maximum number of allowed leaves until we can add the
remaining leaves as a valid entire (non-full) subtree in one go.
|
[
"Extend",
"this",
"tree",
"with",
"new_leaves",
"on",
"the",
"end",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/compact_merkle_tree.py#L162-L185
|
234,226
|
hyperledger/indy-plenum
|
ledger/compact_merkle_tree.py
|
CompactMerkleTree.extended
|
def extended(self, new_leaves: List[bytes]):
"""Returns a new tree equal to this tree extended with new_leaves."""
new_tree = self.__copy__()
new_tree.extend(new_leaves)
return new_tree
|
python
|
def extended(self, new_leaves: List[bytes]):
"""Returns a new tree equal to this tree extended with new_leaves."""
new_tree = self.__copy__()
new_tree.extend(new_leaves)
return new_tree
|
[
"def",
"extended",
"(",
"self",
",",
"new_leaves",
":",
"List",
"[",
"bytes",
"]",
")",
":",
"new_tree",
"=",
"self",
".",
"__copy__",
"(",
")",
"new_tree",
".",
"extend",
"(",
"new_leaves",
")",
"return",
"new_tree"
] |
Returns a new tree equal to this tree extended with new_leaves.
|
[
"Returns",
"a",
"new",
"tree",
"equal",
"to",
"this",
"tree",
"extended",
"with",
"new_leaves",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/compact_merkle_tree.py#L187-L191
|
234,227
|
hyperledger/indy-plenum
|
ledger/compact_merkle_tree.py
|
CompactMerkleTree.verify_consistency
|
def verify_consistency(self, expected_leaf_count) -> bool:
"""
Check that the tree has same leaf count as expected and the
number of nodes are also as expected
"""
if expected_leaf_count != self.leafCount:
raise ConsistencyVerificationFailed()
if self.get_expected_node_count(self.leafCount) != self.nodeCount:
raise ConsistencyVerificationFailed()
return True
|
python
|
def verify_consistency(self, expected_leaf_count) -> bool:
"""
Check that the tree has same leaf count as expected and the
number of nodes are also as expected
"""
if expected_leaf_count != self.leafCount:
raise ConsistencyVerificationFailed()
if self.get_expected_node_count(self.leafCount) != self.nodeCount:
raise ConsistencyVerificationFailed()
return True
|
[
"def",
"verify_consistency",
"(",
"self",
",",
"expected_leaf_count",
")",
"->",
"bool",
":",
"if",
"expected_leaf_count",
"!=",
"self",
".",
"leafCount",
":",
"raise",
"ConsistencyVerificationFailed",
"(",
")",
"if",
"self",
".",
"get_expected_node_count",
"(",
"self",
".",
"leafCount",
")",
"!=",
"self",
".",
"nodeCount",
":",
"raise",
"ConsistencyVerificationFailed",
"(",
")",
"return",
"True"
] |
Check that the tree has same leaf count as expected and the
number of nodes are also as expected
|
[
"Check",
"that",
"the",
"tree",
"has",
"same",
"leaf",
"count",
"as",
"expected",
"and",
"the",
"number",
"of",
"nodes",
"are",
"also",
"as",
"expected"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/compact_merkle_tree.py#L280-L289
|
234,228
|
hyperledger/indy-plenum
|
state/util/utils.py
|
isHex
|
def isHex(val: str) -> bool:
"""
Return whether the given str represents a hex value or not
:param val: the string to check
:return: whether the given str represents a hex value
"""
if isinstance(val, bytes):
# only decodes utf-8 string
try:
val = val.decode()
except ValueError:
return False
return isinstance(val, str) and all(c in string.hexdigits for c in val)
|
python
|
def isHex(val: str) -> bool:
"""
Return whether the given str represents a hex value or not
:param val: the string to check
:return: whether the given str represents a hex value
"""
if isinstance(val, bytes):
# only decodes utf-8 string
try:
val = val.decode()
except ValueError:
return False
return isinstance(val, str) and all(c in string.hexdigits for c in val)
|
[
"def",
"isHex",
"(",
"val",
":",
"str",
")",
"->",
"bool",
":",
"if",
"isinstance",
"(",
"val",
",",
"bytes",
")",
":",
"# only decodes utf-8 string",
"try",
":",
"val",
"=",
"val",
".",
"decode",
"(",
")",
"except",
"ValueError",
":",
"return",
"False",
"return",
"isinstance",
"(",
"val",
",",
"str",
")",
"and",
"all",
"(",
"c",
"in",
"string",
".",
"hexdigits",
"for",
"c",
"in",
"val",
")"
] |
Return whether the given str represents a hex value or not
:param val: the string to check
:return: whether the given str represents a hex value
|
[
"Return",
"whether",
"the",
"given",
"str",
"represents",
"a",
"hex",
"value",
"or",
"not"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/state/util/utils.py#L80-L93
|
234,229
|
hyperledger/indy-plenum
|
plenum/common/latency_measurements.py
|
EMALatencyMeasurementForEachClient._accumulate
|
def _accumulate(self, old_accum, next_val):
"""
Implement exponential moving average
"""
return old_accum * (1 - self.alpha) + next_val * self.alpha
|
python
|
def _accumulate(self, old_accum, next_val):
"""
Implement exponential moving average
"""
return old_accum * (1 - self.alpha) + next_val * self.alpha
|
[
"def",
"_accumulate",
"(",
"self",
",",
"old_accum",
",",
"next_val",
")",
":",
"return",
"old_accum",
"*",
"(",
"1",
"-",
"self",
".",
"alpha",
")",
"+",
"next_val",
"*",
"self",
".",
"alpha"
] |
Implement exponential moving average
|
[
"Implement",
"exponential",
"moving",
"average"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/latency_measurements.py#L36-L40
|
234,230
|
hyperledger/indy-plenum
|
ledger/hash_stores/hash_store.py
|
HashStore.getNodePosition
|
def getNodePosition(cls, start, height=None) -> int:
"""
Calculates node position based on start and height
:param start: The sequence number of the first leaf under this tree.
:param height: Height of this node in the merkle tree
:return: the node's position
"""
pwr = highest_bit_set(start) - 1
height = height or pwr
if count_bits_set(start) == 1:
adj = height - pwr
return start - 1 + adj
else:
c = pow(2, pwr)
return cls.getNodePosition(c, pwr) + \
cls.getNodePosition(start - c, height)
|
python
|
def getNodePosition(cls, start, height=None) -> int:
"""
Calculates node position based on start and height
:param start: The sequence number of the first leaf under this tree.
:param height: Height of this node in the merkle tree
:return: the node's position
"""
pwr = highest_bit_set(start) - 1
height = height or pwr
if count_bits_set(start) == 1:
adj = height - pwr
return start - 1 + adj
else:
c = pow(2, pwr)
return cls.getNodePosition(c, pwr) + \
cls.getNodePosition(start - c, height)
|
[
"def",
"getNodePosition",
"(",
"cls",
",",
"start",
",",
"height",
"=",
"None",
")",
"->",
"int",
":",
"pwr",
"=",
"highest_bit_set",
"(",
"start",
")",
"-",
"1",
"height",
"=",
"height",
"or",
"pwr",
"if",
"count_bits_set",
"(",
"start",
")",
"==",
"1",
":",
"adj",
"=",
"height",
"-",
"pwr",
"return",
"start",
"-",
"1",
"+",
"adj",
"else",
":",
"c",
"=",
"pow",
"(",
"2",
",",
"pwr",
")",
"return",
"cls",
".",
"getNodePosition",
"(",
"c",
",",
"pwr",
")",
"+",
"cls",
".",
"getNodePosition",
"(",
"start",
"-",
"c",
",",
"height",
")"
] |
Calculates node position based on start and height
:param start: The sequence number of the first leaf under this tree.
:param height: Height of this node in the merkle tree
:return: the node's position
|
[
"Calculates",
"node",
"position",
"based",
"on",
"start",
"and",
"height"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/hash_stores/hash_store.py#L88-L104
|
234,231
|
hyperledger/indy-plenum
|
ledger/hash_stores/hash_store.py
|
HashStore.getPath
|
def getPath(cls, seqNo, offset=0):
"""
Get the audit path of the leaf at the position specified by serNo.
:param seqNo: sequence number of the leaf to calculate the path for
:param offset: the sequence number of the node from where the path
should begin.
:return: tuple of leafs and nodes
"""
if offset >= seqNo:
raise ValueError("Offset should be less than serial number")
pwr = highest_bit_set(seqNo - 1 - offset) - 1
if pwr <= 0:
if seqNo % 2 == 0:
return [seqNo - 1], []
else:
return [], []
c = pow(2, pwr) + offset
leafs, nodes = cls.getPath(seqNo, c)
nodes.append(cls.getNodePosition(c, pwr))
return leafs, nodes
|
python
|
def getPath(cls, seqNo, offset=0):
"""
Get the audit path of the leaf at the position specified by serNo.
:param seqNo: sequence number of the leaf to calculate the path for
:param offset: the sequence number of the node from where the path
should begin.
:return: tuple of leafs and nodes
"""
if offset >= seqNo:
raise ValueError("Offset should be less than serial number")
pwr = highest_bit_set(seqNo - 1 - offset) - 1
if pwr <= 0:
if seqNo % 2 == 0:
return [seqNo - 1], []
else:
return [], []
c = pow(2, pwr) + offset
leafs, nodes = cls.getPath(seqNo, c)
nodes.append(cls.getNodePosition(c, pwr))
return leafs, nodes
|
[
"def",
"getPath",
"(",
"cls",
",",
"seqNo",
",",
"offset",
"=",
"0",
")",
":",
"if",
"offset",
">=",
"seqNo",
":",
"raise",
"ValueError",
"(",
"\"Offset should be less than serial number\"",
")",
"pwr",
"=",
"highest_bit_set",
"(",
"seqNo",
"-",
"1",
"-",
"offset",
")",
"-",
"1",
"if",
"pwr",
"<=",
"0",
":",
"if",
"seqNo",
"%",
"2",
"==",
"0",
":",
"return",
"[",
"seqNo",
"-",
"1",
"]",
",",
"[",
"]",
"else",
":",
"return",
"[",
"]",
",",
"[",
"]",
"c",
"=",
"pow",
"(",
"2",
",",
"pwr",
")",
"+",
"offset",
"leafs",
",",
"nodes",
"=",
"cls",
".",
"getPath",
"(",
"seqNo",
",",
"c",
")",
"nodes",
".",
"append",
"(",
"cls",
".",
"getNodePosition",
"(",
"c",
",",
"pwr",
")",
")",
"return",
"leafs",
",",
"nodes"
] |
Get the audit path of the leaf at the position specified by serNo.
:param seqNo: sequence number of the leaf to calculate the path for
:param offset: the sequence number of the node from where the path
should begin.
:return: tuple of leafs and nodes
|
[
"Get",
"the",
"audit",
"path",
"of",
"the",
"leaf",
"at",
"the",
"position",
"specified",
"by",
"serNo",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/hash_stores/hash_store.py#L107-L127
|
234,232
|
hyperledger/indy-plenum
|
ledger/hash_stores/hash_store.py
|
HashStore.readNodeByTree
|
def readNodeByTree(self, start, height=None):
"""
Fetches nodeHash based on start leaf and height of the node in the tree.
:return: the nodeHash
"""
pos = self.getNodePosition(start, height)
return self.readNode(pos)
|
python
|
def readNodeByTree(self, start, height=None):
"""
Fetches nodeHash based on start leaf and height of the node in the tree.
:return: the nodeHash
"""
pos = self.getNodePosition(start, height)
return self.readNode(pos)
|
[
"def",
"readNodeByTree",
"(",
"self",
",",
"start",
",",
"height",
"=",
"None",
")",
":",
"pos",
"=",
"self",
".",
"getNodePosition",
"(",
"start",
",",
"height",
")",
"return",
"self",
".",
"readNode",
"(",
"pos",
")"
] |
Fetches nodeHash based on start leaf and height of the node in the tree.
:return: the nodeHash
|
[
"Fetches",
"nodeHash",
"based",
"on",
"start",
"leaf",
"and",
"height",
"of",
"the",
"node",
"in",
"the",
"tree",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/hash_stores/hash_store.py#L129-L136
|
234,233
|
hyperledger/indy-plenum
|
ledger/hash_stores/hash_store.py
|
HashStore.is_consistent
|
def is_consistent(self) -> bool:
"""
Returns True if number of nodes are consistent with number of leaves
"""
from ledger.compact_merkle_tree import CompactMerkleTree
return self.nodeCount == CompactMerkleTree.get_expected_node_count(
self.leafCount)
|
python
|
def is_consistent(self) -> bool:
"""
Returns True if number of nodes are consistent with number of leaves
"""
from ledger.compact_merkle_tree import CompactMerkleTree
return self.nodeCount == CompactMerkleTree.get_expected_node_count(
self.leafCount)
|
[
"def",
"is_consistent",
"(",
"self",
")",
"->",
"bool",
":",
"from",
"ledger",
".",
"compact_merkle_tree",
"import",
"CompactMerkleTree",
"return",
"self",
".",
"nodeCount",
"==",
"CompactMerkleTree",
".",
"get_expected_node_count",
"(",
"self",
".",
"leafCount",
")"
] |
Returns True if number of nodes are consistent with number of leaves
|
[
"Returns",
"True",
"if",
"number",
"of",
"nodes",
"are",
"consistent",
"with",
"number",
"of",
"leaves"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/hash_stores/hash_store.py#L139-L145
|
234,234
|
hyperledger/indy-plenum
|
storage/chunked_file_store.py
|
ChunkedFileStore._startNextChunk
|
def _startNextChunk(self) -> None:
"""
Close current and start next chunk
"""
if self.currentChunk is None:
self._useLatestChunk()
else:
self._useChunk(self.currentChunkIndex + self.chunkSize)
|
python
|
def _startNextChunk(self) -> None:
"""
Close current and start next chunk
"""
if self.currentChunk is None:
self._useLatestChunk()
else:
self._useChunk(self.currentChunkIndex + self.chunkSize)
|
[
"def",
"_startNextChunk",
"(",
"self",
")",
"->",
"None",
":",
"if",
"self",
".",
"currentChunk",
"is",
"None",
":",
"self",
".",
"_useLatestChunk",
"(",
")",
"else",
":",
"self",
".",
"_useChunk",
"(",
"self",
".",
"currentChunkIndex",
"+",
"self",
".",
"chunkSize",
")"
] |
Close current and start next chunk
|
[
"Close",
"current",
"and",
"start",
"next",
"chunk"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/storage/chunked_file_store.py#L108-L115
|
234,235
|
hyperledger/indy-plenum
|
storage/chunked_file_store.py
|
ChunkedFileStore.get
|
def get(self, key) -> str:
"""
Determines the file to retrieve the data from and retrieves the data.
:return: value corresponding to specified key
"""
# TODO: get is creating files when a key is given which is more than
# the store size
chunk_no, offset = self._get_key_location(key)
with self._openChunk(chunk_no) as chunk:
return chunk.get(str(offset))
|
python
|
def get(self, key) -> str:
"""
Determines the file to retrieve the data from and retrieves the data.
:return: value corresponding to specified key
"""
# TODO: get is creating files when a key is given which is more than
# the store size
chunk_no, offset = self._get_key_location(key)
with self._openChunk(chunk_no) as chunk:
return chunk.get(str(offset))
|
[
"def",
"get",
"(",
"self",
",",
"key",
")",
"->",
"str",
":",
"# TODO: get is creating files when a key is given which is more than",
"# the store size",
"chunk_no",
",",
"offset",
"=",
"self",
".",
"_get_key_location",
"(",
"key",
")",
"with",
"self",
".",
"_openChunk",
"(",
"chunk_no",
")",
"as",
"chunk",
":",
"return",
"chunk",
".",
"get",
"(",
"str",
"(",
"offset",
")",
")"
] |
Determines the file to retrieve the data from and retrieves the data.
:return: value corresponding to specified key
|
[
"Determines",
"the",
"file",
"to",
"retrieve",
"the",
"data",
"from",
"and",
"retrieves",
"the",
"data",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/storage/chunked_file_store.py#L168-L178
|
234,236
|
hyperledger/indy-plenum
|
storage/chunked_file_store.py
|
ChunkedFileStore.reset
|
def reset(self) -> None:
"""
Clear all data in file storage.
"""
self.close()
for f in os.listdir(self.dataDir):
os.remove(os.path.join(self.dataDir, f))
self._useLatestChunk()
|
python
|
def reset(self) -> None:
"""
Clear all data in file storage.
"""
self.close()
for f in os.listdir(self.dataDir):
os.remove(os.path.join(self.dataDir, f))
self._useLatestChunk()
|
[
"def",
"reset",
"(",
"self",
")",
"->",
"None",
":",
"self",
".",
"close",
"(",
")",
"for",
"f",
"in",
"os",
".",
"listdir",
"(",
"self",
".",
"dataDir",
")",
":",
"os",
".",
"remove",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"dataDir",
",",
"f",
")",
")",
"self",
".",
"_useLatestChunk",
"(",
")"
] |
Clear all data in file storage.
|
[
"Clear",
"all",
"data",
"in",
"file",
"storage",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/storage/chunked_file_store.py#L180-L187
|
234,237
|
hyperledger/indy-plenum
|
storage/chunked_file_store.py
|
ChunkedFileStore._listChunks
|
def _listChunks(self):
"""
Lists stored chunks
:return: sorted list of available chunk indices
"""
chunks = []
for fileName in os.listdir(self.dataDir):
index = ChunkedFileStore._fileNameToChunkIndex(fileName)
if index is not None:
chunks.append(index)
return sorted(chunks)
|
python
|
def _listChunks(self):
"""
Lists stored chunks
:return: sorted list of available chunk indices
"""
chunks = []
for fileName in os.listdir(self.dataDir):
index = ChunkedFileStore._fileNameToChunkIndex(fileName)
if index is not None:
chunks.append(index)
return sorted(chunks)
|
[
"def",
"_listChunks",
"(",
"self",
")",
":",
"chunks",
"=",
"[",
"]",
"for",
"fileName",
"in",
"os",
".",
"listdir",
"(",
"self",
".",
"dataDir",
")",
":",
"index",
"=",
"ChunkedFileStore",
".",
"_fileNameToChunkIndex",
"(",
"fileName",
")",
"if",
"index",
"is",
"not",
"None",
":",
"chunks",
".",
"append",
"(",
"index",
")",
"return",
"sorted",
"(",
"chunks",
")"
] |
Lists stored chunks
:return: sorted list of available chunk indices
|
[
"Lists",
"stored",
"chunks"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/storage/chunked_file_store.py#L216-L227
|
234,238
|
hyperledger/indy-plenum
|
plenum/server/primary_decider.py
|
PrimaryDecider.filterMsgs
|
def filterMsgs(self, wrappedMsgs: deque) -> deque:
"""
Filters messages by view number so that only the messages that have the
current view number are retained.
:param wrappedMsgs: the messages to filter
"""
filtered = deque()
while wrappedMsgs:
wrappedMsg = wrappedMsgs.popleft()
msg, sender = wrappedMsg
if hasattr(msg, f.VIEW_NO.nm):
reqViewNo = getattr(msg, f.VIEW_NO.nm)
if reqViewNo == self.viewNo:
filtered.append(wrappedMsg)
else:
self.discard(wrappedMsg,
"its view no {} is less than the elector's {}"
.format(reqViewNo, self.viewNo),
logger.debug)
else:
filtered.append(wrappedMsg)
return filtered
|
python
|
def filterMsgs(self, wrappedMsgs: deque) -> deque:
"""
Filters messages by view number so that only the messages that have the
current view number are retained.
:param wrappedMsgs: the messages to filter
"""
filtered = deque()
while wrappedMsgs:
wrappedMsg = wrappedMsgs.popleft()
msg, sender = wrappedMsg
if hasattr(msg, f.VIEW_NO.nm):
reqViewNo = getattr(msg, f.VIEW_NO.nm)
if reqViewNo == self.viewNo:
filtered.append(wrappedMsg)
else:
self.discard(wrappedMsg,
"its view no {} is less than the elector's {}"
.format(reqViewNo, self.viewNo),
logger.debug)
else:
filtered.append(wrappedMsg)
return filtered
|
[
"def",
"filterMsgs",
"(",
"self",
",",
"wrappedMsgs",
":",
"deque",
")",
"->",
"deque",
":",
"filtered",
"=",
"deque",
"(",
")",
"while",
"wrappedMsgs",
":",
"wrappedMsg",
"=",
"wrappedMsgs",
".",
"popleft",
"(",
")",
"msg",
",",
"sender",
"=",
"wrappedMsg",
"if",
"hasattr",
"(",
"msg",
",",
"f",
".",
"VIEW_NO",
".",
"nm",
")",
":",
"reqViewNo",
"=",
"getattr",
"(",
"msg",
",",
"f",
".",
"VIEW_NO",
".",
"nm",
")",
"if",
"reqViewNo",
"==",
"self",
".",
"viewNo",
":",
"filtered",
".",
"append",
"(",
"wrappedMsg",
")",
"else",
":",
"self",
".",
"discard",
"(",
"wrappedMsg",
",",
"\"its view no {} is less than the elector's {}\"",
".",
"format",
"(",
"reqViewNo",
",",
"self",
".",
"viewNo",
")",
",",
"logger",
".",
"debug",
")",
"else",
":",
"filtered",
".",
"append",
"(",
"wrappedMsg",
")",
"return",
"filtered"
] |
Filters messages by view number so that only the messages that have the
current view number are retained.
:param wrappedMsgs: the messages to filter
|
[
"Filters",
"messages",
"by",
"view",
"number",
"so",
"that",
"only",
"the",
"messages",
"that",
"have",
"the",
"current",
"view",
"number",
"are",
"retained",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/primary_decider.py#L74-L97
|
234,239
|
hyperledger/indy-plenum
|
plenum/server/plugin_loader.py
|
PluginLoader.get
|
def get(self, name):
"""Retrieve a plugin by name."""
try:
return self.plugins[name]
except KeyError:
raise RuntimeError("plugin {} does not exist".format(name))
|
python
|
def get(self, name):
"""Retrieve a plugin by name."""
try:
return self.plugins[name]
except KeyError:
raise RuntimeError("plugin {} does not exist".format(name))
|
[
"def",
"get",
"(",
"self",
",",
"name",
")",
":",
"try",
":",
"return",
"self",
".",
"plugins",
"[",
"name",
"]",
"except",
"KeyError",
":",
"raise",
"RuntimeError",
"(",
"\"plugin {} does not exist\"",
".",
"format",
"(",
"name",
")",
")"
] |
Retrieve a plugin by name.
|
[
"Retrieve",
"a",
"plugin",
"by",
"name",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/plugin_loader.py#L65-L70
|
234,240
|
hyperledger/indy-plenum
|
common/version.py
|
VersionBase.cmp
|
def cmp(cls, v1: 'VersionBase', v2: 'VersionBase') -> int:
""" Compares two instances. """
# TODO types checking
if v1._version > v2._version:
return 1
elif v1._version == v2._version:
return 0
else:
return -1
|
python
|
def cmp(cls, v1: 'VersionBase', v2: 'VersionBase') -> int:
""" Compares two instances. """
# TODO types checking
if v1._version > v2._version:
return 1
elif v1._version == v2._version:
return 0
else:
return -1
|
[
"def",
"cmp",
"(",
"cls",
",",
"v1",
":",
"'VersionBase'",
",",
"v2",
":",
"'VersionBase'",
")",
"->",
"int",
":",
"# TODO types checking",
"if",
"v1",
".",
"_version",
">",
"v2",
".",
"_version",
":",
"return",
"1",
"elif",
"v1",
".",
"_version",
"==",
"v2",
".",
"_version",
":",
"return",
"0",
"else",
":",
"return",
"-",
"1"
] |
Compares two instances.
|
[
"Compares",
"two",
"instances",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/common/version.py#L39-L47
|
234,241
|
hyperledger/indy-plenum
|
stp_zmq/kit_zstack.py
|
KITZStack.maintainConnections
|
def maintainConnections(self, force=False):
"""
Ensure appropriate connections.
"""
now = time.perf_counter()
if now < self.nextCheck and not force:
return False
self.nextCheck = now + (self.config.RETRY_TIMEOUT_NOT_RESTRICTED
if self.isKeySharing
else self.config.RETRY_TIMEOUT_RESTRICTED)
missing = self.connectToMissing()
self.retryDisconnected(exclude=missing)
logger.trace("{} next check for retries in {:.2f} seconds"
.format(self, self.nextCheck - now))
return True
|
python
|
def maintainConnections(self, force=False):
"""
Ensure appropriate connections.
"""
now = time.perf_counter()
if now < self.nextCheck and not force:
return False
self.nextCheck = now + (self.config.RETRY_TIMEOUT_NOT_RESTRICTED
if self.isKeySharing
else self.config.RETRY_TIMEOUT_RESTRICTED)
missing = self.connectToMissing()
self.retryDisconnected(exclude=missing)
logger.trace("{} next check for retries in {:.2f} seconds"
.format(self, self.nextCheck - now))
return True
|
[
"def",
"maintainConnections",
"(",
"self",
",",
"force",
"=",
"False",
")",
":",
"now",
"=",
"time",
".",
"perf_counter",
"(",
")",
"if",
"now",
"<",
"self",
".",
"nextCheck",
"and",
"not",
"force",
":",
"return",
"False",
"self",
".",
"nextCheck",
"=",
"now",
"+",
"(",
"self",
".",
"config",
".",
"RETRY_TIMEOUT_NOT_RESTRICTED",
"if",
"self",
".",
"isKeySharing",
"else",
"self",
".",
"config",
".",
"RETRY_TIMEOUT_RESTRICTED",
")",
"missing",
"=",
"self",
".",
"connectToMissing",
"(",
")",
"self",
".",
"retryDisconnected",
"(",
"exclude",
"=",
"missing",
")",
"logger",
".",
"trace",
"(",
"\"{} next check for retries in {:.2f} seconds\"",
".",
"format",
"(",
"self",
",",
"self",
".",
"nextCheck",
"-",
"now",
")",
")",
"return",
"True"
] |
Ensure appropriate connections.
|
[
"Ensure",
"appropriate",
"connections",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/kit_zstack.py#L54-L69
|
234,242
|
hyperledger/indy-plenum
|
stp_zmq/kit_zstack.py
|
KITZStack.connectToMissing
|
def connectToMissing(self) -> set:
"""
Try to connect to the missing nodes
"""
missing = self.reconcileNodeReg()
if not missing:
return missing
logger.info("{}{} found the following missing connections: {}".
format(CONNECTION_PREFIX, self, ", ".join(missing)))
for name in missing:
try:
self.connect(name, ha=self.registry[name])
except (ValueError, KeyError, PublicKeyNotFoundOnDisk, VerKeyNotFoundOnDisk) as ex:
logger.warning('{}{} cannot connect to {} due to {}'.
format(CONNECTION_PREFIX, self, name, ex))
return missing
|
python
|
def connectToMissing(self) -> set:
"""
Try to connect to the missing nodes
"""
missing = self.reconcileNodeReg()
if not missing:
return missing
logger.info("{}{} found the following missing connections: {}".
format(CONNECTION_PREFIX, self, ", ".join(missing)))
for name in missing:
try:
self.connect(name, ha=self.registry[name])
except (ValueError, KeyError, PublicKeyNotFoundOnDisk, VerKeyNotFoundOnDisk) as ex:
logger.warning('{}{} cannot connect to {} due to {}'.
format(CONNECTION_PREFIX, self, name, ex))
return missing
|
[
"def",
"connectToMissing",
"(",
"self",
")",
"->",
"set",
":",
"missing",
"=",
"self",
".",
"reconcileNodeReg",
"(",
")",
"if",
"not",
"missing",
":",
"return",
"missing",
"logger",
".",
"info",
"(",
"\"{}{} found the following missing connections: {}\"",
".",
"format",
"(",
"CONNECTION_PREFIX",
",",
"self",
",",
"\", \"",
".",
"join",
"(",
"missing",
")",
")",
")",
"for",
"name",
"in",
"missing",
":",
"try",
":",
"self",
".",
"connect",
"(",
"name",
",",
"ha",
"=",
"self",
".",
"registry",
"[",
"name",
"]",
")",
"except",
"(",
"ValueError",
",",
"KeyError",
",",
"PublicKeyNotFoundOnDisk",
",",
"VerKeyNotFoundOnDisk",
")",
"as",
"ex",
":",
"logger",
".",
"warning",
"(",
"'{}{} cannot connect to {} due to {}'",
".",
"format",
"(",
"CONNECTION_PREFIX",
",",
"self",
",",
"name",
",",
"ex",
")",
")",
"return",
"missing"
] |
Try to connect to the missing nodes
|
[
"Try",
"to",
"connect",
"to",
"the",
"missing",
"nodes"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/kit_zstack.py#L107-L125
|
234,243
|
hyperledger/indy-plenum
|
stp_core/common/logging/handlers.py
|
CallbackHandler.emit
|
def emit(self, record):
"""
Passes the log record back to the CLI for rendering
"""
should_cb = None
attr_val = None
if hasattr(record, self.typestr):
attr_val = getattr(record, self.typestr)
should_cb = bool(attr_val)
if should_cb is None and record.levelno >= logging.INFO:
should_cb = True
if hasattr(record, 'tags'):
for t in record.tags:
if t in self.tags:
if self.tags[t]:
should_cb = True
continue
else:
should_cb = False
break
if should_cb:
self.callback(record, attr_val)
|
python
|
def emit(self, record):
"""
Passes the log record back to the CLI for rendering
"""
should_cb = None
attr_val = None
if hasattr(record, self.typestr):
attr_val = getattr(record, self.typestr)
should_cb = bool(attr_val)
if should_cb is None and record.levelno >= logging.INFO:
should_cb = True
if hasattr(record, 'tags'):
for t in record.tags:
if t in self.tags:
if self.tags[t]:
should_cb = True
continue
else:
should_cb = False
break
if should_cb:
self.callback(record, attr_val)
|
[
"def",
"emit",
"(",
"self",
",",
"record",
")",
":",
"should_cb",
"=",
"None",
"attr_val",
"=",
"None",
"if",
"hasattr",
"(",
"record",
",",
"self",
".",
"typestr",
")",
":",
"attr_val",
"=",
"getattr",
"(",
"record",
",",
"self",
".",
"typestr",
")",
"should_cb",
"=",
"bool",
"(",
"attr_val",
")",
"if",
"should_cb",
"is",
"None",
"and",
"record",
".",
"levelno",
">=",
"logging",
".",
"INFO",
":",
"should_cb",
"=",
"True",
"if",
"hasattr",
"(",
"record",
",",
"'tags'",
")",
":",
"for",
"t",
"in",
"record",
".",
"tags",
":",
"if",
"t",
"in",
"self",
".",
"tags",
":",
"if",
"self",
".",
"tags",
"[",
"t",
"]",
":",
"should_cb",
"=",
"True",
"continue",
"else",
":",
"should_cb",
"=",
"False",
"break",
"if",
"should_cb",
":",
"self",
".",
"callback",
"(",
"record",
",",
"attr_val",
")"
] |
Passes the log record back to the CLI for rendering
|
[
"Passes",
"the",
"log",
"record",
"back",
"to",
"the",
"CLI",
"for",
"rendering"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/common/logging/handlers.py#L18-L39
|
234,244
|
hyperledger/indy-plenum
|
stp_core/network/keep_in_touch.py
|
KITNetworkInterface.conns
|
def conns(self, value: Set[str]) -> None:
"""
Updates the connection count of this node if not already done.
"""
if not self._conns == value:
old = self._conns
self._conns = value
ins = value - old
outs = old - value
logger.display("{}'s connections changed from {} to {}".format(self, old, value))
self._connsChanged(ins, outs)
|
python
|
def conns(self, value: Set[str]) -> None:
"""
Updates the connection count of this node if not already done.
"""
if not self._conns == value:
old = self._conns
self._conns = value
ins = value - old
outs = old - value
logger.display("{}'s connections changed from {} to {}".format(self, old, value))
self._connsChanged(ins, outs)
|
[
"def",
"conns",
"(",
"self",
",",
"value",
":",
"Set",
"[",
"str",
"]",
")",
"->",
"None",
":",
"if",
"not",
"self",
".",
"_conns",
"==",
"value",
":",
"old",
"=",
"self",
".",
"_conns",
"self",
".",
"_conns",
"=",
"value",
"ins",
"=",
"value",
"-",
"old",
"outs",
"=",
"old",
"-",
"value",
"logger",
".",
"display",
"(",
"\"{}'s connections changed from {} to {}\"",
".",
"format",
"(",
"self",
",",
"old",
",",
"value",
")",
")",
"self",
".",
"_connsChanged",
"(",
"ins",
",",
"outs",
")"
] |
Updates the connection count of this node if not already done.
|
[
"Updates",
"the",
"connection",
"count",
"of",
"this",
"node",
"if",
"not",
"already",
"done",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/network/keep_in_touch.py#L57-L67
|
234,245
|
hyperledger/indy-plenum
|
stp_core/network/keep_in_touch.py
|
KITNetworkInterface.findInNodeRegByHA
|
def findInNodeRegByHA(self, remoteHa):
"""
Returns the name of the remote by HA if found in the node registry, else
returns None
"""
regName = [nm for nm, ha in self.registry.items()
if self.sameAddr(ha, remoteHa)]
if len(regName) > 1:
raise RuntimeError("more than one node registry entry with the "
"same ha {}: {}".format(remoteHa, regName))
if regName:
return regName[0]
return None
|
python
|
def findInNodeRegByHA(self, remoteHa):
"""
Returns the name of the remote by HA if found in the node registry, else
returns None
"""
regName = [nm for nm, ha in self.registry.items()
if self.sameAddr(ha, remoteHa)]
if len(regName) > 1:
raise RuntimeError("more than one node registry entry with the "
"same ha {}: {}".format(remoteHa, regName))
if regName:
return regName[0]
return None
|
[
"def",
"findInNodeRegByHA",
"(",
"self",
",",
"remoteHa",
")",
":",
"regName",
"=",
"[",
"nm",
"for",
"nm",
",",
"ha",
"in",
"self",
".",
"registry",
".",
"items",
"(",
")",
"if",
"self",
".",
"sameAddr",
"(",
"ha",
",",
"remoteHa",
")",
"]",
"if",
"len",
"(",
"regName",
")",
">",
"1",
":",
"raise",
"RuntimeError",
"(",
"\"more than one node registry entry with the \"",
"\"same ha {}: {}\"",
".",
"format",
"(",
"remoteHa",
",",
"regName",
")",
")",
"if",
"regName",
":",
"return",
"regName",
"[",
"0",
"]",
"return",
"None"
] |
Returns the name of the remote by HA if found in the node registry, else
returns None
|
[
"Returns",
"the",
"name",
"of",
"the",
"remote",
"by",
"HA",
"if",
"found",
"in",
"the",
"node",
"registry",
"else",
"returns",
"None"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/network/keep_in_touch.py#L110-L122
|
234,246
|
hyperledger/indy-plenum
|
stp_core/network/keep_in_touch.py
|
KITNetworkInterface.getRemoteName
|
def getRemoteName(self, remote):
"""
Returns the name of the remote object if found in node registry.
:param remote: the remote object
"""
if remote.name not in self.registry:
find = [name for name, ha in self.registry.items()
if ha == remote.ha]
assert len(find) == 1
return find[0]
return remote.name
|
python
|
def getRemoteName(self, remote):
"""
Returns the name of the remote object if found in node registry.
:param remote: the remote object
"""
if remote.name not in self.registry:
find = [name for name, ha in self.registry.items()
if ha == remote.ha]
assert len(find) == 1
return find[0]
return remote.name
|
[
"def",
"getRemoteName",
"(",
"self",
",",
"remote",
")",
":",
"if",
"remote",
".",
"name",
"not",
"in",
"self",
".",
"registry",
":",
"find",
"=",
"[",
"name",
"for",
"name",
",",
"ha",
"in",
"self",
".",
"registry",
".",
"items",
"(",
")",
"if",
"ha",
"==",
"remote",
".",
"ha",
"]",
"assert",
"len",
"(",
"find",
")",
"==",
"1",
"return",
"find",
"[",
"0",
"]",
"return",
"remote",
".",
"name"
] |
Returns the name of the remote object if found in node registry.
:param remote: the remote object
|
[
"Returns",
"the",
"name",
"of",
"the",
"remote",
"object",
"if",
"found",
"in",
"node",
"registry",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/network/keep_in_touch.py#L124-L135
|
234,247
|
hyperledger/indy-plenum
|
stp_core/network/keep_in_touch.py
|
KITNetworkInterface.notConnectedNodes
|
def notConnectedNodes(self) -> Set[str]:
"""
Returns the names of nodes in the registry this node is NOT connected
to.
"""
return set(self.registry.keys()) - self.conns
|
python
|
def notConnectedNodes(self) -> Set[str]:
"""
Returns the names of nodes in the registry this node is NOT connected
to.
"""
return set(self.registry.keys()) - self.conns
|
[
"def",
"notConnectedNodes",
"(",
"self",
")",
"->",
"Set",
"[",
"str",
"]",
":",
"return",
"set",
"(",
"self",
".",
"registry",
".",
"keys",
"(",
")",
")",
"-",
"self",
".",
"conns"
] |
Returns the names of nodes in the registry this node is NOT connected
to.
|
[
"Returns",
"the",
"names",
"of",
"nodes",
"in",
"the",
"registry",
"this",
"node",
"is",
"NOT",
"connected",
"to",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_core/network/keep_in_touch.py#L138-L143
|
234,248
|
hyperledger/indy-plenum
|
stp_zmq/authenticator.py
|
MultiZapAuthenticator.start
|
def start(self):
"""Create and bind the ZAP socket"""
self.zap_socket = self.context.socket(zmq.REP)
self.zap_socket.linger = 1
zapLoc = 'inproc://zeromq.zap.{}'.format(MultiZapAuthenticator.count)
self.zap_socket.bind(zapLoc)
self.log.debug('Starting ZAP at {}'.format(zapLoc))
|
python
|
def start(self):
"""Create and bind the ZAP socket"""
self.zap_socket = self.context.socket(zmq.REP)
self.zap_socket.linger = 1
zapLoc = 'inproc://zeromq.zap.{}'.format(MultiZapAuthenticator.count)
self.zap_socket.bind(zapLoc)
self.log.debug('Starting ZAP at {}'.format(zapLoc))
|
[
"def",
"start",
"(",
"self",
")",
":",
"self",
".",
"zap_socket",
"=",
"self",
".",
"context",
".",
"socket",
"(",
"zmq",
".",
"REP",
")",
"self",
".",
"zap_socket",
".",
"linger",
"=",
"1",
"zapLoc",
"=",
"'inproc://zeromq.zap.{}'",
".",
"format",
"(",
"MultiZapAuthenticator",
".",
"count",
")",
"self",
".",
"zap_socket",
".",
"bind",
"(",
"zapLoc",
")",
"self",
".",
"log",
".",
"debug",
"(",
"'Starting ZAP at {}'",
".",
"format",
"(",
"zapLoc",
")",
")"
] |
Create and bind the ZAP socket
|
[
"Create",
"and",
"bind",
"the",
"ZAP",
"socket"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/authenticator.py#L25-L31
|
234,249
|
hyperledger/indy-plenum
|
stp_zmq/authenticator.py
|
MultiZapAuthenticator.stop
|
def stop(self):
"""Close the ZAP socket"""
if self.zap_socket:
self.log.debug(
'Stopping ZAP at {}'.format(self.zap_socket.LAST_ENDPOINT))
super().stop()
|
python
|
def stop(self):
"""Close the ZAP socket"""
if self.zap_socket:
self.log.debug(
'Stopping ZAP at {}'.format(self.zap_socket.LAST_ENDPOINT))
super().stop()
|
[
"def",
"stop",
"(",
"self",
")",
":",
"if",
"self",
".",
"zap_socket",
":",
"self",
".",
"log",
".",
"debug",
"(",
"'Stopping ZAP at {}'",
".",
"format",
"(",
"self",
".",
"zap_socket",
".",
"LAST_ENDPOINT",
")",
")",
"super",
"(",
")",
".",
"stop",
"(",
")"
] |
Close the ZAP socket
|
[
"Close",
"the",
"ZAP",
"socket"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/authenticator.py#L33-L38
|
234,250
|
hyperledger/indy-plenum
|
stp_zmq/authenticator.py
|
AsyncioAuthenticator.start
|
def start(self):
"""Start ZAP authentication"""
super().start()
self.__poller = zmq.asyncio.Poller()
self.__poller.register(self.zap_socket, zmq.POLLIN)
self.__task = asyncio.ensure_future(self.__handle_zap())
|
python
|
def start(self):
"""Start ZAP authentication"""
super().start()
self.__poller = zmq.asyncio.Poller()
self.__poller.register(self.zap_socket, zmq.POLLIN)
self.__task = asyncio.ensure_future(self.__handle_zap())
|
[
"def",
"start",
"(",
"self",
")",
":",
"super",
"(",
")",
".",
"start",
"(",
")",
"self",
".",
"__poller",
"=",
"zmq",
".",
"asyncio",
".",
"Poller",
"(",
")",
"self",
".",
"__poller",
".",
"register",
"(",
"self",
".",
"zap_socket",
",",
"zmq",
".",
"POLLIN",
")",
"self",
".",
"__task",
"=",
"asyncio",
".",
"ensure_future",
"(",
"self",
".",
"__handle_zap",
"(",
")",
")"
] |
Start ZAP authentication
|
[
"Start",
"ZAP",
"authentication"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/authenticator.py#L88-L93
|
234,251
|
hyperledger/indy-plenum
|
stp_zmq/authenticator.py
|
AsyncioAuthenticator.stop
|
def stop(self):
"""Stop ZAP authentication"""
if self.__task:
self.__task.cancel()
if self.__poller:
self.__poller.unregister(self.zap_socket)
self.__poller = None
super().stop()
|
python
|
def stop(self):
"""Stop ZAP authentication"""
if self.__task:
self.__task.cancel()
if self.__poller:
self.__poller.unregister(self.zap_socket)
self.__poller = None
super().stop()
|
[
"def",
"stop",
"(",
"self",
")",
":",
"if",
"self",
".",
"__task",
":",
"self",
".",
"__task",
".",
"cancel",
"(",
")",
"if",
"self",
".",
"__poller",
":",
"self",
".",
"__poller",
".",
"unregister",
"(",
"self",
".",
"zap_socket",
")",
"self",
".",
"__poller",
"=",
"None",
"super",
"(",
")",
".",
"stop",
"(",
")"
] |
Stop ZAP authentication
|
[
"Stop",
"ZAP",
"authentication"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/authenticator.py#L95-L102
|
234,252
|
hyperledger/indy-plenum
|
plenum/common/util.py
|
randomString
|
def randomString(size: int = 20) -> str:
"""
Generate a random string in hex of the specified size
DO NOT use python provided random class its a Pseudo Random Number Generator
and not secure enough for our needs
:param size: size of the random string to generate
:return: the hexadecimal random string
"""
def randomStr(size):
if not isinstance(size, int):
raise PlenumTypeError('size', size, int)
if not size > 0:
raise PlenumValueError('size', size, '> 0')
# Approach 1
rv = randombytes(size // 2).hex()
return rv if size % 2 == 0 else rv + hex(randombytes_uniform(15))[-1]
# Approach 2 this is faster than Approach 1, but lovesh had a doubt
# that part of a random may not be truly random, so until
# we have definite proof going to retain it commented
# rstr = randombytes(size).hex()
# return rstr[:size]
return randomStr(size)
|
python
|
def randomString(size: int = 20) -> str:
"""
Generate a random string in hex of the specified size
DO NOT use python provided random class its a Pseudo Random Number Generator
and not secure enough for our needs
:param size: size of the random string to generate
:return: the hexadecimal random string
"""
def randomStr(size):
if not isinstance(size, int):
raise PlenumTypeError('size', size, int)
if not size > 0:
raise PlenumValueError('size', size, '> 0')
# Approach 1
rv = randombytes(size // 2).hex()
return rv if size % 2 == 0 else rv + hex(randombytes_uniform(15))[-1]
# Approach 2 this is faster than Approach 1, but lovesh had a doubt
# that part of a random may not be truly random, so until
# we have definite proof going to retain it commented
# rstr = randombytes(size).hex()
# return rstr[:size]
return randomStr(size)
|
[
"def",
"randomString",
"(",
"size",
":",
"int",
"=",
"20",
")",
"->",
"str",
":",
"def",
"randomStr",
"(",
"size",
")",
":",
"if",
"not",
"isinstance",
"(",
"size",
",",
"int",
")",
":",
"raise",
"PlenumTypeError",
"(",
"'size'",
",",
"size",
",",
"int",
")",
"if",
"not",
"size",
">",
"0",
":",
"raise",
"PlenumValueError",
"(",
"'size'",
",",
"size",
",",
"'> 0'",
")",
"# Approach 1",
"rv",
"=",
"randombytes",
"(",
"size",
"//",
"2",
")",
".",
"hex",
"(",
")",
"return",
"rv",
"if",
"size",
"%",
"2",
"==",
"0",
"else",
"rv",
"+",
"hex",
"(",
"randombytes_uniform",
"(",
"15",
")",
")",
"[",
"-",
"1",
"]",
"# Approach 2 this is faster than Approach 1, but lovesh had a doubt",
"# that part of a random may not be truly random, so until",
"# we have definite proof going to retain it commented",
"# rstr = randombytes(size).hex()",
"# return rstr[:size]",
"return",
"randomStr",
"(",
"size",
")"
] |
Generate a random string in hex of the specified size
DO NOT use python provided random class its a Pseudo Random Number Generator
and not secure enough for our needs
:param size: size of the random string to generate
:return: the hexadecimal random string
|
[
"Generate",
"a",
"random",
"string",
"in",
"hex",
"of",
"the",
"specified",
"size"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/util.py#L48-L75
|
234,253
|
hyperledger/indy-plenum
|
plenum/common/util.py
|
mostCommonElement
|
def mostCommonElement(elements: Iterable[T], to_hashable_f: Callable=None):
"""
Find the most frequent element of a collection.
:param elements: An iterable of elements
:param to_hashable_f: (optional) if defined will be used to get
hashable presentation for non-hashable elements. Otherwise json.dumps
is used with sort_keys=True
:return: element which is the most frequent in the collection and
the number of its occurrences
"""
class _Hashable(collections.abc.Hashable):
def __init__(self, orig):
self.orig = orig
if isinstance(orig, collections.Hashable):
self.hashable = orig
elif to_hashable_f is not None:
self.hashable = to_hashable_f(orig)
else:
self.hashable = json.dumps(orig, sort_keys=True)
def __eq__(self, other):
return self.hashable == other.hashable
def __hash__(self):
return hash(self.hashable)
_elements = (_Hashable(el) for el in elements)
most_common, counter = Counter(_elements).most_common(n=1)[0]
return most_common.orig, counter
|
python
|
def mostCommonElement(elements: Iterable[T], to_hashable_f: Callable=None):
"""
Find the most frequent element of a collection.
:param elements: An iterable of elements
:param to_hashable_f: (optional) if defined will be used to get
hashable presentation for non-hashable elements. Otherwise json.dumps
is used with sort_keys=True
:return: element which is the most frequent in the collection and
the number of its occurrences
"""
class _Hashable(collections.abc.Hashable):
def __init__(self, orig):
self.orig = orig
if isinstance(orig, collections.Hashable):
self.hashable = orig
elif to_hashable_f is not None:
self.hashable = to_hashable_f(orig)
else:
self.hashable = json.dumps(orig, sort_keys=True)
def __eq__(self, other):
return self.hashable == other.hashable
def __hash__(self):
return hash(self.hashable)
_elements = (_Hashable(el) for el in elements)
most_common, counter = Counter(_elements).most_common(n=1)[0]
return most_common.orig, counter
|
[
"def",
"mostCommonElement",
"(",
"elements",
":",
"Iterable",
"[",
"T",
"]",
",",
"to_hashable_f",
":",
"Callable",
"=",
"None",
")",
":",
"class",
"_Hashable",
"(",
"collections",
".",
"abc",
".",
"Hashable",
")",
":",
"def",
"__init__",
"(",
"self",
",",
"orig",
")",
":",
"self",
".",
"orig",
"=",
"orig",
"if",
"isinstance",
"(",
"orig",
",",
"collections",
".",
"Hashable",
")",
":",
"self",
".",
"hashable",
"=",
"orig",
"elif",
"to_hashable_f",
"is",
"not",
"None",
":",
"self",
".",
"hashable",
"=",
"to_hashable_f",
"(",
"orig",
")",
"else",
":",
"self",
".",
"hashable",
"=",
"json",
".",
"dumps",
"(",
"orig",
",",
"sort_keys",
"=",
"True",
")",
"def",
"__eq__",
"(",
"self",
",",
"other",
")",
":",
"return",
"self",
".",
"hashable",
"==",
"other",
".",
"hashable",
"def",
"__hash__",
"(",
"self",
")",
":",
"return",
"hash",
"(",
"self",
".",
"hashable",
")",
"_elements",
"=",
"(",
"_Hashable",
"(",
"el",
")",
"for",
"el",
"in",
"elements",
")",
"most_common",
",",
"counter",
"=",
"Counter",
"(",
"_elements",
")",
".",
"most_common",
"(",
"n",
"=",
"1",
")",
"[",
"0",
"]",
"return",
"most_common",
".",
"orig",
",",
"counter"
] |
Find the most frequent element of a collection.
:param elements: An iterable of elements
:param to_hashable_f: (optional) if defined will be used to get
hashable presentation for non-hashable elements. Otherwise json.dumps
is used with sort_keys=True
:return: element which is the most frequent in the collection and
the number of its occurrences
|
[
"Find",
"the",
"most",
"frequent",
"element",
"of",
"a",
"collection",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/util.py#L92-L122
|
234,254
|
hyperledger/indy-plenum
|
plenum/common/util.py
|
objSearchReplace
|
def objSearchReplace(obj: Any,
toFrom: Dict[Any, Any],
checked: Set[Any]=None,
logMsg: str=None,
deepLevel: int=None) -> None:
"""
Search for an attribute in an object and replace it with another.
:param obj: the object to search for the attribute
:param toFrom: dictionary of the attribute name before and after search and replace i.e. search for the key and replace with the value
:param checked: set of attributes of the object for recursion. optional. defaults to `set()`
:param logMsg: a custom log message
"""
if checked is None:
checked = set()
checked.add(id(obj))
pairs = [(i, getattr(obj, i)) for i in dir(obj) if not i.startswith("__")]
if isinstance(obj, Mapping):
pairs += [x for x in iteritems(obj)]
elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
pairs += [x for x in enumerate(obj)]
for nm, o in pairs:
if id(o) not in checked:
mutated = False
for old, new in toFrom.items():
if id(o) == id(old):
logging.debug(
"{}in object {}, attribute {} changed from {} to {}". format(
logMsg + ": " if logMsg else "", obj, nm, old, new))
if isinstance(obj, dict):
obj[nm] = new
else:
setattr(obj, nm, new)
mutated = True
if not mutated:
if deepLevel is not None and deepLevel == 0:
continue
objSearchReplace(o, toFrom, checked, logMsg, deepLevel -
1 if deepLevel is not None else deepLevel)
checked.remove(id(obj))
|
python
|
def objSearchReplace(obj: Any,
toFrom: Dict[Any, Any],
checked: Set[Any]=None,
logMsg: str=None,
deepLevel: int=None) -> None:
"""
Search for an attribute in an object and replace it with another.
:param obj: the object to search for the attribute
:param toFrom: dictionary of the attribute name before and after search and replace i.e. search for the key and replace with the value
:param checked: set of attributes of the object for recursion. optional. defaults to `set()`
:param logMsg: a custom log message
"""
if checked is None:
checked = set()
checked.add(id(obj))
pairs = [(i, getattr(obj, i)) for i in dir(obj) if not i.startswith("__")]
if isinstance(obj, Mapping):
pairs += [x for x in iteritems(obj)]
elif isinstance(obj, (Sequence, Set)) and not isinstance(obj, string_types):
pairs += [x for x in enumerate(obj)]
for nm, o in pairs:
if id(o) not in checked:
mutated = False
for old, new in toFrom.items():
if id(o) == id(old):
logging.debug(
"{}in object {}, attribute {} changed from {} to {}". format(
logMsg + ": " if logMsg else "", obj, nm, old, new))
if isinstance(obj, dict):
obj[nm] = new
else:
setattr(obj, nm, new)
mutated = True
if not mutated:
if deepLevel is not None and deepLevel == 0:
continue
objSearchReplace(o, toFrom, checked, logMsg, deepLevel -
1 if deepLevel is not None else deepLevel)
checked.remove(id(obj))
|
[
"def",
"objSearchReplace",
"(",
"obj",
":",
"Any",
",",
"toFrom",
":",
"Dict",
"[",
"Any",
",",
"Any",
"]",
",",
"checked",
":",
"Set",
"[",
"Any",
"]",
"=",
"None",
",",
"logMsg",
":",
"str",
"=",
"None",
",",
"deepLevel",
":",
"int",
"=",
"None",
")",
"->",
"None",
":",
"if",
"checked",
"is",
"None",
":",
"checked",
"=",
"set",
"(",
")",
"checked",
".",
"add",
"(",
"id",
"(",
"obj",
")",
")",
"pairs",
"=",
"[",
"(",
"i",
",",
"getattr",
"(",
"obj",
",",
"i",
")",
")",
"for",
"i",
"in",
"dir",
"(",
"obj",
")",
"if",
"not",
"i",
".",
"startswith",
"(",
"\"__\"",
")",
"]",
"if",
"isinstance",
"(",
"obj",
",",
"Mapping",
")",
":",
"pairs",
"+=",
"[",
"x",
"for",
"x",
"in",
"iteritems",
"(",
"obj",
")",
"]",
"elif",
"isinstance",
"(",
"obj",
",",
"(",
"Sequence",
",",
"Set",
")",
")",
"and",
"not",
"isinstance",
"(",
"obj",
",",
"string_types",
")",
":",
"pairs",
"+=",
"[",
"x",
"for",
"x",
"in",
"enumerate",
"(",
"obj",
")",
"]",
"for",
"nm",
",",
"o",
"in",
"pairs",
":",
"if",
"id",
"(",
"o",
")",
"not",
"in",
"checked",
":",
"mutated",
"=",
"False",
"for",
"old",
",",
"new",
"in",
"toFrom",
".",
"items",
"(",
")",
":",
"if",
"id",
"(",
"o",
")",
"==",
"id",
"(",
"old",
")",
":",
"logging",
".",
"debug",
"(",
"\"{}in object {}, attribute {} changed from {} to {}\"",
".",
"format",
"(",
"logMsg",
"+",
"\": \"",
"if",
"logMsg",
"else",
"\"\"",
",",
"obj",
",",
"nm",
",",
"old",
",",
"new",
")",
")",
"if",
"isinstance",
"(",
"obj",
",",
"dict",
")",
":",
"obj",
"[",
"nm",
"]",
"=",
"new",
"else",
":",
"setattr",
"(",
"obj",
",",
"nm",
",",
"new",
")",
"mutated",
"=",
"True",
"if",
"not",
"mutated",
":",
"if",
"deepLevel",
"is",
"not",
"None",
"and",
"deepLevel",
"==",
"0",
":",
"continue",
"objSearchReplace",
"(",
"o",
",",
"toFrom",
",",
"checked",
",",
"logMsg",
",",
"deepLevel",
"-",
"1",
"if",
"deepLevel",
"is",
"not",
"None",
"else",
"deepLevel",
")",
"checked",
".",
"remove",
"(",
"id",
"(",
"obj",
")",
")"
] |
Search for an attribute in an object and replace it with another.
:param obj: the object to search for the attribute
:param toFrom: dictionary of the attribute name before and after search and replace i.e. search for the key and replace with the value
:param checked: set of attributes of the object for recursion. optional. defaults to `set()`
:param logMsg: a custom log message
|
[
"Search",
"for",
"an",
"attribute",
"in",
"an",
"object",
"and",
"replace",
"it",
"with",
"another",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/util.py#L131-L174
|
234,255
|
hyperledger/indy-plenum
|
plenum/common/util.py
|
runall
|
async def runall(corogen):
"""
Run an array of coroutines
:param corogen: a generator that generates coroutines
:return: list or returns of the coroutines
"""
results = []
for c in corogen:
result = await c
results.append(result)
return results
|
python
|
async def runall(corogen):
"""
Run an array of coroutines
:param corogen: a generator that generates coroutines
:return: list or returns of the coroutines
"""
results = []
for c in corogen:
result = await c
results.append(result)
return results
|
[
"async",
"def",
"runall",
"(",
"corogen",
")",
":",
"results",
"=",
"[",
"]",
"for",
"c",
"in",
"corogen",
":",
"result",
"=",
"await",
"c",
"results",
".",
"append",
"(",
"result",
")",
"return",
"results"
] |
Run an array of coroutines
:param corogen: a generator that generates coroutines
:return: list or returns of the coroutines
|
[
"Run",
"an",
"array",
"of",
"coroutines"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/util.py#L186-L197
|
234,256
|
hyperledger/indy-plenum
|
plenum/common/util.py
|
prime_gen
|
def prime_gen() -> int:
# credit to David Eppstein, Wolfgang Beneicke, Paul Hofstra
"""
A generator for prime numbers starting from 2.
"""
D = {}
yield 2
for q in itertools.islice(itertools.count(3), 0, None, 2):
p = D.pop(q, None)
if p is None:
D[q * q] = 2 * q
yield q
else:
x = p + q
while x in D:
x += p
D[x] = p
|
python
|
def prime_gen() -> int:
# credit to David Eppstein, Wolfgang Beneicke, Paul Hofstra
"""
A generator for prime numbers starting from 2.
"""
D = {}
yield 2
for q in itertools.islice(itertools.count(3), 0, None, 2):
p = D.pop(q, None)
if p is None:
D[q * q] = 2 * q
yield q
else:
x = p + q
while x in D:
x += p
D[x] = p
|
[
"def",
"prime_gen",
"(",
")",
"->",
"int",
":",
"# credit to David Eppstein, Wolfgang Beneicke, Paul Hofstra",
"D",
"=",
"{",
"}",
"yield",
"2",
"for",
"q",
"in",
"itertools",
".",
"islice",
"(",
"itertools",
".",
"count",
"(",
"3",
")",
",",
"0",
",",
"None",
",",
"2",
")",
":",
"p",
"=",
"D",
".",
"pop",
"(",
"q",
",",
"None",
")",
"if",
"p",
"is",
"None",
":",
"D",
"[",
"q",
"*",
"q",
"]",
"=",
"2",
"*",
"q",
"yield",
"q",
"else",
":",
"x",
"=",
"p",
"+",
"q",
"while",
"x",
"in",
"D",
":",
"x",
"+=",
"p",
"D",
"[",
"x",
"]",
"=",
"p"
] |
A generator for prime numbers starting from 2.
|
[
"A",
"generator",
"for",
"prime",
"numbers",
"starting",
"from",
"2",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/util.py#L254-L270
|
234,257
|
hyperledger/indy-plenum
|
plenum/common/util.py
|
untilTrue
|
async def untilTrue(condition, *args, timeout=5) -> bool:
"""
Keep checking the condition till it is true or a timeout is reached
:param condition: the condition to check (a function that returns bool)
:param args: the arguments to the condition
:return: True if the condition is met in the given timeout, False otherwise
"""
result = False
start = time.perf_counter()
elapsed = 0
while elapsed < timeout:
result = condition(*args)
if result:
break
await asyncio.sleep(.1)
elapsed = time.perf_counter() - start
return result
|
python
|
async def untilTrue(condition, *args, timeout=5) -> bool:
"""
Keep checking the condition till it is true or a timeout is reached
:param condition: the condition to check (a function that returns bool)
:param args: the arguments to the condition
:return: True if the condition is met in the given timeout, False otherwise
"""
result = False
start = time.perf_counter()
elapsed = 0
while elapsed < timeout:
result = condition(*args)
if result:
break
await asyncio.sleep(.1)
elapsed = time.perf_counter() - start
return result
|
[
"async",
"def",
"untilTrue",
"(",
"condition",
",",
"*",
"args",
",",
"timeout",
"=",
"5",
")",
"->",
"bool",
":",
"result",
"=",
"False",
"start",
"=",
"time",
".",
"perf_counter",
"(",
")",
"elapsed",
"=",
"0",
"while",
"elapsed",
"<",
"timeout",
":",
"result",
"=",
"condition",
"(",
"*",
"args",
")",
"if",
"result",
":",
"break",
"await",
"asyncio",
".",
"sleep",
"(",
".1",
")",
"elapsed",
"=",
"time",
".",
"perf_counter",
"(",
")",
"-",
"start",
"return",
"result"
] |
Keep checking the condition till it is true or a timeout is reached
:param condition: the condition to check (a function that returns bool)
:param args: the arguments to the condition
:return: True if the condition is met in the given timeout, False otherwise
|
[
"Keep",
"checking",
"the",
"condition",
"till",
"it",
"is",
"true",
"or",
"a",
"timeout",
"is",
"reached"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/util.py#L273-L290
|
234,258
|
hyperledger/indy-plenum
|
plenum/common/stacks.py
|
ClientZStack.transmitToClient
|
def transmitToClient(self, msg: Any, remoteName: str):
"""
Transmit the specified message to the remote client specified by `remoteName`.
:param msg: a message
:param remoteName: the name of the remote
"""
payload = self.prepForSending(msg)
try:
if isinstance(remoteName, str):
remoteName = remoteName.encode()
self.send(payload, remoteName)
except Exception as ex:
# TODO: This should not be an error since the client might not have
# sent the request to all nodes but only some nodes and other
# nodes might have got this request through PROPAGATE and thus
# might not have connection with the client.
logger.error(
"{}{} unable to send message {} to client {}; Exception: {}" .format(
CONNECTION_PREFIX, self, msg, remoteName, ex.__repr__()))
|
python
|
def transmitToClient(self, msg: Any, remoteName: str):
"""
Transmit the specified message to the remote client specified by `remoteName`.
:param msg: a message
:param remoteName: the name of the remote
"""
payload = self.prepForSending(msg)
try:
if isinstance(remoteName, str):
remoteName = remoteName.encode()
self.send(payload, remoteName)
except Exception as ex:
# TODO: This should not be an error since the client might not have
# sent the request to all nodes but only some nodes and other
# nodes might have got this request through PROPAGATE and thus
# might not have connection with the client.
logger.error(
"{}{} unable to send message {} to client {}; Exception: {}" .format(
CONNECTION_PREFIX, self, msg, remoteName, ex.__repr__()))
|
[
"def",
"transmitToClient",
"(",
"self",
",",
"msg",
":",
"Any",
",",
"remoteName",
":",
"str",
")",
":",
"payload",
"=",
"self",
".",
"prepForSending",
"(",
"msg",
")",
"try",
":",
"if",
"isinstance",
"(",
"remoteName",
",",
"str",
")",
":",
"remoteName",
"=",
"remoteName",
".",
"encode",
"(",
")",
"self",
".",
"send",
"(",
"payload",
",",
"remoteName",
")",
"except",
"Exception",
"as",
"ex",
":",
"# TODO: This should not be an error since the client might not have",
"# sent the request to all nodes but only some nodes and other",
"# nodes might have got this request through PROPAGATE and thus",
"# might not have connection with the client.",
"logger",
".",
"error",
"(",
"\"{}{} unable to send message {} to client {}; Exception: {}\"",
".",
"format",
"(",
"CONNECTION_PREFIX",
",",
"self",
",",
"msg",
",",
"remoteName",
",",
"ex",
".",
"__repr__",
"(",
")",
")",
")"
] |
Transmit the specified message to the remote client specified by `remoteName`.
:param msg: a message
:param remoteName: the name of the remote
|
[
"Transmit",
"the",
"specified",
"message",
"to",
"the",
"remote",
"client",
"specified",
"by",
"remoteName",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/stacks.py#L139-L158
|
234,259
|
hyperledger/indy-plenum
|
plenum/server/catchup/catchup_rep_service.py
|
CatchupRepService._has_valid_catchup_replies
|
def _has_valid_catchup_replies(self, seq_no: int, txns_to_process: List[Tuple[int, Any]]) -> Tuple[bool, str, int]:
"""
Transforms transactions for ledger!
Returns:
Whether catchup reply corresponding to seq_no
Name of node from which txns came
Number of transactions ready to be processed
"""
# TODO: Remove after stop passing seqNo here
assert seq_no == txns_to_process[0][0]
# Here seqNo has to be the seqNo of first transaction of
# `catchupReplies`
# Get the transactions in the catchup reply which has sequence
# number `seqNo`
node_name, catchup_rep = self._find_catchup_reply_for_seq_no(seq_no)
txns = catchup_rep.txns
# Add only those transaction in the temporary tree from the above
# batch which are not present in the ledger
# Integer keys being converted to strings when marshaled to JSON
txns = [self._provider.transform_txn_for_ledger(txn)
for s, txn in txns_to_process[:len(txns)]
if str(s) in txns]
# Creating a temporary tree which will be used to verify consistency
# proof, by inserting transactions. Duplicating a merkle tree is not
# expensive since we are using a compact merkle tree.
temp_tree = self._ledger.treeWithAppliedTxns(txns)
proof = catchup_rep.consProof
final_size = self._catchup_till.final_size
final_hash = self._catchup_till.final_hash
try:
logger.info("{} verifying proof for {}, {}, {}, {}, {}".
format(self, temp_tree.tree_size, final_size,
temp_tree.root_hash, final_hash, proof))
verified = self._provider.verifier(self._ledger_id).verify_tree_consistency(
temp_tree.tree_size,
final_size,
temp_tree.root_hash,
Ledger.strToHash(final_hash),
[Ledger.strToHash(p) for p in proof]
)
except Exception as ex:
logger.info("{} could not verify catchup reply {} since {}".format(self, catchup_rep, ex))
verified = False
return bool(verified), node_name, len(txns)
|
python
|
def _has_valid_catchup_replies(self, seq_no: int, txns_to_process: List[Tuple[int, Any]]) -> Tuple[bool, str, int]:
"""
Transforms transactions for ledger!
Returns:
Whether catchup reply corresponding to seq_no
Name of node from which txns came
Number of transactions ready to be processed
"""
# TODO: Remove after stop passing seqNo here
assert seq_no == txns_to_process[0][0]
# Here seqNo has to be the seqNo of first transaction of
# `catchupReplies`
# Get the transactions in the catchup reply which has sequence
# number `seqNo`
node_name, catchup_rep = self._find_catchup_reply_for_seq_no(seq_no)
txns = catchup_rep.txns
# Add only those transaction in the temporary tree from the above
# batch which are not present in the ledger
# Integer keys being converted to strings when marshaled to JSON
txns = [self._provider.transform_txn_for_ledger(txn)
for s, txn in txns_to_process[:len(txns)]
if str(s) in txns]
# Creating a temporary tree which will be used to verify consistency
# proof, by inserting transactions. Duplicating a merkle tree is not
# expensive since we are using a compact merkle tree.
temp_tree = self._ledger.treeWithAppliedTxns(txns)
proof = catchup_rep.consProof
final_size = self._catchup_till.final_size
final_hash = self._catchup_till.final_hash
try:
logger.info("{} verifying proof for {}, {}, {}, {}, {}".
format(self, temp_tree.tree_size, final_size,
temp_tree.root_hash, final_hash, proof))
verified = self._provider.verifier(self._ledger_id).verify_tree_consistency(
temp_tree.tree_size,
final_size,
temp_tree.root_hash,
Ledger.strToHash(final_hash),
[Ledger.strToHash(p) for p in proof]
)
except Exception as ex:
logger.info("{} could not verify catchup reply {} since {}".format(self, catchup_rep, ex))
verified = False
return bool(verified), node_name, len(txns)
|
[
"def",
"_has_valid_catchup_replies",
"(",
"self",
",",
"seq_no",
":",
"int",
",",
"txns_to_process",
":",
"List",
"[",
"Tuple",
"[",
"int",
",",
"Any",
"]",
"]",
")",
"->",
"Tuple",
"[",
"bool",
",",
"str",
",",
"int",
"]",
":",
"# TODO: Remove after stop passing seqNo here",
"assert",
"seq_no",
"==",
"txns_to_process",
"[",
"0",
"]",
"[",
"0",
"]",
"# Here seqNo has to be the seqNo of first transaction of",
"# `catchupReplies`",
"# Get the transactions in the catchup reply which has sequence",
"# number `seqNo`",
"node_name",
",",
"catchup_rep",
"=",
"self",
".",
"_find_catchup_reply_for_seq_no",
"(",
"seq_no",
")",
"txns",
"=",
"catchup_rep",
".",
"txns",
"# Add only those transaction in the temporary tree from the above",
"# batch which are not present in the ledger",
"# Integer keys being converted to strings when marshaled to JSON",
"txns",
"=",
"[",
"self",
".",
"_provider",
".",
"transform_txn_for_ledger",
"(",
"txn",
")",
"for",
"s",
",",
"txn",
"in",
"txns_to_process",
"[",
":",
"len",
"(",
"txns",
")",
"]",
"if",
"str",
"(",
"s",
")",
"in",
"txns",
"]",
"# Creating a temporary tree which will be used to verify consistency",
"# proof, by inserting transactions. Duplicating a merkle tree is not",
"# expensive since we are using a compact merkle tree.",
"temp_tree",
"=",
"self",
".",
"_ledger",
".",
"treeWithAppliedTxns",
"(",
"txns",
")",
"proof",
"=",
"catchup_rep",
".",
"consProof",
"final_size",
"=",
"self",
".",
"_catchup_till",
".",
"final_size",
"final_hash",
"=",
"self",
".",
"_catchup_till",
".",
"final_hash",
"try",
":",
"logger",
".",
"info",
"(",
"\"{} verifying proof for {}, {}, {}, {}, {}\"",
".",
"format",
"(",
"self",
",",
"temp_tree",
".",
"tree_size",
",",
"final_size",
",",
"temp_tree",
".",
"root_hash",
",",
"final_hash",
",",
"proof",
")",
")",
"verified",
"=",
"self",
".",
"_provider",
".",
"verifier",
"(",
"self",
".",
"_ledger_id",
")",
".",
"verify_tree_consistency",
"(",
"temp_tree",
".",
"tree_size",
",",
"final_size",
",",
"temp_tree",
".",
"root_hash",
",",
"Ledger",
".",
"strToHash",
"(",
"final_hash",
")",
",",
"[",
"Ledger",
".",
"strToHash",
"(",
"p",
")",
"for",
"p",
"in",
"proof",
"]",
")",
"except",
"Exception",
"as",
"ex",
":",
"logger",
".",
"info",
"(",
"\"{} could not verify catchup reply {} since {}\"",
".",
"format",
"(",
"self",
",",
"catchup_rep",
",",
"ex",
")",
")",
"verified",
"=",
"False",
"return",
"bool",
"(",
"verified",
")",
",",
"node_name",
",",
"len",
"(",
"txns",
")"
] |
Transforms transactions for ledger!
Returns:
Whether catchup reply corresponding to seq_no
Name of node from which txns came
Number of transactions ready to be processed
|
[
"Transforms",
"transactions",
"for",
"ledger!"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/catchup/catchup_rep_service.py#L374-L425
|
234,260
|
hyperledger/indy-plenum
|
plenum/common/stack_manager.py
|
TxnStackManager._parse_pool_transaction_file
|
def _parse_pool_transaction_file(
ledger, nodeReg, cliNodeReg, nodeKeys, activeValidators,
ledger_size=None):
"""
helper function for parseLedgerForHaAndKeys
"""
for _, txn in ledger.getAllTxn(to=ledger_size):
if get_type(txn) == NODE:
txn_data = get_payload_data(txn)
nodeName = txn_data[DATA][ALIAS]
clientStackName = nodeName + CLIENT_STACK_SUFFIX
nHa = (txn_data[DATA][NODE_IP], txn_data[DATA][NODE_PORT]) \
if (NODE_IP in txn_data[DATA] and NODE_PORT in txn_data[DATA]) \
else None
cHa = (txn_data[DATA][CLIENT_IP], txn_data[DATA][CLIENT_PORT]) \
if (CLIENT_IP in txn_data[DATA] and CLIENT_PORT in txn_data[DATA]) \
else None
if nHa:
nodeReg[nodeName] = HA(*nHa)
if cHa:
cliNodeReg[clientStackName] = HA(*cHa)
try:
# TODO: Need to handle abbreviated verkey
key_type = 'verkey'
verkey = cryptonymToHex(str(txn_data[TARGET_NYM]))
key_type = 'identifier'
cryptonymToHex(get_from(txn))
except ValueError:
logger.exception(
'Invalid {}. Rebuild pool transactions.'.format(key_type))
exit('Invalid {}. Rebuild pool transactions.'.format(key_type))
nodeKeys[nodeName] = verkey
services = txn_data[DATA].get(SERVICES)
if isinstance(services, list):
if VALIDATOR in services:
activeValidators.add(nodeName)
else:
activeValidators.discard(nodeName)
|
python
|
def _parse_pool_transaction_file(
ledger, nodeReg, cliNodeReg, nodeKeys, activeValidators,
ledger_size=None):
"""
helper function for parseLedgerForHaAndKeys
"""
for _, txn in ledger.getAllTxn(to=ledger_size):
if get_type(txn) == NODE:
txn_data = get_payload_data(txn)
nodeName = txn_data[DATA][ALIAS]
clientStackName = nodeName + CLIENT_STACK_SUFFIX
nHa = (txn_data[DATA][NODE_IP], txn_data[DATA][NODE_PORT]) \
if (NODE_IP in txn_data[DATA] and NODE_PORT in txn_data[DATA]) \
else None
cHa = (txn_data[DATA][CLIENT_IP], txn_data[DATA][CLIENT_PORT]) \
if (CLIENT_IP in txn_data[DATA] and CLIENT_PORT in txn_data[DATA]) \
else None
if nHa:
nodeReg[nodeName] = HA(*nHa)
if cHa:
cliNodeReg[clientStackName] = HA(*cHa)
try:
# TODO: Need to handle abbreviated verkey
key_type = 'verkey'
verkey = cryptonymToHex(str(txn_data[TARGET_NYM]))
key_type = 'identifier'
cryptonymToHex(get_from(txn))
except ValueError:
logger.exception(
'Invalid {}. Rebuild pool transactions.'.format(key_type))
exit('Invalid {}. Rebuild pool transactions.'.format(key_type))
nodeKeys[nodeName] = verkey
services = txn_data[DATA].get(SERVICES)
if isinstance(services, list):
if VALIDATOR in services:
activeValidators.add(nodeName)
else:
activeValidators.discard(nodeName)
|
[
"def",
"_parse_pool_transaction_file",
"(",
"ledger",
",",
"nodeReg",
",",
"cliNodeReg",
",",
"nodeKeys",
",",
"activeValidators",
",",
"ledger_size",
"=",
"None",
")",
":",
"for",
"_",
",",
"txn",
"in",
"ledger",
".",
"getAllTxn",
"(",
"to",
"=",
"ledger_size",
")",
":",
"if",
"get_type",
"(",
"txn",
")",
"==",
"NODE",
":",
"txn_data",
"=",
"get_payload_data",
"(",
"txn",
")",
"nodeName",
"=",
"txn_data",
"[",
"DATA",
"]",
"[",
"ALIAS",
"]",
"clientStackName",
"=",
"nodeName",
"+",
"CLIENT_STACK_SUFFIX",
"nHa",
"=",
"(",
"txn_data",
"[",
"DATA",
"]",
"[",
"NODE_IP",
"]",
",",
"txn_data",
"[",
"DATA",
"]",
"[",
"NODE_PORT",
"]",
")",
"if",
"(",
"NODE_IP",
"in",
"txn_data",
"[",
"DATA",
"]",
"and",
"NODE_PORT",
"in",
"txn_data",
"[",
"DATA",
"]",
")",
"else",
"None",
"cHa",
"=",
"(",
"txn_data",
"[",
"DATA",
"]",
"[",
"CLIENT_IP",
"]",
",",
"txn_data",
"[",
"DATA",
"]",
"[",
"CLIENT_PORT",
"]",
")",
"if",
"(",
"CLIENT_IP",
"in",
"txn_data",
"[",
"DATA",
"]",
"and",
"CLIENT_PORT",
"in",
"txn_data",
"[",
"DATA",
"]",
")",
"else",
"None",
"if",
"nHa",
":",
"nodeReg",
"[",
"nodeName",
"]",
"=",
"HA",
"(",
"*",
"nHa",
")",
"if",
"cHa",
":",
"cliNodeReg",
"[",
"clientStackName",
"]",
"=",
"HA",
"(",
"*",
"cHa",
")",
"try",
":",
"# TODO: Need to handle abbreviated verkey",
"key_type",
"=",
"'verkey'",
"verkey",
"=",
"cryptonymToHex",
"(",
"str",
"(",
"txn_data",
"[",
"TARGET_NYM",
"]",
")",
")",
"key_type",
"=",
"'identifier'",
"cryptonymToHex",
"(",
"get_from",
"(",
"txn",
")",
")",
"except",
"ValueError",
":",
"logger",
".",
"exception",
"(",
"'Invalid {}. Rebuild pool transactions.'",
".",
"format",
"(",
"key_type",
")",
")",
"exit",
"(",
"'Invalid {}. Rebuild pool transactions.'",
".",
"format",
"(",
"key_type",
")",
")",
"nodeKeys",
"[",
"nodeName",
"]",
"=",
"verkey",
"services",
"=",
"txn_data",
"[",
"DATA",
"]",
".",
"get",
"(",
"SERVICES",
")",
"if",
"isinstance",
"(",
"services",
",",
"list",
")",
":",
"if",
"VALIDATOR",
"in",
"services",
":",
"activeValidators",
".",
"add",
"(",
"nodeName",
")",
"else",
":",
"activeValidators",
".",
"discard",
"(",
"nodeName",
")"
] |
helper function for parseLedgerForHaAndKeys
|
[
"helper",
"function",
"for",
"parseLedgerForHaAndKeys"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/stack_manager.py#L58-L98
|
234,261
|
hyperledger/indy-plenum
|
ledger/merkle_verifier.py
|
MerkleVerifier.verify_tree_consistency
|
def verify_tree_consistency(self, old_tree_size: int, new_tree_size: int,
old_root: bytes, new_root: bytes,
proof: Sequence[bytes]):
"""Verify the consistency between two root hashes.
old_tree_size must be <= new_tree_size.
Args:
old_tree_size: size of the older tree.
new_tree_size: size of the newer_tree.
old_root: the root hash of the older tree.
new_root: the root hash of the newer tree.
proof: the consistency proof.
Returns:
True. The return value is enforced by a decorator and need not be
checked by the caller.
Raises:
ConsistencyError: the proof indicates an inconsistency
(this is usually really serious!).
ProofError: the proof is invalid.
ValueError: supplied tree sizes are invalid.
"""
old_size = old_tree_size
new_size = new_tree_size
if old_size < 0 or new_size < 0:
raise ValueError("Negative tree size")
if old_size > new_size:
raise ValueError("Older tree has bigger size (%d vs %d), did "
"you supply inputs in the wrong order?" %
(old_size, new_size))
if old_size == new_size:
if old_root == new_root:
if proof:
logging.debug("Trees are identical, ignoring proof")
return True
else:
raise error.ConsistencyError("Inconsistency: different root "
"hashes for the same tree size")
if old_size == 0:
if proof:
# A consistency proof with an empty tree is an empty proof.
# Anything is consistent with an empty tree, so ignore whatever
# bogus proof was supplied. Note we do not verify here that the
# root hash is a valid hash for an empty tree.
logging.debug("Ignoring non-empty consistency proof for "
"empty tree.")
return True
# Now 0 < old_size < new_size
# A consistency proof is essentially an audit proof for the node with
# index old_size - 1 in the newer tree. The sole difference is that
# the path is already hashed together into a single hash up until the
# first audit node that occurs in the newer tree only.
node = old_size - 1
last_node = new_size - 1
# While we are the right child, everything is in both trees,
# so move one level up.
while node % 2:
node //= 2
last_node //= 2
p = iter(proof)
try:
if node:
# Compute the two root hashes in parallel.
new_hash = old_hash = next(p)
else:
# The old tree was balanced (2**k nodes), so we already have
# the first root hash.
new_hash = old_hash = old_root
while node:
if node % 2:
# node is a right child: left sibling exists in both trees.
next_node = next(p)
old_hash = self.hasher.hash_children(next_node, old_hash)
new_hash = self.hasher.hash_children(next_node, new_hash)
elif node < last_node:
# node is a left child: right sibling only exists in the
# newer tree.
new_hash = self.hasher.hash_children(new_hash, next(p))
# else node == last_node: node is a left child with no sibling
# in either tree.
node //= 2
last_node //= 2
# Now old_hash is the hash of the first subtree. If the two trees
# have different height, continue the path until the new root.
while last_node:
n = next(p)
new_hash = self.hasher.hash_children(new_hash, n)
last_node //= 2
# If the second hash does not match, the proof is invalid for the
# given pair. If, on the other hand, the newer hash matches but the
# older one doesn't, then the proof (together with the signatures
# on the hashes) is proof of inconsistency.
# Continue to find out.
if new_hash != new_root:
raise error.ProofError("Bad Merkle proof: second root hash "
"does not match. Expected hash: %s "
", computed hash: %s" %
(hexlify(new_root).strip(),
hexlify(new_hash).strip()))
elif old_hash != old_root:
raise error.ConsistencyError("Inconsistency: first root hash "
"does not match. Expected hash: "
"%s, computed hash: %s" %
(hexlify(old_root).strip(),
hexlify(old_hash).strip())
)
except StopIteration:
raise error.ProofError("Merkle proof is too short")
# We've already verified consistency, so accept the proof even if
# there's garbage left over (but log a warning).
try:
next(p)
except StopIteration:
pass
else:
logging.debug("Proof has extra nodes")
return True
|
python
|
def verify_tree_consistency(self, old_tree_size: int, new_tree_size: int,
old_root: bytes, new_root: bytes,
proof: Sequence[bytes]):
"""Verify the consistency between two root hashes.
old_tree_size must be <= new_tree_size.
Args:
old_tree_size: size of the older tree.
new_tree_size: size of the newer_tree.
old_root: the root hash of the older tree.
new_root: the root hash of the newer tree.
proof: the consistency proof.
Returns:
True. The return value is enforced by a decorator and need not be
checked by the caller.
Raises:
ConsistencyError: the proof indicates an inconsistency
(this is usually really serious!).
ProofError: the proof is invalid.
ValueError: supplied tree sizes are invalid.
"""
old_size = old_tree_size
new_size = new_tree_size
if old_size < 0 or new_size < 0:
raise ValueError("Negative tree size")
if old_size > new_size:
raise ValueError("Older tree has bigger size (%d vs %d), did "
"you supply inputs in the wrong order?" %
(old_size, new_size))
if old_size == new_size:
if old_root == new_root:
if proof:
logging.debug("Trees are identical, ignoring proof")
return True
else:
raise error.ConsistencyError("Inconsistency: different root "
"hashes for the same tree size")
if old_size == 0:
if proof:
# A consistency proof with an empty tree is an empty proof.
# Anything is consistent with an empty tree, so ignore whatever
# bogus proof was supplied. Note we do not verify here that the
# root hash is a valid hash for an empty tree.
logging.debug("Ignoring non-empty consistency proof for "
"empty tree.")
return True
# Now 0 < old_size < new_size
# A consistency proof is essentially an audit proof for the node with
# index old_size - 1 in the newer tree. The sole difference is that
# the path is already hashed together into a single hash up until the
# first audit node that occurs in the newer tree only.
node = old_size - 1
last_node = new_size - 1
# While we are the right child, everything is in both trees,
# so move one level up.
while node % 2:
node //= 2
last_node //= 2
p = iter(proof)
try:
if node:
# Compute the two root hashes in parallel.
new_hash = old_hash = next(p)
else:
# The old tree was balanced (2**k nodes), so we already have
# the first root hash.
new_hash = old_hash = old_root
while node:
if node % 2:
# node is a right child: left sibling exists in both trees.
next_node = next(p)
old_hash = self.hasher.hash_children(next_node, old_hash)
new_hash = self.hasher.hash_children(next_node, new_hash)
elif node < last_node:
# node is a left child: right sibling only exists in the
# newer tree.
new_hash = self.hasher.hash_children(new_hash, next(p))
# else node == last_node: node is a left child with no sibling
# in either tree.
node //= 2
last_node //= 2
# Now old_hash is the hash of the first subtree. If the two trees
# have different height, continue the path until the new root.
while last_node:
n = next(p)
new_hash = self.hasher.hash_children(new_hash, n)
last_node //= 2
# If the second hash does not match, the proof is invalid for the
# given pair. If, on the other hand, the newer hash matches but the
# older one doesn't, then the proof (together with the signatures
# on the hashes) is proof of inconsistency.
# Continue to find out.
if new_hash != new_root:
raise error.ProofError("Bad Merkle proof: second root hash "
"does not match. Expected hash: %s "
", computed hash: %s" %
(hexlify(new_root).strip(),
hexlify(new_hash).strip()))
elif old_hash != old_root:
raise error.ConsistencyError("Inconsistency: first root hash "
"does not match. Expected hash: "
"%s, computed hash: %s" %
(hexlify(old_root).strip(),
hexlify(old_hash).strip())
)
except StopIteration:
raise error.ProofError("Merkle proof is too short")
# We've already verified consistency, so accept the proof even if
# there's garbage left over (but log a warning).
try:
next(p)
except StopIteration:
pass
else:
logging.debug("Proof has extra nodes")
return True
|
[
"def",
"verify_tree_consistency",
"(",
"self",
",",
"old_tree_size",
":",
"int",
",",
"new_tree_size",
":",
"int",
",",
"old_root",
":",
"bytes",
",",
"new_root",
":",
"bytes",
",",
"proof",
":",
"Sequence",
"[",
"bytes",
"]",
")",
":",
"old_size",
"=",
"old_tree_size",
"new_size",
"=",
"new_tree_size",
"if",
"old_size",
"<",
"0",
"or",
"new_size",
"<",
"0",
":",
"raise",
"ValueError",
"(",
"\"Negative tree size\"",
")",
"if",
"old_size",
">",
"new_size",
":",
"raise",
"ValueError",
"(",
"\"Older tree has bigger size (%d vs %d), did \"",
"\"you supply inputs in the wrong order?\"",
"%",
"(",
"old_size",
",",
"new_size",
")",
")",
"if",
"old_size",
"==",
"new_size",
":",
"if",
"old_root",
"==",
"new_root",
":",
"if",
"proof",
":",
"logging",
".",
"debug",
"(",
"\"Trees are identical, ignoring proof\"",
")",
"return",
"True",
"else",
":",
"raise",
"error",
".",
"ConsistencyError",
"(",
"\"Inconsistency: different root \"",
"\"hashes for the same tree size\"",
")",
"if",
"old_size",
"==",
"0",
":",
"if",
"proof",
":",
"# A consistency proof with an empty tree is an empty proof.",
"# Anything is consistent with an empty tree, so ignore whatever",
"# bogus proof was supplied. Note we do not verify here that the",
"# root hash is a valid hash for an empty tree.",
"logging",
".",
"debug",
"(",
"\"Ignoring non-empty consistency proof for \"",
"\"empty tree.\"",
")",
"return",
"True",
"# Now 0 < old_size < new_size",
"# A consistency proof is essentially an audit proof for the node with",
"# index old_size - 1 in the newer tree. The sole difference is that",
"# the path is already hashed together into a single hash up until the",
"# first audit node that occurs in the newer tree only.",
"node",
"=",
"old_size",
"-",
"1",
"last_node",
"=",
"new_size",
"-",
"1",
"# While we are the right child, everything is in both trees,",
"# so move one level up.",
"while",
"node",
"%",
"2",
":",
"node",
"//=",
"2",
"last_node",
"//=",
"2",
"p",
"=",
"iter",
"(",
"proof",
")",
"try",
":",
"if",
"node",
":",
"# Compute the two root hashes in parallel.",
"new_hash",
"=",
"old_hash",
"=",
"next",
"(",
"p",
")",
"else",
":",
"# The old tree was balanced (2**k nodes), so we already have",
"# the first root hash.",
"new_hash",
"=",
"old_hash",
"=",
"old_root",
"while",
"node",
":",
"if",
"node",
"%",
"2",
":",
"# node is a right child: left sibling exists in both trees.",
"next_node",
"=",
"next",
"(",
"p",
")",
"old_hash",
"=",
"self",
".",
"hasher",
".",
"hash_children",
"(",
"next_node",
",",
"old_hash",
")",
"new_hash",
"=",
"self",
".",
"hasher",
".",
"hash_children",
"(",
"next_node",
",",
"new_hash",
")",
"elif",
"node",
"<",
"last_node",
":",
"# node is a left child: right sibling only exists in the",
"# newer tree.",
"new_hash",
"=",
"self",
".",
"hasher",
".",
"hash_children",
"(",
"new_hash",
",",
"next",
"(",
"p",
")",
")",
"# else node == last_node: node is a left child with no sibling",
"# in either tree.",
"node",
"//=",
"2",
"last_node",
"//=",
"2",
"# Now old_hash is the hash of the first subtree. If the two trees",
"# have different height, continue the path until the new root.",
"while",
"last_node",
":",
"n",
"=",
"next",
"(",
"p",
")",
"new_hash",
"=",
"self",
".",
"hasher",
".",
"hash_children",
"(",
"new_hash",
",",
"n",
")",
"last_node",
"//=",
"2",
"# If the second hash does not match, the proof is invalid for the",
"# given pair. If, on the other hand, the newer hash matches but the",
"# older one doesn't, then the proof (together with the signatures",
"# on the hashes) is proof of inconsistency.",
"# Continue to find out.",
"if",
"new_hash",
"!=",
"new_root",
":",
"raise",
"error",
".",
"ProofError",
"(",
"\"Bad Merkle proof: second root hash \"",
"\"does not match. Expected hash: %s \"",
"\", computed hash: %s\"",
"%",
"(",
"hexlify",
"(",
"new_root",
")",
".",
"strip",
"(",
")",
",",
"hexlify",
"(",
"new_hash",
")",
".",
"strip",
"(",
")",
")",
")",
"elif",
"old_hash",
"!=",
"old_root",
":",
"raise",
"error",
".",
"ConsistencyError",
"(",
"\"Inconsistency: first root hash \"",
"\"does not match. Expected hash: \"",
"\"%s, computed hash: %s\"",
"%",
"(",
"hexlify",
"(",
"old_root",
")",
".",
"strip",
"(",
")",
",",
"hexlify",
"(",
"old_hash",
")",
".",
"strip",
"(",
")",
")",
")",
"except",
"StopIteration",
":",
"raise",
"error",
".",
"ProofError",
"(",
"\"Merkle proof is too short\"",
")",
"# We've already verified consistency, so accept the proof even if",
"# there's garbage left over (but log a warning).",
"try",
":",
"next",
"(",
"p",
")",
"except",
"StopIteration",
":",
"pass",
"else",
":",
"logging",
".",
"debug",
"(",
"\"Proof has extra nodes\"",
")",
"return",
"True"
] |
Verify the consistency between two root hashes.
old_tree_size must be <= new_tree_size.
Args:
old_tree_size: size of the older tree.
new_tree_size: size of the newer_tree.
old_root: the root hash of the older tree.
new_root: the root hash of the newer tree.
proof: the consistency proof.
Returns:
True. The return value is enforced by a decorator and need not be
checked by the caller.
Raises:
ConsistencyError: the proof indicates an inconsistency
(this is usually really serious!).
ProofError: the proof is invalid.
ValueError: supplied tree sizes are invalid.
|
[
"Verify",
"the",
"consistency",
"between",
"two",
"root",
"hashes",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/merkle_verifier.py#L23-L153
|
234,262
|
hyperledger/indy-plenum
|
plenum/server/has_action_queue.py
|
HasActionQueue._schedule
|
def _schedule(self, action: Callable, seconds: int=0) -> int:
"""
Schedule an action to be executed after `seconds` seconds.
:param action: a callable to be scheduled
:param seconds: the time in seconds after which the action must be executed
"""
self.aid += 1
if seconds > 0:
nxt = time.perf_counter() + seconds
if nxt < self.aqNextCheck:
self.aqNextCheck = nxt
logger.trace("{} scheduling action {} with id {} to run in {} "
"seconds".format(self, get_func_name(action),
self.aid, seconds))
self.aqStash.append((nxt, (action, self.aid)))
else:
logger.trace("{} scheduling action {} with id {} to run now".
format(self, get_func_name(action), self.aid))
self.actionQueue.append((action, self.aid))
if action not in self.scheduled:
self.scheduled[action] = []
self.scheduled[action].append(self.aid)
return self.aid
|
python
|
def _schedule(self, action: Callable, seconds: int=0) -> int:
"""
Schedule an action to be executed after `seconds` seconds.
:param action: a callable to be scheduled
:param seconds: the time in seconds after which the action must be executed
"""
self.aid += 1
if seconds > 0:
nxt = time.perf_counter() + seconds
if nxt < self.aqNextCheck:
self.aqNextCheck = nxt
logger.trace("{} scheduling action {} with id {} to run in {} "
"seconds".format(self, get_func_name(action),
self.aid, seconds))
self.aqStash.append((nxt, (action, self.aid)))
else:
logger.trace("{} scheduling action {} with id {} to run now".
format(self, get_func_name(action), self.aid))
self.actionQueue.append((action, self.aid))
if action not in self.scheduled:
self.scheduled[action] = []
self.scheduled[action].append(self.aid)
return self.aid
|
[
"def",
"_schedule",
"(",
"self",
",",
"action",
":",
"Callable",
",",
"seconds",
":",
"int",
"=",
"0",
")",
"->",
"int",
":",
"self",
".",
"aid",
"+=",
"1",
"if",
"seconds",
">",
"0",
":",
"nxt",
"=",
"time",
".",
"perf_counter",
"(",
")",
"+",
"seconds",
"if",
"nxt",
"<",
"self",
".",
"aqNextCheck",
":",
"self",
".",
"aqNextCheck",
"=",
"nxt",
"logger",
".",
"trace",
"(",
"\"{} scheduling action {} with id {} to run in {} \"",
"\"seconds\"",
".",
"format",
"(",
"self",
",",
"get_func_name",
"(",
"action",
")",
",",
"self",
".",
"aid",
",",
"seconds",
")",
")",
"self",
".",
"aqStash",
".",
"append",
"(",
"(",
"nxt",
",",
"(",
"action",
",",
"self",
".",
"aid",
")",
")",
")",
"else",
":",
"logger",
".",
"trace",
"(",
"\"{} scheduling action {} with id {} to run now\"",
".",
"format",
"(",
"self",
",",
"get_func_name",
"(",
"action",
")",
",",
"self",
".",
"aid",
")",
")",
"self",
".",
"actionQueue",
".",
"append",
"(",
"(",
"action",
",",
"self",
".",
"aid",
")",
")",
"if",
"action",
"not",
"in",
"self",
".",
"scheduled",
":",
"self",
".",
"scheduled",
"[",
"action",
"]",
"=",
"[",
"]",
"self",
".",
"scheduled",
"[",
"action",
"]",
".",
"append",
"(",
"self",
".",
"aid",
")",
"return",
"self",
".",
"aid"
] |
Schedule an action to be executed after `seconds` seconds.
:param action: a callable to be scheduled
:param seconds: the time in seconds after which the action must be executed
|
[
"Schedule",
"an",
"action",
"to",
"be",
"executed",
"after",
"seconds",
"seconds",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/has_action_queue.py#L23-L48
|
234,263
|
hyperledger/indy-plenum
|
plenum/server/has_action_queue.py
|
HasActionQueue._cancel
|
def _cancel(self, action: Callable = None, aid: int = None):
"""
Cancel scheduled events
:param action: (optional) scheduled action. If specified, all
scheduled events for the action are cancelled.
:param aid: (options) scheduled event id. If specified,
scheduled event with the aid is cancelled.
"""
if action is not None:
if action in self.scheduled:
logger.trace("{} cancelling all events for action {}, ids: {}"
"".format(self, action, self.scheduled[action]))
self.scheduled[action].clear()
elif aid is not None:
for action, aids in self.scheduled.items():
try:
aids.remove(aid)
except ValueError:
pass
else:
logger.trace("{} cancelled action {} with id {}".format(self, action, aid))
break
|
python
|
def _cancel(self, action: Callable = None, aid: int = None):
"""
Cancel scheduled events
:param action: (optional) scheduled action. If specified, all
scheduled events for the action are cancelled.
:param aid: (options) scheduled event id. If specified,
scheduled event with the aid is cancelled.
"""
if action is not None:
if action in self.scheduled:
logger.trace("{} cancelling all events for action {}, ids: {}"
"".format(self, action, self.scheduled[action]))
self.scheduled[action].clear()
elif aid is not None:
for action, aids in self.scheduled.items():
try:
aids.remove(aid)
except ValueError:
pass
else:
logger.trace("{} cancelled action {} with id {}".format(self, action, aid))
break
|
[
"def",
"_cancel",
"(",
"self",
",",
"action",
":",
"Callable",
"=",
"None",
",",
"aid",
":",
"int",
"=",
"None",
")",
":",
"if",
"action",
"is",
"not",
"None",
":",
"if",
"action",
"in",
"self",
".",
"scheduled",
":",
"logger",
".",
"trace",
"(",
"\"{} cancelling all events for action {}, ids: {}\"",
"\"\"",
".",
"format",
"(",
"self",
",",
"action",
",",
"self",
".",
"scheduled",
"[",
"action",
"]",
")",
")",
"self",
".",
"scheduled",
"[",
"action",
"]",
".",
"clear",
"(",
")",
"elif",
"aid",
"is",
"not",
"None",
":",
"for",
"action",
",",
"aids",
"in",
"self",
".",
"scheduled",
".",
"items",
"(",
")",
":",
"try",
":",
"aids",
".",
"remove",
"(",
"aid",
")",
"except",
"ValueError",
":",
"pass",
"else",
":",
"logger",
".",
"trace",
"(",
"\"{} cancelled action {} with id {}\"",
".",
"format",
"(",
"self",
",",
"action",
",",
"aid",
")",
")",
"break"
] |
Cancel scheduled events
:param action: (optional) scheduled action. If specified, all
scheduled events for the action are cancelled.
:param aid: (options) scheduled event id. If specified,
scheduled event with the aid is cancelled.
|
[
"Cancel",
"scheduled",
"events"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/has_action_queue.py#L50-L72
|
234,264
|
hyperledger/indy-plenum
|
plenum/server/has_action_queue.py
|
HasActionQueue._serviceActions
|
def _serviceActions(self) -> int:
"""
Run all pending actions in the action queue.
:return: number of actions executed.
"""
if self.aqStash:
tm = time.perf_counter()
if tm > self.aqNextCheck:
earliest = float('inf')
for d in list(self.aqStash):
nxt, action = d
if tm > nxt:
self.actionQueue.appendleft(action)
self.aqStash.remove(d)
if nxt < earliest:
earliest = nxt
self.aqNextCheck = earliest
count = len(self.actionQueue)
while self.actionQueue:
action, aid = self.actionQueue.popleft()
assert action in self.scheduled
if aid in self.scheduled[action]:
self.scheduled[action].remove(aid)
logger.trace("{} running action {} with id {}".
format(self, get_func_name(action), aid))
action()
else:
logger.trace("{} not running cancelled action {} with id {}".
format(self, get_func_name(action), aid))
return count
|
python
|
def _serviceActions(self) -> int:
"""
Run all pending actions in the action queue.
:return: number of actions executed.
"""
if self.aqStash:
tm = time.perf_counter()
if tm > self.aqNextCheck:
earliest = float('inf')
for d in list(self.aqStash):
nxt, action = d
if tm > nxt:
self.actionQueue.appendleft(action)
self.aqStash.remove(d)
if nxt < earliest:
earliest = nxt
self.aqNextCheck = earliest
count = len(self.actionQueue)
while self.actionQueue:
action, aid = self.actionQueue.popleft()
assert action in self.scheduled
if aid in self.scheduled[action]:
self.scheduled[action].remove(aid)
logger.trace("{} running action {} with id {}".
format(self, get_func_name(action), aid))
action()
else:
logger.trace("{} not running cancelled action {} with id {}".
format(self, get_func_name(action), aid))
return count
|
[
"def",
"_serviceActions",
"(",
"self",
")",
"->",
"int",
":",
"if",
"self",
".",
"aqStash",
":",
"tm",
"=",
"time",
".",
"perf_counter",
"(",
")",
"if",
"tm",
">",
"self",
".",
"aqNextCheck",
":",
"earliest",
"=",
"float",
"(",
"'inf'",
")",
"for",
"d",
"in",
"list",
"(",
"self",
".",
"aqStash",
")",
":",
"nxt",
",",
"action",
"=",
"d",
"if",
"tm",
">",
"nxt",
":",
"self",
".",
"actionQueue",
".",
"appendleft",
"(",
"action",
")",
"self",
".",
"aqStash",
".",
"remove",
"(",
"d",
")",
"if",
"nxt",
"<",
"earliest",
":",
"earliest",
"=",
"nxt",
"self",
".",
"aqNextCheck",
"=",
"earliest",
"count",
"=",
"len",
"(",
"self",
".",
"actionQueue",
")",
"while",
"self",
".",
"actionQueue",
":",
"action",
",",
"aid",
"=",
"self",
".",
"actionQueue",
".",
"popleft",
"(",
")",
"assert",
"action",
"in",
"self",
".",
"scheduled",
"if",
"aid",
"in",
"self",
".",
"scheduled",
"[",
"action",
"]",
":",
"self",
".",
"scheduled",
"[",
"action",
"]",
".",
"remove",
"(",
"aid",
")",
"logger",
".",
"trace",
"(",
"\"{} running action {} with id {}\"",
".",
"format",
"(",
"self",
",",
"get_func_name",
"(",
"action",
")",
",",
"aid",
")",
")",
"action",
"(",
")",
"else",
":",
"logger",
".",
"trace",
"(",
"\"{} not running cancelled action {} with id {}\"",
".",
"format",
"(",
"self",
",",
"get_func_name",
"(",
"action",
")",
",",
"aid",
")",
")",
"return",
"count"
] |
Run all pending actions in the action queue.
:return: number of actions executed.
|
[
"Run",
"all",
"pending",
"actions",
"in",
"the",
"action",
"queue",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/has_action_queue.py#L74-L104
|
234,265
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.execute_pool_txns
|
def execute_pool_txns(self, three_pc_batch) -> List:
"""
Execute a transaction that involves consensus pool management, like
adding a node, client or a steward.
:param ppTime: PrePrepare request time
:param reqs_keys: requests keys to be committed
"""
committed_txns = self.default_executer(three_pc_batch)
for txn in committed_txns:
self.poolManager.onPoolMembershipChange(txn)
return committed_txns
|
python
|
def execute_pool_txns(self, three_pc_batch) -> List:
"""
Execute a transaction that involves consensus pool management, like
adding a node, client or a steward.
:param ppTime: PrePrepare request time
:param reqs_keys: requests keys to be committed
"""
committed_txns = self.default_executer(three_pc_batch)
for txn in committed_txns:
self.poolManager.onPoolMembershipChange(txn)
return committed_txns
|
[
"def",
"execute_pool_txns",
"(",
"self",
",",
"three_pc_batch",
")",
"->",
"List",
":",
"committed_txns",
"=",
"self",
".",
"default_executer",
"(",
"three_pc_batch",
")",
"for",
"txn",
"in",
"committed_txns",
":",
"self",
".",
"poolManager",
".",
"onPoolMembershipChange",
"(",
"txn",
")",
"return",
"committed_txns"
] |
Execute a transaction that involves consensus pool management, like
adding a node, client or a steward.
:param ppTime: PrePrepare request time
:param reqs_keys: requests keys to be committed
|
[
"Execute",
"a",
"transaction",
"that",
"involves",
"consensus",
"pool",
"management",
"like",
"adding",
"a",
"node",
"client",
"or",
"a",
"steward",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L637-L648
|
234,266
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.init_state_from_ledger
|
def init_state_from_ledger(self, state: State, ledger: Ledger, reqHandler):
"""
If the trie is empty then initialize it by applying
txns from ledger.
"""
if state.isEmpty:
logger.info('{} found state to be empty, recreating from '
'ledger'.format(self))
for seq_no, txn in ledger.getAllTxn():
txn = self.update_txn_with_extra_data(txn)
reqHandler.updateState([txn, ], isCommitted=True)
state.commit(rootHash=state.headHash)
|
python
|
def init_state_from_ledger(self, state: State, ledger: Ledger, reqHandler):
"""
If the trie is empty then initialize it by applying
txns from ledger.
"""
if state.isEmpty:
logger.info('{} found state to be empty, recreating from '
'ledger'.format(self))
for seq_no, txn in ledger.getAllTxn():
txn = self.update_txn_with_extra_data(txn)
reqHandler.updateState([txn, ], isCommitted=True)
state.commit(rootHash=state.headHash)
|
[
"def",
"init_state_from_ledger",
"(",
"self",
",",
"state",
":",
"State",
",",
"ledger",
":",
"Ledger",
",",
"reqHandler",
")",
":",
"if",
"state",
".",
"isEmpty",
":",
"logger",
".",
"info",
"(",
"'{} found state to be empty, recreating from '",
"'ledger'",
".",
"format",
"(",
"self",
")",
")",
"for",
"seq_no",
",",
"txn",
"in",
"ledger",
".",
"getAllTxn",
"(",
")",
":",
"txn",
"=",
"self",
".",
"update_txn_with_extra_data",
"(",
"txn",
")",
"reqHandler",
".",
"updateState",
"(",
"[",
"txn",
",",
"]",
",",
"isCommitted",
"=",
"True",
")",
"state",
".",
"commit",
"(",
"rootHash",
"=",
"state",
".",
"headHash",
")"
] |
If the trie is empty then initialize it by applying
txns from ledger.
|
[
"If",
"the",
"trie",
"is",
"empty",
"then",
"initialize",
"it",
"by",
"applying",
"txns",
"from",
"ledger",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L663-L674
|
234,267
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.on_view_change_start
|
def on_view_change_start(self):
"""
Notifies node about the fact that view changed to let it
prepare for election
"""
self.view_changer.start_view_change_ts = self.utc_epoch()
for replica in self.replicas.values():
replica.on_view_change_start()
logger.info("{} resetting monitor stats at view change start".format(self))
self.monitor.reset()
self.processStashedMsgsForView(self.viewNo)
self.backup_instance_faulty_processor.restore_replicas()
self.drop_primaries()
pop_keys(self.msgsForFutureViews, lambda x: x <= self.viewNo)
self.logNodeInfo()
# Keep on doing catchup until >(n-f) nodes LedgerStatus same on have a
# prepared certificate the first PRE-PREPARE of the new view
logger.info('{}{} changed to view {}, will start catchup now'.
format(VIEW_CHANGE_PREFIX, self, self.viewNo))
self._cancel(self._check_view_change_completed)
self._schedule(action=self._check_view_change_completed,
seconds=self._view_change_timeout)
# Set to 0 even when set to 0 in `on_view_change_complete` since
# catchup might be started due to several reasons.
self.catchup_rounds_without_txns = 0
self.last_sent_pp_store_helper.erase_last_sent_pp_seq_no()
|
python
|
def on_view_change_start(self):
"""
Notifies node about the fact that view changed to let it
prepare for election
"""
self.view_changer.start_view_change_ts = self.utc_epoch()
for replica in self.replicas.values():
replica.on_view_change_start()
logger.info("{} resetting monitor stats at view change start".format(self))
self.monitor.reset()
self.processStashedMsgsForView(self.viewNo)
self.backup_instance_faulty_processor.restore_replicas()
self.drop_primaries()
pop_keys(self.msgsForFutureViews, lambda x: x <= self.viewNo)
self.logNodeInfo()
# Keep on doing catchup until >(n-f) nodes LedgerStatus same on have a
# prepared certificate the first PRE-PREPARE of the new view
logger.info('{}{} changed to view {}, will start catchup now'.
format(VIEW_CHANGE_PREFIX, self, self.viewNo))
self._cancel(self._check_view_change_completed)
self._schedule(action=self._check_view_change_completed,
seconds=self._view_change_timeout)
# Set to 0 even when set to 0 in `on_view_change_complete` since
# catchup might be started due to several reasons.
self.catchup_rounds_without_txns = 0
self.last_sent_pp_store_helper.erase_last_sent_pp_seq_no()
|
[
"def",
"on_view_change_start",
"(",
"self",
")",
":",
"self",
".",
"view_changer",
".",
"start_view_change_ts",
"=",
"self",
".",
"utc_epoch",
"(",
")",
"for",
"replica",
"in",
"self",
".",
"replicas",
".",
"values",
"(",
")",
":",
"replica",
".",
"on_view_change_start",
"(",
")",
"logger",
".",
"info",
"(",
"\"{} resetting monitor stats at view change start\"",
".",
"format",
"(",
"self",
")",
")",
"self",
".",
"monitor",
".",
"reset",
"(",
")",
"self",
".",
"processStashedMsgsForView",
"(",
"self",
".",
"viewNo",
")",
"self",
".",
"backup_instance_faulty_processor",
".",
"restore_replicas",
"(",
")",
"self",
".",
"drop_primaries",
"(",
")",
"pop_keys",
"(",
"self",
".",
"msgsForFutureViews",
",",
"lambda",
"x",
":",
"x",
"<=",
"self",
".",
"viewNo",
")",
"self",
".",
"logNodeInfo",
"(",
")",
"# Keep on doing catchup until >(n-f) nodes LedgerStatus same on have a",
"# prepared certificate the first PRE-PREPARE of the new view",
"logger",
".",
"info",
"(",
"'{}{} changed to view {}, will start catchup now'",
".",
"format",
"(",
"VIEW_CHANGE_PREFIX",
",",
"self",
",",
"self",
".",
"viewNo",
")",
")",
"self",
".",
"_cancel",
"(",
"self",
".",
"_check_view_change_completed",
")",
"self",
".",
"_schedule",
"(",
"action",
"=",
"self",
".",
"_check_view_change_completed",
",",
"seconds",
"=",
"self",
".",
"_view_change_timeout",
")",
"# Set to 0 even when set to 0 in `on_view_change_complete` since",
"# catchup might be started due to several reasons.",
"self",
".",
"catchup_rounds_without_txns",
"=",
"0",
"self",
".",
"last_sent_pp_store_helper",
".",
"erase_last_sent_pp_seq_no",
"(",
")"
] |
Notifies node about the fact that view changed to let it
prepare for election
|
[
"Notifies",
"node",
"about",
"the",
"fact",
"that",
"view",
"changed",
"to",
"let",
"it",
"prepare",
"for",
"election"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L791-L821
|
234,268
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.on_view_change_complete
|
def on_view_change_complete(self):
"""
View change completes for a replica when it has been decided which was
the last ppSeqNo and state and txn root for previous view
"""
self.future_primaries_handler.set_node_state()
if not self.replicas.all_instances_have_primary:
raise LogicError(
"{} Not all replicas have "
"primaries: {}".format(self, self.replicas.primary_name_by_inst_id)
)
self._cancel(self._check_view_change_completed)
for replica in self.replicas.values():
replica.on_view_change_done()
self.view_changer.last_completed_view_no = self.view_changer.view_no
# Remove already ordered requests from requests list after view change
# If view change happen when one half of nodes ordered on master
# instance and backup but other only on master then we need to clear
# requests list. We do this to stop transactions ordering on backup
# replicas that have already been ordered on master.
# Test for this case in plenum/test/view_change/
# test_no_propagate_request_on_different_last_ordered_before_vc.py
for replica in self.replicas.values():
replica.clear_requests_and_fix_last_ordered()
self.monitor.reset()
|
python
|
def on_view_change_complete(self):
"""
View change completes for a replica when it has been decided which was
the last ppSeqNo and state and txn root for previous view
"""
self.future_primaries_handler.set_node_state()
if not self.replicas.all_instances_have_primary:
raise LogicError(
"{} Not all replicas have "
"primaries: {}".format(self, self.replicas.primary_name_by_inst_id)
)
self._cancel(self._check_view_change_completed)
for replica in self.replicas.values():
replica.on_view_change_done()
self.view_changer.last_completed_view_no = self.view_changer.view_no
# Remove already ordered requests from requests list after view change
# If view change happen when one half of nodes ordered on master
# instance and backup but other only on master then we need to clear
# requests list. We do this to stop transactions ordering on backup
# replicas that have already been ordered on master.
# Test for this case in plenum/test/view_change/
# test_no_propagate_request_on_different_last_ordered_before_vc.py
for replica in self.replicas.values():
replica.clear_requests_and_fix_last_ordered()
self.monitor.reset()
|
[
"def",
"on_view_change_complete",
"(",
"self",
")",
":",
"self",
".",
"future_primaries_handler",
".",
"set_node_state",
"(",
")",
"if",
"not",
"self",
".",
"replicas",
".",
"all_instances_have_primary",
":",
"raise",
"LogicError",
"(",
"\"{} Not all replicas have \"",
"\"primaries: {}\"",
".",
"format",
"(",
"self",
",",
"self",
".",
"replicas",
".",
"primary_name_by_inst_id",
")",
")",
"self",
".",
"_cancel",
"(",
"self",
".",
"_check_view_change_completed",
")",
"for",
"replica",
"in",
"self",
".",
"replicas",
".",
"values",
"(",
")",
":",
"replica",
".",
"on_view_change_done",
"(",
")",
"self",
".",
"view_changer",
".",
"last_completed_view_no",
"=",
"self",
".",
"view_changer",
".",
"view_no",
"# Remove already ordered requests from requests list after view change",
"# If view change happen when one half of nodes ordered on master",
"# instance and backup but other only on master then we need to clear",
"# requests list. We do this to stop transactions ordering on backup",
"# replicas that have already been ordered on master.",
"# Test for this case in plenum/test/view_change/",
"# test_no_propagate_request_on_different_last_ordered_before_vc.py",
"for",
"replica",
"in",
"self",
".",
"replicas",
".",
"values",
"(",
")",
":",
"replica",
".",
"clear_requests_and_fix_last_ordered",
"(",
")",
"self",
".",
"monitor",
".",
"reset",
"(",
")"
] |
View change completes for a replica when it has been decided which was
the last ppSeqNo and state and txn root for previous view
|
[
"View",
"change",
"completes",
"for",
"a",
"replica",
"when",
"it",
"has",
"been",
"decided",
"which",
"was",
"the",
"last",
"ppSeqNo",
"and",
"state",
"and",
"txn",
"root",
"for",
"previous",
"view"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L823-L851
|
234,269
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.onStopping
|
def onStopping(self):
"""
Actions to be performed on stopping the node.
- Close the UDP socket of the nodestack
"""
# Log stats should happen before any kind of reset or clearing
if self.config.STACK_COMPANION == 1:
add_stop_time(self.ledger_dir, self.utc_epoch())
self.logstats()
self.reset()
# Stop the ledgers
for ledger in self.ledgers:
try:
ledger.stop()
except Exception as ex:
logger.exception('{} got exception while stopping ledger: {}'.format(self, ex))
self.nodestack.stop()
self.clientstack.stop()
self.closeAllKVStores()
self._info_tool.stop()
self.mode = None
self.execute_hook(NodeHooks.POST_NODE_STOPPED)
|
python
|
def onStopping(self):
"""
Actions to be performed on stopping the node.
- Close the UDP socket of the nodestack
"""
# Log stats should happen before any kind of reset or clearing
if self.config.STACK_COMPANION == 1:
add_stop_time(self.ledger_dir, self.utc_epoch())
self.logstats()
self.reset()
# Stop the ledgers
for ledger in self.ledgers:
try:
ledger.stop()
except Exception as ex:
logger.exception('{} got exception while stopping ledger: {}'.format(self, ex))
self.nodestack.stop()
self.clientstack.stop()
self.closeAllKVStores()
self._info_tool.stop()
self.mode = None
self.execute_hook(NodeHooks.POST_NODE_STOPPED)
|
[
"def",
"onStopping",
"(",
"self",
")",
":",
"# Log stats should happen before any kind of reset or clearing",
"if",
"self",
".",
"config",
".",
"STACK_COMPANION",
"==",
"1",
":",
"add_stop_time",
"(",
"self",
".",
"ledger_dir",
",",
"self",
".",
"utc_epoch",
"(",
")",
")",
"self",
".",
"logstats",
"(",
")",
"self",
".",
"reset",
"(",
")",
"# Stop the ledgers",
"for",
"ledger",
"in",
"self",
".",
"ledgers",
":",
"try",
":",
"ledger",
".",
"stop",
"(",
")",
"except",
"Exception",
"as",
"ex",
":",
"logger",
".",
"exception",
"(",
"'{} got exception while stopping ledger: {}'",
".",
"format",
"(",
"self",
",",
"ex",
")",
")",
"self",
".",
"nodestack",
".",
"stop",
"(",
")",
"self",
".",
"clientstack",
".",
"stop",
"(",
")",
"self",
".",
"closeAllKVStores",
"(",
")",
"self",
".",
"_info_tool",
".",
"stop",
"(",
")",
"self",
".",
"mode",
"=",
"None",
"self",
".",
"execute_hook",
"(",
"NodeHooks",
".",
"POST_NODE_STOPPED",
")"
] |
Actions to be performed on stopping the node.
- Close the UDP socket of the nodestack
|
[
"Actions",
"to",
"be",
"performed",
"on",
"stopping",
"the",
"node",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1248-L1275
|
234,270
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.prod
|
async def prod(self, limit: int = None) -> int:
""".opened
This function is executed by the node each time it gets its share of
CPU time from the event loop.
:param limit: the number of items to be serviced in this attempt
:return: total number of messages serviced by this node
"""
c = 0
if self.last_prod_started:
self.metrics.add_event(MetricsName.LOOPER_RUN_TIME_SPENT, time.perf_counter() - self.last_prod_started)
self.last_prod_started = time.perf_counter()
self.quota_control.update_state({
'request_queue_size': len(self.monitor.requestTracker.unordered())}
)
if self.status is not Status.stopped:
c += await self.serviceReplicas(limit)
c += await self.serviceNodeMsgs(limit)
c += await self.serviceClientMsgs(limit)
with self.metrics.measure_time(MetricsName.SERVICE_NODE_ACTIONS_TIME):
c += self._serviceActions()
with self.metrics.measure_time(MetricsName.SERVICE_TIMERS_TIME):
self.timer.service()
with self.metrics.measure_time(MetricsName.SERVICE_MONITOR_ACTIONS_TIME):
c += self.monitor._serviceActions()
c += await self.serviceViewChanger(limit)
c += await self.service_observable(limit)
c += await self.service_observer(limit)
with self.metrics.measure_time(MetricsName.FLUSH_OUTBOXES_TIME):
self.nodestack.flushOutBoxes()
if self.isGoing():
with self.metrics.measure_time(MetricsName.SERVICE_NODE_LIFECYCLE_TIME):
self.nodestack.serviceLifecycle()
with self.metrics.measure_time(MetricsName.SERVICE_CLIENT_STACK_TIME):
self.clientstack.serviceClientStack()
return c
|
python
|
async def prod(self, limit: int = None) -> int:
""".opened
This function is executed by the node each time it gets its share of
CPU time from the event loop.
:param limit: the number of items to be serviced in this attempt
:return: total number of messages serviced by this node
"""
c = 0
if self.last_prod_started:
self.metrics.add_event(MetricsName.LOOPER_RUN_TIME_SPENT, time.perf_counter() - self.last_prod_started)
self.last_prod_started = time.perf_counter()
self.quota_control.update_state({
'request_queue_size': len(self.monitor.requestTracker.unordered())}
)
if self.status is not Status.stopped:
c += await self.serviceReplicas(limit)
c += await self.serviceNodeMsgs(limit)
c += await self.serviceClientMsgs(limit)
with self.metrics.measure_time(MetricsName.SERVICE_NODE_ACTIONS_TIME):
c += self._serviceActions()
with self.metrics.measure_time(MetricsName.SERVICE_TIMERS_TIME):
self.timer.service()
with self.metrics.measure_time(MetricsName.SERVICE_MONITOR_ACTIONS_TIME):
c += self.monitor._serviceActions()
c += await self.serviceViewChanger(limit)
c += await self.service_observable(limit)
c += await self.service_observer(limit)
with self.metrics.measure_time(MetricsName.FLUSH_OUTBOXES_TIME):
self.nodestack.flushOutBoxes()
if self.isGoing():
with self.metrics.measure_time(MetricsName.SERVICE_NODE_LIFECYCLE_TIME):
self.nodestack.serviceLifecycle()
with self.metrics.measure_time(MetricsName.SERVICE_CLIENT_STACK_TIME):
self.clientstack.serviceClientStack()
return c
|
[
"async",
"def",
"prod",
"(",
"self",
",",
"limit",
":",
"int",
"=",
"None",
")",
"->",
"int",
":",
"c",
"=",
"0",
"if",
"self",
".",
"last_prod_started",
":",
"self",
".",
"metrics",
".",
"add_event",
"(",
"MetricsName",
".",
"LOOPER_RUN_TIME_SPENT",
",",
"time",
".",
"perf_counter",
"(",
")",
"-",
"self",
".",
"last_prod_started",
")",
"self",
".",
"last_prod_started",
"=",
"time",
".",
"perf_counter",
"(",
")",
"self",
".",
"quota_control",
".",
"update_state",
"(",
"{",
"'request_queue_size'",
":",
"len",
"(",
"self",
".",
"monitor",
".",
"requestTracker",
".",
"unordered",
"(",
")",
")",
"}",
")",
"if",
"self",
".",
"status",
"is",
"not",
"Status",
".",
"stopped",
":",
"c",
"+=",
"await",
"self",
".",
"serviceReplicas",
"(",
"limit",
")",
"c",
"+=",
"await",
"self",
".",
"serviceNodeMsgs",
"(",
"limit",
")",
"c",
"+=",
"await",
"self",
".",
"serviceClientMsgs",
"(",
"limit",
")",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"SERVICE_NODE_ACTIONS_TIME",
")",
":",
"c",
"+=",
"self",
".",
"_serviceActions",
"(",
")",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"SERVICE_TIMERS_TIME",
")",
":",
"self",
".",
"timer",
".",
"service",
"(",
")",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"SERVICE_MONITOR_ACTIONS_TIME",
")",
":",
"c",
"+=",
"self",
".",
"monitor",
".",
"_serviceActions",
"(",
")",
"c",
"+=",
"await",
"self",
".",
"serviceViewChanger",
"(",
"limit",
")",
"c",
"+=",
"await",
"self",
".",
"service_observable",
"(",
"limit",
")",
"c",
"+=",
"await",
"self",
".",
"service_observer",
"(",
"limit",
")",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"FLUSH_OUTBOXES_TIME",
")",
":",
"self",
".",
"nodestack",
".",
"flushOutBoxes",
"(",
")",
"if",
"self",
".",
"isGoing",
"(",
")",
":",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"SERVICE_NODE_LIFECYCLE_TIME",
")",
":",
"self",
".",
"nodestack",
".",
"serviceLifecycle",
"(",
")",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"SERVICE_CLIENT_STACK_TIME",
")",
":",
"self",
".",
"clientstack",
".",
"serviceClientStack",
"(",
")",
"return",
"c"
] |
.opened
This function is executed by the node each time it gets its share of
CPU time from the event loop.
:param limit: the number of items to be serviced in this attempt
:return: total number of messages serviced by this node
|
[
".",
"opened",
"This",
"function",
"is",
"executed",
"by",
"the",
"node",
"each",
"time",
"it",
"gets",
"its",
"share",
"of",
"CPU",
"time",
"from",
"the",
"event",
"loop",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1309-L1349
|
234,271
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.serviceNodeMsgs
|
async def serviceNodeMsgs(self, limit: int) -> int:
"""
Process `limit` number of messages from the nodeInBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
"""
with self.metrics.measure_time(MetricsName.SERVICE_NODE_STACK_TIME):
n = await self.nodestack.service(limit, self.quota_control.node_quota)
self.metrics.add_event(MetricsName.NODE_STACK_MESSAGES_PROCESSED, n)
await self.processNodeInBox()
return n
|
python
|
async def serviceNodeMsgs(self, limit: int) -> int:
"""
Process `limit` number of messages from the nodeInBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
"""
with self.metrics.measure_time(MetricsName.SERVICE_NODE_STACK_TIME):
n = await self.nodestack.service(limit, self.quota_control.node_quota)
self.metrics.add_event(MetricsName.NODE_STACK_MESSAGES_PROCESSED, n)
await self.processNodeInBox()
return n
|
[
"async",
"def",
"serviceNodeMsgs",
"(",
"self",
",",
"limit",
":",
"int",
")",
"->",
"int",
":",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"SERVICE_NODE_STACK_TIME",
")",
":",
"n",
"=",
"await",
"self",
".",
"nodestack",
".",
"service",
"(",
"limit",
",",
"self",
".",
"quota_control",
".",
"node_quota",
")",
"self",
".",
"metrics",
".",
"add_event",
"(",
"MetricsName",
".",
"NODE_STACK_MESSAGES_PROCESSED",
",",
"n",
")",
"await",
"self",
".",
"processNodeInBox",
"(",
")",
"return",
"n"
] |
Process `limit` number of messages from the nodeInBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
|
[
"Process",
"limit",
"number",
"of",
"messages",
"from",
"the",
"nodeInBox",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1368-L1381
|
234,272
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.serviceClientMsgs
|
async def serviceClientMsgs(self, limit: int) -> int:
"""
Process `limit` number of messages from the clientInBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
"""
c = await self.clientstack.service(limit, self.quota_control.client_quota)
self.metrics.add_event(MetricsName.CLIENT_STACK_MESSAGES_PROCESSED, c)
await self.processClientInBox()
return c
|
python
|
async def serviceClientMsgs(self, limit: int) -> int:
"""
Process `limit` number of messages from the clientInBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
"""
c = await self.clientstack.service(limit, self.quota_control.client_quota)
self.metrics.add_event(MetricsName.CLIENT_STACK_MESSAGES_PROCESSED, c)
await self.processClientInBox()
return c
|
[
"async",
"def",
"serviceClientMsgs",
"(",
"self",
",",
"limit",
":",
"int",
")",
"->",
"int",
":",
"c",
"=",
"await",
"self",
".",
"clientstack",
".",
"service",
"(",
"limit",
",",
"self",
".",
"quota_control",
".",
"client_quota",
")",
"self",
".",
"metrics",
".",
"add_event",
"(",
"MetricsName",
".",
"CLIENT_STACK_MESSAGES_PROCESSED",
",",
"c",
")",
"await",
"self",
".",
"processClientInBox",
"(",
")",
"return",
"c"
] |
Process `limit` number of messages from the clientInBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
|
[
"Process",
"limit",
"number",
"of",
"messages",
"from",
"the",
"clientInBox",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1384-L1395
|
234,273
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.serviceViewChanger
|
async def serviceViewChanger(self, limit) -> int:
"""
Service the view_changer's inBox, outBox and action queues.
:return: the number of messages successfully serviced
"""
if not self.isReady():
return 0
o = self.serviceViewChangerOutBox(limit)
i = await self.serviceViewChangerInbox(limit)
return o + i
|
python
|
async def serviceViewChanger(self, limit) -> int:
"""
Service the view_changer's inBox, outBox and action queues.
:return: the number of messages successfully serviced
"""
if not self.isReady():
return 0
o = self.serviceViewChangerOutBox(limit)
i = await self.serviceViewChangerInbox(limit)
return o + i
|
[
"async",
"def",
"serviceViewChanger",
"(",
"self",
",",
"limit",
")",
"->",
"int",
":",
"if",
"not",
"self",
".",
"isReady",
"(",
")",
":",
"return",
"0",
"o",
"=",
"self",
".",
"serviceViewChangerOutBox",
"(",
"limit",
")",
"i",
"=",
"await",
"self",
".",
"serviceViewChangerInbox",
"(",
"limit",
")",
"return",
"o",
"+",
"i"
] |
Service the view_changer's inBox, outBox and action queues.
:return: the number of messages successfully serviced
|
[
"Service",
"the",
"view_changer",
"s",
"inBox",
"outBox",
"and",
"action",
"queues",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1398-L1408
|
234,274
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.service_observable
|
async def service_observable(self, limit) -> int:
"""
Service the observable's inBox and outBox
:return: the number of messages successfully serviced
"""
if not self.isReady():
return 0
o = self._service_observable_out_box(limit)
i = await self._observable.serviceQueues(limit)
return o + i
|
python
|
async def service_observable(self, limit) -> int:
"""
Service the observable's inBox and outBox
:return: the number of messages successfully serviced
"""
if not self.isReady():
return 0
o = self._service_observable_out_box(limit)
i = await self._observable.serviceQueues(limit)
return o + i
|
[
"async",
"def",
"service_observable",
"(",
"self",
",",
"limit",
")",
"->",
"int",
":",
"if",
"not",
"self",
".",
"isReady",
"(",
")",
":",
"return",
"0",
"o",
"=",
"self",
".",
"_service_observable_out_box",
"(",
"limit",
")",
"i",
"=",
"await",
"self",
".",
"_observable",
".",
"serviceQueues",
"(",
"limit",
")",
"return",
"o",
"+",
"i"
] |
Service the observable's inBox and outBox
:return: the number of messages successfully serviced
|
[
"Service",
"the",
"observable",
"s",
"inBox",
"and",
"outBox"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1411-L1421
|
234,275
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node._service_observable_out_box
|
def _service_observable_out_box(self, limit: int = None) -> int:
"""
Service at most `limit` number of messages from the observable's outBox.
:return: the number of messages successfully serviced.
"""
msg_count = 0
while True:
if limit and msg_count >= limit:
break
msg = self._observable.get_output()
if not msg:
break
msg_count += 1
msg, observer_ids = msg
# TODO: it's assumed that all Observers are connected the same way as Validators
self.sendToNodes(msg, observer_ids)
return msg_count
|
python
|
def _service_observable_out_box(self, limit: int = None) -> int:
"""
Service at most `limit` number of messages from the observable's outBox.
:return: the number of messages successfully serviced.
"""
msg_count = 0
while True:
if limit and msg_count >= limit:
break
msg = self._observable.get_output()
if not msg:
break
msg_count += 1
msg, observer_ids = msg
# TODO: it's assumed that all Observers are connected the same way as Validators
self.sendToNodes(msg, observer_ids)
return msg_count
|
[
"def",
"_service_observable_out_box",
"(",
"self",
",",
"limit",
":",
"int",
"=",
"None",
")",
"->",
"int",
":",
"msg_count",
"=",
"0",
"while",
"True",
":",
"if",
"limit",
"and",
"msg_count",
">=",
"limit",
":",
"break",
"msg",
"=",
"self",
".",
"_observable",
".",
"get_output",
"(",
")",
"if",
"not",
"msg",
":",
"break",
"msg_count",
"+=",
"1",
"msg",
",",
"observer_ids",
"=",
"msg",
"# TODO: it's assumed that all Observers are connected the same way as Validators",
"self",
".",
"sendToNodes",
"(",
"msg",
",",
"observer_ids",
")",
"return",
"msg_count"
] |
Service at most `limit` number of messages from the observable's outBox.
:return: the number of messages successfully serviced.
|
[
"Service",
"at",
"most",
"limit",
"number",
"of",
"messages",
"from",
"the",
"observable",
"s",
"outBox",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1423-L1442
|
234,276
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.service_observer
|
async def service_observer(self, limit) -> int:
"""
Service the observer's inBox and outBox
:return: the number of messages successfully serviced
"""
if not self.isReady():
return 0
return await self._observer.serviceQueues(limit)
|
python
|
async def service_observer(self, limit) -> int:
"""
Service the observer's inBox and outBox
:return: the number of messages successfully serviced
"""
if not self.isReady():
return 0
return await self._observer.serviceQueues(limit)
|
[
"async",
"def",
"service_observer",
"(",
"self",
",",
"limit",
")",
"->",
"int",
":",
"if",
"not",
"self",
".",
"isReady",
"(",
")",
":",
"return",
"0",
"return",
"await",
"self",
".",
"_observer",
".",
"serviceQueues",
"(",
"limit",
")"
] |
Service the observer's inBox and outBox
:return: the number of messages successfully serviced
|
[
"Service",
"the",
"observer",
"s",
"inBox",
"and",
"outBox"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1445-L1453
|
234,277
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node._ask_for_ledger_status
|
def _ask_for_ledger_status(self, node_name: str, ledger_id):
"""
Ask other node for LedgerStatus
"""
self.request_msg(LEDGER_STATUS, {f.LEDGER_ID.nm: ledger_id},
[node_name, ])
logger.info("{} asking {} for ledger status of ledger {}".format(self, node_name, ledger_id))
|
python
|
def _ask_for_ledger_status(self, node_name: str, ledger_id):
"""
Ask other node for LedgerStatus
"""
self.request_msg(LEDGER_STATUS, {f.LEDGER_ID.nm: ledger_id},
[node_name, ])
logger.info("{} asking {} for ledger status of ledger {}".format(self, node_name, ledger_id))
|
[
"def",
"_ask_for_ledger_status",
"(",
"self",
",",
"node_name",
":",
"str",
",",
"ledger_id",
")",
":",
"self",
".",
"request_msg",
"(",
"LEDGER_STATUS",
",",
"{",
"f",
".",
"LEDGER_ID",
".",
"nm",
":",
"ledger_id",
"}",
",",
"[",
"node_name",
",",
"]",
")",
"logger",
".",
"info",
"(",
"\"{} asking {} for ledger status of ledger {}\"",
".",
"format",
"(",
"self",
",",
"node_name",
",",
"ledger_id",
")",
")"
] |
Ask other node for LedgerStatus
|
[
"Ask",
"other",
"node",
"for",
"LedgerStatus"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1525-L1531
|
234,278
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.checkInstances
|
def checkInstances(self) -> None:
# TODO: Is this method really needed?
"""
Check if this node has the minimum required number of protocol
instances, i.e. f+1. If not, add a replica. If no election is in
progress, this node will try to nominate one of its replicas as primary.
This method is called whenever a connection with a new node is
established.
"""
logger.debug("{} choosing to start election on the basis of count {} and nodes {}".
format(self, self.connectedNodeCount, self.nodestack.conns))
|
python
|
def checkInstances(self) -> None:
# TODO: Is this method really needed?
"""
Check if this node has the minimum required number of protocol
instances, i.e. f+1. If not, add a replica. If no election is in
progress, this node will try to nominate one of its replicas as primary.
This method is called whenever a connection with a new node is
established.
"""
logger.debug("{} choosing to start election on the basis of count {} and nodes {}".
format(self, self.connectedNodeCount, self.nodestack.conns))
|
[
"def",
"checkInstances",
"(",
"self",
")",
"->",
"None",
":",
"# TODO: Is this method really needed?",
"logger",
".",
"debug",
"(",
"\"{} choosing to start election on the basis of count {} and nodes {}\"",
".",
"format",
"(",
"self",
",",
"self",
".",
"connectedNodeCount",
",",
"self",
".",
"nodestack",
".",
"conns",
")",
")"
] |
Check if this node has the minimum required number of protocol
instances, i.e. f+1. If not, add a replica. If no election is in
progress, this node will try to nominate one of its replicas as primary.
This method is called whenever a connection with a new node is
established.
|
[
"Check",
"if",
"this",
"node",
"has",
"the",
"minimum",
"required",
"number",
"of",
"protocol",
"instances",
"i",
".",
"e",
".",
"f",
"+",
"1",
".",
"If",
"not",
"add",
"a",
"replica",
".",
"If",
"no",
"election",
"is",
"in",
"progress",
"this",
"node",
"will",
"try",
"to",
"nominate",
"one",
"of",
"its",
"replicas",
"as",
"primary",
".",
"This",
"method",
"is",
"called",
"whenever",
"a",
"connection",
"with",
"a",
"new",
"node",
"is",
"established",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1587-L1597
|
234,279
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.adjustReplicas
|
def adjustReplicas(self,
old_required_number_of_instances: int,
new_required_number_of_instances: int):
"""
Add or remove replicas depending on `f`
"""
# TODO: refactor this
replica_num = old_required_number_of_instances
while replica_num < new_required_number_of_instances:
self.replicas.add_replica(replica_num)
self.processStashedMsgsForReplica(replica_num)
replica_num += 1
while replica_num > new_required_number_of_instances:
replica_num -= 1
self.replicas.remove_replica(replica_num)
pop_keys(self.msgsForFutureReplicas, lambda inst_id: inst_id < new_required_number_of_instances)
if len(self.primaries_disconnection_times) < new_required_number_of_instances:
self.primaries_disconnection_times.extend(
[None] * (new_required_number_of_instances - len(self.primaries_disconnection_times)))
elif len(self.primaries_disconnection_times) > new_required_number_of_instances:
self.primaries_disconnection_times = self.primaries_disconnection_times[:new_required_number_of_instances]
|
python
|
def adjustReplicas(self,
old_required_number_of_instances: int,
new_required_number_of_instances: int):
"""
Add or remove replicas depending on `f`
"""
# TODO: refactor this
replica_num = old_required_number_of_instances
while replica_num < new_required_number_of_instances:
self.replicas.add_replica(replica_num)
self.processStashedMsgsForReplica(replica_num)
replica_num += 1
while replica_num > new_required_number_of_instances:
replica_num -= 1
self.replicas.remove_replica(replica_num)
pop_keys(self.msgsForFutureReplicas, lambda inst_id: inst_id < new_required_number_of_instances)
if len(self.primaries_disconnection_times) < new_required_number_of_instances:
self.primaries_disconnection_times.extend(
[None] * (new_required_number_of_instances - len(self.primaries_disconnection_times)))
elif len(self.primaries_disconnection_times) > new_required_number_of_instances:
self.primaries_disconnection_times = self.primaries_disconnection_times[:new_required_number_of_instances]
|
[
"def",
"adjustReplicas",
"(",
"self",
",",
"old_required_number_of_instances",
":",
"int",
",",
"new_required_number_of_instances",
":",
"int",
")",
":",
"# TODO: refactor this",
"replica_num",
"=",
"old_required_number_of_instances",
"while",
"replica_num",
"<",
"new_required_number_of_instances",
":",
"self",
".",
"replicas",
".",
"add_replica",
"(",
"replica_num",
")",
"self",
".",
"processStashedMsgsForReplica",
"(",
"replica_num",
")",
"replica_num",
"+=",
"1",
"while",
"replica_num",
">",
"new_required_number_of_instances",
":",
"replica_num",
"-=",
"1",
"self",
".",
"replicas",
".",
"remove_replica",
"(",
"replica_num",
")",
"pop_keys",
"(",
"self",
".",
"msgsForFutureReplicas",
",",
"lambda",
"inst_id",
":",
"inst_id",
"<",
"new_required_number_of_instances",
")",
"if",
"len",
"(",
"self",
".",
"primaries_disconnection_times",
")",
"<",
"new_required_number_of_instances",
":",
"self",
".",
"primaries_disconnection_times",
".",
"extend",
"(",
"[",
"None",
"]",
"*",
"(",
"new_required_number_of_instances",
"-",
"len",
"(",
"self",
".",
"primaries_disconnection_times",
")",
")",
")",
"elif",
"len",
"(",
"self",
".",
"primaries_disconnection_times",
")",
">",
"new_required_number_of_instances",
":",
"self",
".",
"primaries_disconnection_times",
"=",
"self",
".",
"primaries_disconnection_times",
"[",
":",
"new_required_number_of_instances",
"]"
] |
Add or remove replicas depending on `f`
|
[
"Add",
"or",
"remove",
"replicas",
"depending",
"on",
"f"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1599-L1622
|
234,280
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node._check_view_change_completed
|
def _check_view_change_completed(self):
"""
This thing checks whether new primary was elected.
If it was not - starts view change again
"""
logger.info('{} running the scheduled check for view change completion'.format(self))
if not self.view_changer.view_change_in_progress:
logger.info('{} already completion view change'.format(self))
return False
self.view_changer.on_view_change_not_completed_in_time()
return True
|
python
|
def _check_view_change_completed(self):
"""
This thing checks whether new primary was elected.
If it was not - starts view change again
"""
logger.info('{} running the scheduled check for view change completion'.format(self))
if not self.view_changer.view_change_in_progress:
logger.info('{} already completion view change'.format(self))
return False
self.view_changer.on_view_change_not_completed_in_time()
return True
|
[
"def",
"_check_view_change_completed",
"(",
"self",
")",
":",
"logger",
".",
"info",
"(",
"'{} running the scheduled check for view change completion'",
".",
"format",
"(",
"self",
")",
")",
"if",
"not",
"self",
".",
"view_changer",
".",
"view_change_in_progress",
":",
"logger",
".",
"info",
"(",
"'{} already completion view change'",
".",
"format",
"(",
"self",
")",
")",
"return",
"False",
"self",
".",
"view_changer",
".",
"on_view_change_not_completed_in_time",
"(",
")",
"return",
"True"
] |
This thing checks whether new primary was elected.
If it was not - starts view change again
|
[
"This",
"thing",
"checks",
"whether",
"new",
"primary",
"was",
"elected",
".",
"If",
"it",
"was",
"not",
"-",
"starts",
"view",
"change",
"again"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1663-L1674
|
234,281
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.service_replicas_outbox
|
def service_replicas_outbox(self, limit: int = None) -> int:
"""
Process `limit` number of replica messages
"""
# TODO: rewrite this using Router
num_processed = 0
for message in self.replicas.get_output(limit):
num_processed += 1
if isinstance(message, (PrePrepare, Prepare, Commit, Checkpoint)):
self.send(message)
elif isinstance(message, Ordered):
self.try_processing_ordered(message)
elif isinstance(message, tuple) and isinstance(message[1], Reject):
with self.metrics.measure_time(MetricsName.NODE_SEND_REJECT_TIME):
digest, reject = message
result_reject = Reject(
reject.identifier,
reject.reqId,
self.reasonForClientFromException(
reject.reason))
# TODO: What the case when reqKey will be not in requestSender dict
if digest in self.requestSender:
self.transmitToClient(result_reject, self.requestSender[digest])
self.doneProcessingReq(digest)
elif isinstance(message, Exception):
self.processEscalatedException(message)
else:
# TODO: should not this raise exception?
logger.error("Received msg {} and don't "
"know how to handle it".format(message))
return num_processed
|
python
|
def service_replicas_outbox(self, limit: int = None) -> int:
"""
Process `limit` number of replica messages
"""
# TODO: rewrite this using Router
num_processed = 0
for message in self.replicas.get_output(limit):
num_processed += 1
if isinstance(message, (PrePrepare, Prepare, Commit, Checkpoint)):
self.send(message)
elif isinstance(message, Ordered):
self.try_processing_ordered(message)
elif isinstance(message, tuple) and isinstance(message[1], Reject):
with self.metrics.measure_time(MetricsName.NODE_SEND_REJECT_TIME):
digest, reject = message
result_reject = Reject(
reject.identifier,
reject.reqId,
self.reasonForClientFromException(
reject.reason))
# TODO: What the case when reqKey will be not in requestSender dict
if digest in self.requestSender:
self.transmitToClient(result_reject, self.requestSender[digest])
self.doneProcessingReq(digest)
elif isinstance(message, Exception):
self.processEscalatedException(message)
else:
# TODO: should not this raise exception?
logger.error("Received msg {} and don't "
"know how to handle it".format(message))
return num_processed
|
[
"def",
"service_replicas_outbox",
"(",
"self",
",",
"limit",
":",
"int",
"=",
"None",
")",
"->",
"int",
":",
"# TODO: rewrite this using Router",
"num_processed",
"=",
"0",
"for",
"message",
"in",
"self",
".",
"replicas",
".",
"get_output",
"(",
"limit",
")",
":",
"num_processed",
"+=",
"1",
"if",
"isinstance",
"(",
"message",
",",
"(",
"PrePrepare",
",",
"Prepare",
",",
"Commit",
",",
"Checkpoint",
")",
")",
":",
"self",
".",
"send",
"(",
"message",
")",
"elif",
"isinstance",
"(",
"message",
",",
"Ordered",
")",
":",
"self",
".",
"try_processing_ordered",
"(",
"message",
")",
"elif",
"isinstance",
"(",
"message",
",",
"tuple",
")",
"and",
"isinstance",
"(",
"message",
"[",
"1",
"]",
",",
"Reject",
")",
":",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"NODE_SEND_REJECT_TIME",
")",
":",
"digest",
",",
"reject",
"=",
"message",
"result_reject",
"=",
"Reject",
"(",
"reject",
".",
"identifier",
",",
"reject",
".",
"reqId",
",",
"self",
".",
"reasonForClientFromException",
"(",
"reject",
".",
"reason",
")",
")",
"# TODO: What the case when reqKey will be not in requestSender dict",
"if",
"digest",
"in",
"self",
".",
"requestSender",
":",
"self",
".",
"transmitToClient",
"(",
"result_reject",
",",
"self",
".",
"requestSender",
"[",
"digest",
"]",
")",
"self",
".",
"doneProcessingReq",
"(",
"digest",
")",
"elif",
"isinstance",
"(",
"message",
",",
"Exception",
")",
":",
"self",
".",
"processEscalatedException",
"(",
"message",
")",
"else",
":",
"# TODO: should not this raise exception?",
"logger",
".",
"error",
"(",
"\"Received msg {} and don't \"",
"\"know how to handle it\"",
".",
"format",
"(",
"message",
")",
")",
"return",
"num_processed"
] |
Process `limit` number of replica messages
|
[
"Process",
"limit",
"number",
"of",
"replica",
"messages"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1677-L1708
|
234,282
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.master_primary_name
|
def master_primary_name(self) -> Optional[str]:
"""
Return the name of the primary node of the master instance
"""
master_primary_name = self.master_replica.primaryName
if master_primary_name:
return self.master_replica.getNodeName(master_primary_name)
return None
|
python
|
def master_primary_name(self) -> Optional[str]:
"""
Return the name of the primary node of the master instance
"""
master_primary_name = self.master_replica.primaryName
if master_primary_name:
return self.master_replica.getNodeName(master_primary_name)
return None
|
[
"def",
"master_primary_name",
"(",
"self",
")",
"->",
"Optional",
"[",
"str",
"]",
":",
"master_primary_name",
"=",
"self",
".",
"master_replica",
".",
"primaryName",
"if",
"master_primary_name",
":",
"return",
"self",
".",
"master_replica",
".",
"getNodeName",
"(",
"master_primary_name",
")",
"return",
"None"
] |
Return the name of the primary node of the master instance
|
[
"Return",
"the",
"name",
"of",
"the",
"primary",
"node",
"of",
"the",
"master",
"instance"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1758-L1766
|
234,283
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.msgHasAcceptableInstId
|
def msgHasAcceptableInstId(self, msg, frm) -> bool:
"""
Return true if the instance id of message corresponds to a correct
replica.
:param msg: the node message to validate
:return:
"""
# TODO: refactor this! this should not do anything except checking!
instId = getattr(msg, f.INST_ID.nm, None)
if not (isinstance(instId, int) and instId >= 0):
return False
if instId >= self.requiredNumberOfInstances:
if instId not in self.msgsForFutureReplicas:
self.msgsForFutureReplicas[instId] = deque()
self.msgsForFutureReplicas[instId].append((msg, frm))
logger.debug("{} queueing message {} for future protocol instance {}".format(self, msg, instId))
return False
return True
|
python
|
def msgHasAcceptableInstId(self, msg, frm) -> bool:
"""
Return true if the instance id of message corresponds to a correct
replica.
:param msg: the node message to validate
:return:
"""
# TODO: refactor this! this should not do anything except checking!
instId = getattr(msg, f.INST_ID.nm, None)
if not (isinstance(instId, int) and instId >= 0):
return False
if instId >= self.requiredNumberOfInstances:
if instId not in self.msgsForFutureReplicas:
self.msgsForFutureReplicas[instId] = deque()
self.msgsForFutureReplicas[instId].append((msg, frm))
logger.debug("{} queueing message {} for future protocol instance {}".format(self, msg, instId))
return False
return True
|
[
"def",
"msgHasAcceptableInstId",
"(",
"self",
",",
"msg",
",",
"frm",
")",
"->",
"bool",
":",
"# TODO: refactor this! this should not do anything except checking!",
"instId",
"=",
"getattr",
"(",
"msg",
",",
"f",
".",
"INST_ID",
".",
"nm",
",",
"None",
")",
"if",
"not",
"(",
"isinstance",
"(",
"instId",
",",
"int",
")",
"and",
"instId",
">=",
"0",
")",
":",
"return",
"False",
"if",
"instId",
">=",
"self",
".",
"requiredNumberOfInstances",
":",
"if",
"instId",
"not",
"in",
"self",
".",
"msgsForFutureReplicas",
":",
"self",
".",
"msgsForFutureReplicas",
"[",
"instId",
"]",
"=",
"deque",
"(",
")",
"self",
".",
"msgsForFutureReplicas",
"[",
"instId",
"]",
".",
"append",
"(",
"(",
"msg",
",",
"frm",
")",
")",
"logger",
".",
"debug",
"(",
"\"{} queueing message {} for future protocol instance {}\"",
".",
"format",
"(",
"self",
",",
"msg",
",",
"instId",
")",
")",
"return",
"False",
"return",
"True"
] |
Return true if the instance id of message corresponds to a correct
replica.
:param msg: the node message to validate
:return:
|
[
"Return",
"true",
"if",
"the",
"instance",
"id",
"of",
"message",
"corresponds",
"to",
"a",
"correct",
"replica",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1778-L1796
|
234,284
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.sendToReplica
|
def sendToReplica(self, msg, frm):
"""
Send the message to the intended replica.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
"""
# TODO: discard or stash messages here instead of doing
# this in msgHas* methods!!!
if self.msgHasAcceptableInstId(msg, frm):
self.replicas.pass_message((msg, frm), msg.instId)
|
python
|
def sendToReplica(self, msg, frm):
"""
Send the message to the intended replica.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
"""
# TODO: discard or stash messages here instead of doing
# this in msgHas* methods!!!
if self.msgHasAcceptableInstId(msg, frm):
self.replicas.pass_message((msg, frm), msg.instId)
|
[
"def",
"sendToReplica",
"(",
"self",
",",
"msg",
",",
"frm",
")",
":",
"# TODO: discard or stash messages here instead of doing",
"# this in msgHas* methods!!!",
"if",
"self",
".",
"msgHasAcceptableInstId",
"(",
"msg",
",",
"frm",
")",
":",
"self",
".",
"replicas",
".",
"pass_message",
"(",
"(",
"msg",
",",
"frm",
")",
",",
"msg",
".",
"instId",
")"
] |
Send the message to the intended replica.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
|
[
"Send",
"the",
"message",
"to",
"the",
"intended",
"replica",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1831-L1841
|
234,285
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.sendToViewChanger
|
def sendToViewChanger(self, msg, frm):
"""
Send the message to the intended view changer.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
"""
if (isinstance(msg, InstanceChange) or
self.msgHasAcceptableViewNo(msg, frm)):
logger.debug("{} sending message to view changer: {}".
format(self, (msg, frm)))
self.msgsToViewChanger.append((msg, frm))
|
python
|
def sendToViewChanger(self, msg, frm):
"""
Send the message to the intended view changer.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
"""
if (isinstance(msg, InstanceChange) or
self.msgHasAcceptableViewNo(msg, frm)):
logger.debug("{} sending message to view changer: {}".
format(self, (msg, frm)))
self.msgsToViewChanger.append((msg, frm))
|
[
"def",
"sendToViewChanger",
"(",
"self",
",",
"msg",
",",
"frm",
")",
":",
"if",
"(",
"isinstance",
"(",
"msg",
",",
"InstanceChange",
")",
"or",
"self",
".",
"msgHasAcceptableViewNo",
"(",
"msg",
",",
"frm",
")",
")",
":",
"logger",
".",
"debug",
"(",
"\"{} sending message to view changer: {}\"",
".",
"format",
"(",
"self",
",",
"(",
"msg",
",",
"frm",
")",
")",
")",
"self",
".",
"msgsToViewChanger",
".",
"append",
"(",
"(",
"msg",
",",
"frm",
")",
")"
] |
Send the message to the intended view changer.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
|
[
"Send",
"the",
"message",
"to",
"the",
"intended",
"view",
"changer",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1843-L1854
|
234,286
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.send_to_observer
|
def send_to_observer(self, msg, frm):
"""
Send the message to the observer.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
"""
logger.debug("{} sending message to observer: {}".
format(self, (msg, frm)))
self._observer.append_input(msg, frm)
|
python
|
def send_to_observer(self, msg, frm):
"""
Send the message to the observer.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
"""
logger.debug("{} sending message to observer: {}".
format(self, (msg, frm)))
self._observer.append_input(msg, frm)
|
[
"def",
"send_to_observer",
"(",
"self",
",",
"msg",
",",
"frm",
")",
":",
"logger",
".",
"debug",
"(",
"\"{} sending message to observer: {}\"",
".",
"format",
"(",
"self",
",",
"(",
"msg",
",",
"frm",
")",
")",
")",
"self",
".",
"_observer",
".",
"append_input",
"(",
"msg",
",",
"frm",
")"
] |
Send the message to the observer.
:param msg: the message to send
:param frm: the name of the node which sent this `msg`
|
[
"Send",
"the",
"message",
"to",
"the",
"observer",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1856-L1865
|
234,287
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.handleOneNodeMsg
|
def handleOneNodeMsg(self, wrappedMsg):
"""
Validate and process one message from a node.
:param wrappedMsg: Tuple of message and the name of the node that sent
the message
"""
try:
vmsg = self.validateNodeMsg(wrappedMsg)
if vmsg:
logger.trace("{} msg validated {}".format(self, wrappedMsg),
extra={"tags": ["node-msg-validation"]})
self.unpackNodeMsg(*vmsg)
else:
logger.debug("{} invalidated msg {}".format(self, wrappedMsg),
extra={"tags": ["node-msg-validation"]})
except SuspiciousNode as ex:
self.reportSuspiciousNodeEx(ex)
except Exception as ex:
msg, frm = wrappedMsg
self.discard(msg, ex, logger.info)
|
python
|
def handleOneNodeMsg(self, wrappedMsg):
"""
Validate and process one message from a node.
:param wrappedMsg: Tuple of message and the name of the node that sent
the message
"""
try:
vmsg = self.validateNodeMsg(wrappedMsg)
if vmsg:
logger.trace("{} msg validated {}".format(self, wrappedMsg),
extra={"tags": ["node-msg-validation"]})
self.unpackNodeMsg(*vmsg)
else:
logger.debug("{} invalidated msg {}".format(self, wrappedMsg),
extra={"tags": ["node-msg-validation"]})
except SuspiciousNode as ex:
self.reportSuspiciousNodeEx(ex)
except Exception as ex:
msg, frm = wrappedMsg
self.discard(msg, ex, logger.info)
|
[
"def",
"handleOneNodeMsg",
"(",
"self",
",",
"wrappedMsg",
")",
":",
"try",
":",
"vmsg",
"=",
"self",
".",
"validateNodeMsg",
"(",
"wrappedMsg",
")",
"if",
"vmsg",
":",
"logger",
".",
"trace",
"(",
"\"{} msg validated {}\"",
".",
"format",
"(",
"self",
",",
"wrappedMsg",
")",
",",
"extra",
"=",
"{",
"\"tags\"",
":",
"[",
"\"node-msg-validation\"",
"]",
"}",
")",
"self",
".",
"unpackNodeMsg",
"(",
"*",
"vmsg",
")",
"else",
":",
"logger",
".",
"debug",
"(",
"\"{} invalidated msg {}\"",
".",
"format",
"(",
"self",
",",
"wrappedMsg",
")",
",",
"extra",
"=",
"{",
"\"tags\"",
":",
"[",
"\"node-msg-validation\"",
"]",
"}",
")",
"except",
"SuspiciousNode",
"as",
"ex",
":",
"self",
".",
"reportSuspiciousNodeEx",
"(",
"ex",
")",
"except",
"Exception",
"as",
"ex",
":",
"msg",
",",
"frm",
"=",
"wrappedMsg",
"self",
".",
"discard",
"(",
"msg",
",",
"ex",
",",
"logger",
".",
"info",
")"
] |
Validate and process one message from a node.
:param wrappedMsg: Tuple of message and the name of the node that sent
the message
|
[
"Validate",
"and",
"process",
"one",
"message",
"from",
"a",
"node",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1867-L1887
|
234,288
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.validateNodeMsg
|
def validateNodeMsg(self, wrappedMsg):
"""
Validate another node's message sent to this node.
:param wrappedMsg: Tuple of message and the name of the node that sent
the message
:return: Tuple of message from node and name of the node
"""
msg, frm = wrappedMsg
if self.isNodeBlacklisted(frm):
self.discard(str(msg)[:256], "received from blacklisted node {}".format(frm), logger.display)
return None
with self.metrics.measure_time(MetricsName.INT_VALIDATE_NODE_MSG_TIME):
try:
message = node_message_factory.get_instance(**msg)
except (MissingNodeOp, InvalidNodeOp) as ex:
raise ex
except Exception as ex:
raise InvalidNodeMsg(str(ex))
try:
self.verifySignature(message)
except BaseExc as ex:
raise SuspiciousNode(frm, ex, message) from ex
logger.debug("{} received node message from {}: {}".format(self, frm, message), extra={"cli": False})
return message, frm
|
python
|
def validateNodeMsg(self, wrappedMsg):
"""
Validate another node's message sent to this node.
:param wrappedMsg: Tuple of message and the name of the node that sent
the message
:return: Tuple of message from node and name of the node
"""
msg, frm = wrappedMsg
if self.isNodeBlacklisted(frm):
self.discard(str(msg)[:256], "received from blacklisted node {}".format(frm), logger.display)
return None
with self.metrics.measure_time(MetricsName.INT_VALIDATE_NODE_MSG_TIME):
try:
message = node_message_factory.get_instance(**msg)
except (MissingNodeOp, InvalidNodeOp) as ex:
raise ex
except Exception as ex:
raise InvalidNodeMsg(str(ex))
try:
self.verifySignature(message)
except BaseExc as ex:
raise SuspiciousNode(frm, ex, message) from ex
logger.debug("{} received node message from {}: {}".format(self, frm, message), extra={"cli": False})
return message, frm
|
[
"def",
"validateNodeMsg",
"(",
"self",
",",
"wrappedMsg",
")",
":",
"msg",
",",
"frm",
"=",
"wrappedMsg",
"if",
"self",
".",
"isNodeBlacklisted",
"(",
"frm",
")",
":",
"self",
".",
"discard",
"(",
"str",
"(",
"msg",
")",
"[",
":",
"256",
"]",
",",
"\"received from blacklisted node {}\"",
".",
"format",
"(",
"frm",
")",
",",
"logger",
".",
"display",
")",
"return",
"None",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"INT_VALIDATE_NODE_MSG_TIME",
")",
":",
"try",
":",
"message",
"=",
"node_message_factory",
".",
"get_instance",
"(",
"*",
"*",
"msg",
")",
"except",
"(",
"MissingNodeOp",
",",
"InvalidNodeOp",
")",
"as",
"ex",
":",
"raise",
"ex",
"except",
"Exception",
"as",
"ex",
":",
"raise",
"InvalidNodeMsg",
"(",
"str",
"(",
"ex",
")",
")",
"try",
":",
"self",
".",
"verifySignature",
"(",
"message",
")",
"except",
"BaseExc",
"as",
"ex",
":",
"raise",
"SuspiciousNode",
"(",
"frm",
",",
"ex",
",",
"message",
")",
"from",
"ex",
"logger",
".",
"debug",
"(",
"\"{} received node message from {}: {}\"",
".",
"format",
"(",
"self",
",",
"frm",
",",
"message",
")",
",",
"extra",
"=",
"{",
"\"cli\"",
":",
"False",
"}",
")",
"return",
"message",
",",
"frm"
] |
Validate another node's message sent to this node.
:param wrappedMsg: Tuple of message and the name of the node that sent
the message
:return: Tuple of message from node and name of the node
|
[
"Validate",
"another",
"node",
"s",
"message",
"sent",
"to",
"this",
"node",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1890-L1916
|
234,289
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.unpackNodeMsg
|
def unpackNodeMsg(self, msg, frm) -> None:
"""
If the message is a batch message validate each message in the batch,
otherwise add the message to the node's inbox.
:param msg: a node message
:param frm: the name of the node that sent this `msg`
"""
# TODO: why do we unpack batches here? Batching is a feature of
# a transport, it should be encapsulated.
if isinstance(msg, Batch):
logger.trace("{} processing a batch {}".format(self, msg))
with self.metrics.measure_time(MetricsName.UNPACK_BATCH_TIME):
for m in msg.messages:
try:
m = self.nodestack.deserializeMsg(m)
except Exception as ex:
logger.warning("Got error {} while processing {} message".format(ex, m))
continue
self.handleOneNodeMsg((m, frm))
else:
self.postToNodeInBox(msg, frm)
|
python
|
def unpackNodeMsg(self, msg, frm) -> None:
"""
If the message is a batch message validate each message in the batch,
otherwise add the message to the node's inbox.
:param msg: a node message
:param frm: the name of the node that sent this `msg`
"""
# TODO: why do we unpack batches here? Batching is a feature of
# a transport, it should be encapsulated.
if isinstance(msg, Batch):
logger.trace("{} processing a batch {}".format(self, msg))
with self.metrics.measure_time(MetricsName.UNPACK_BATCH_TIME):
for m in msg.messages:
try:
m = self.nodestack.deserializeMsg(m)
except Exception as ex:
logger.warning("Got error {} while processing {} message".format(ex, m))
continue
self.handleOneNodeMsg((m, frm))
else:
self.postToNodeInBox(msg, frm)
|
[
"def",
"unpackNodeMsg",
"(",
"self",
",",
"msg",
",",
"frm",
")",
"->",
"None",
":",
"# TODO: why do we unpack batches here? Batching is a feature of",
"# a transport, it should be encapsulated.",
"if",
"isinstance",
"(",
"msg",
",",
"Batch",
")",
":",
"logger",
".",
"trace",
"(",
"\"{} processing a batch {}\"",
".",
"format",
"(",
"self",
",",
"msg",
")",
")",
"with",
"self",
".",
"metrics",
".",
"measure_time",
"(",
"MetricsName",
".",
"UNPACK_BATCH_TIME",
")",
":",
"for",
"m",
"in",
"msg",
".",
"messages",
":",
"try",
":",
"m",
"=",
"self",
".",
"nodestack",
".",
"deserializeMsg",
"(",
"m",
")",
"except",
"Exception",
"as",
"ex",
":",
"logger",
".",
"warning",
"(",
"\"Got error {} while processing {} message\"",
".",
"format",
"(",
"ex",
",",
"m",
")",
")",
"continue",
"self",
".",
"handleOneNodeMsg",
"(",
"(",
"m",
",",
"frm",
")",
")",
"else",
":",
"self",
".",
"postToNodeInBox",
"(",
"msg",
",",
"frm",
")"
] |
If the message is a batch message validate each message in the batch,
otherwise add the message to the node's inbox.
:param msg: a node message
:param frm: the name of the node that sent this `msg`
|
[
"If",
"the",
"message",
"is",
"a",
"batch",
"message",
"validate",
"each",
"message",
"in",
"the",
"batch",
"otherwise",
"add",
"the",
"message",
"to",
"the",
"node",
"s",
"inbox",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1918-L1940
|
234,290
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.postToNodeInBox
|
def postToNodeInBox(self, msg, frm):
"""
Append the message to the node inbox
:param msg: a node message
:param frm: the name of the node that sent this `msg`
"""
logger.trace("{} appending to nodeInbox {}".format(self, msg))
self.nodeInBox.append((msg, frm))
|
python
|
def postToNodeInBox(self, msg, frm):
"""
Append the message to the node inbox
:param msg: a node message
:param frm: the name of the node that sent this `msg`
"""
logger.trace("{} appending to nodeInbox {}".format(self, msg))
self.nodeInBox.append((msg, frm))
|
[
"def",
"postToNodeInBox",
"(",
"self",
",",
"msg",
",",
"frm",
")",
":",
"logger",
".",
"trace",
"(",
"\"{} appending to nodeInbox {}\"",
".",
"format",
"(",
"self",
",",
"msg",
")",
")",
"self",
".",
"nodeInBox",
".",
"append",
"(",
"(",
"msg",
",",
"frm",
")",
")"
] |
Append the message to the node inbox
:param msg: a node message
:param frm: the name of the node that sent this `msg`
|
[
"Append",
"the",
"message",
"to",
"the",
"node",
"inbox"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1942-L1950
|
234,291
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.processNodeInBox
|
async def processNodeInBox(self):
"""
Process the messages in the node inbox asynchronously.
"""
while self.nodeInBox:
m = self.nodeInBox.popleft()
await self.process_one_node_message(m)
|
python
|
async def processNodeInBox(self):
"""
Process the messages in the node inbox asynchronously.
"""
while self.nodeInBox:
m = self.nodeInBox.popleft()
await self.process_one_node_message(m)
|
[
"async",
"def",
"processNodeInBox",
"(",
"self",
")",
":",
"while",
"self",
".",
"nodeInBox",
":",
"m",
"=",
"self",
".",
"nodeInBox",
".",
"popleft",
"(",
")",
"await",
"self",
".",
"process_one_node_message",
"(",
"m",
")"
] |
Process the messages in the node inbox asynchronously.
|
[
"Process",
"the",
"messages",
"in",
"the",
"node",
"inbox",
"asynchronously",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1953-L1959
|
234,292
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.handleOneClientMsg
|
def handleOneClientMsg(self, wrappedMsg):
"""
Validate and process a client message
:param wrappedMsg: a message from a client
"""
try:
vmsg = self.validateClientMsg(wrappedMsg)
if vmsg:
self.unpackClientMsg(*vmsg)
except BlowUp:
raise
except Exception as ex:
msg, frm = wrappedMsg
friendly = friendlyEx(ex)
if isinstance(ex, SuspiciousClient):
self.reportSuspiciousClient(frm, friendly)
self.handleInvalidClientMsg(ex, wrappedMsg)
|
python
|
def handleOneClientMsg(self, wrappedMsg):
"""
Validate and process a client message
:param wrappedMsg: a message from a client
"""
try:
vmsg = self.validateClientMsg(wrappedMsg)
if vmsg:
self.unpackClientMsg(*vmsg)
except BlowUp:
raise
except Exception as ex:
msg, frm = wrappedMsg
friendly = friendlyEx(ex)
if isinstance(ex, SuspiciousClient):
self.reportSuspiciousClient(frm, friendly)
self.handleInvalidClientMsg(ex, wrappedMsg)
|
[
"def",
"handleOneClientMsg",
"(",
"self",
",",
"wrappedMsg",
")",
":",
"try",
":",
"vmsg",
"=",
"self",
".",
"validateClientMsg",
"(",
"wrappedMsg",
")",
"if",
"vmsg",
":",
"self",
".",
"unpackClientMsg",
"(",
"*",
"vmsg",
")",
"except",
"BlowUp",
":",
"raise",
"except",
"Exception",
"as",
"ex",
":",
"msg",
",",
"frm",
"=",
"wrappedMsg",
"friendly",
"=",
"friendlyEx",
"(",
"ex",
")",
"if",
"isinstance",
"(",
"ex",
",",
"SuspiciousClient",
")",
":",
"self",
".",
"reportSuspiciousClient",
"(",
"frm",
",",
"friendly",
")",
"self",
".",
"handleInvalidClientMsg",
"(",
"ex",
",",
"wrappedMsg",
")"
] |
Validate and process a client message
:param wrappedMsg: a message from a client
|
[
"Validate",
"and",
"process",
"a",
"client",
"message"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1968-L1986
|
234,293
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.processClientInBox
|
async def processClientInBox(self):
"""
Process the messages in the node's clientInBox asynchronously.
All messages in the inBox have already been validated, including
signature check.
"""
while self.clientInBox:
m = self.clientInBox.popleft()
req, frm = m
logger.debug("{} processing {} request {}".
format(self.clientstack.name, frm, req),
extra={"cli": True,
"tags": ["node-msg-processing"]})
try:
await self.clientMsgRouter.handle(m)
except InvalidClientMessageException as ex:
self.handleInvalidClientMsg(ex, m)
|
python
|
async def processClientInBox(self):
"""
Process the messages in the node's clientInBox asynchronously.
All messages in the inBox have already been validated, including
signature check.
"""
while self.clientInBox:
m = self.clientInBox.popleft()
req, frm = m
logger.debug("{} processing {} request {}".
format(self.clientstack.name, frm, req),
extra={"cli": True,
"tags": ["node-msg-processing"]})
try:
await self.clientMsgRouter.handle(m)
except InvalidClientMessageException as ex:
self.handleInvalidClientMsg(ex, m)
|
[
"async",
"def",
"processClientInBox",
"(",
"self",
")",
":",
"while",
"self",
".",
"clientInBox",
":",
"m",
"=",
"self",
".",
"clientInBox",
".",
"popleft",
"(",
")",
"req",
",",
"frm",
"=",
"m",
"logger",
".",
"debug",
"(",
"\"{} processing {} request {}\"",
".",
"format",
"(",
"self",
".",
"clientstack",
".",
"name",
",",
"frm",
",",
"req",
")",
",",
"extra",
"=",
"{",
"\"cli\"",
":",
"True",
",",
"\"tags\"",
":",
"[",
"\"node-msg-processing\"",
"]",
"}",
")",
"try",
":",
"await",
"self",
".",
"clientMsgRouter",
".",
"handle",
"(",
"m",
")",
"except",
"InvalidClientMessageException",
"as",
"ex",
":",
"self",
".",
"handleInvalidClientMsg",
"(",
"ex",
",",
"m",
")"
] |
Process the messages in the node's clientInBox asynchronously.
All messages in the inBox have already been validated, including
signature check.
|
[
"Process",
"the",
"messages",
"in",
"the",
"node",
"s",
"clientInBox",
"asynchronously",
".",
"All",
"messages",
"in",
"the",
"inBox",
"have",
"already",
"been",
"validated",
"including",
"signature",
"check",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2120-L2137
|
234,294
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.is_catchup_needed_during_view_change
|
def is_catchup_needed_during_view_change(self) -> bool:
"""
Check if received a quorum of view change done messages and if yes
check if caught up till the
Check if all requests ordered till last prepared certificate
Check if last catchup resulted in no txns
"""
if self.caught_up_for_current_view():
logger.info('{} is caught up for the current view {}'.format(self, self.viewNo))
return False
logger.info('{} is not caught up for the current view {}'.format(self, self.viewNo))
if self.num_txns_caught_up_in_last_catchup() == 0:
if self.has_ordered_till_last_prepared_certificate():
logger.info('{} ordered till last prepared certificate'.format(self))
return False
if self.is_catch_up_limit(self.config.MIN_TIMEOUT_CATCHUPS_DONE_DURING_VIEW_CHANGE):
# No more 3PC messages will be processed since maximum catchup
# rounds have been done
self.master_replica.last_prepared_before_view_change = None
return False
return True
|
python
|
def is_catchup_needed_during_view_change(self) -> bool:
"""
Check if received a quorum of view change done messages and if yes
check if caught up till the
Check if all requests ordered till last prepared certificate
Check if last catchup resulted in no txns
"""
if self.caught_up_for_current_view():
logger.info('{} is caught up for the current view {}'.format(self, self.viewNo))
return False
logger.info('{} is not caught up for the current view {}'.format(self, self.viewNo))
if self.num_txns_caught_up_in_last_catchup() == 0:
if self.has_ordered_till_last_prepared_certificate():
logger.info('{} ordered till last prepared certificate'.format(self))
return False
if self.is_catch_up_limit(self.config.MIN_TIMEOUT_CATCHUPS_DONE_DURING_VIEW_CHANGE):
# No more 3PC messages will be processed since maximum catchup
# rounds have been done
self.master_replica.last_prepared_before_view_change = None
return False
return True
|
[
"def",
"is_catchup_needed_during_view_change",
"(",
"self",
")",
"->",
"bool",
":",
"if",
"self",
".",
"caught_up_for_current_view",
"(",
")",
":",
"logger",
".",
"info",
"(",
"'{} is caught up for the current view {}'",
".",
"format",
"(",
"self",
",",
"self",
".",
"viewNo",
")",
")",
"return",
"False",
"logger",
".",
"info",
"(",
"'{} is not caught up for the current view {}'",
".",
"format",
"(",
"self",
",",
"self",
".",
"viewNo",
")",
")",
"if",
"self",
".",
"num_txns_caught_up_in_last_catchup",
"(",
")",
"==",
"0",
":",
"if",
"self",
".",
"has_ordered_till_last_prepared_certificate",
"(",
")",
":",
"logger",
".",
"info",
"(",
"'{} ordered till last prepared certificate'",
".",
"format",
"(",
"self",
")",
")",
"return",
"False",
"if",
"self",
".",
"is_catch_up_limit",
"(",
"self",
".",
"config",
".",
"MIN_TIMEOUT_CATCHUPS_DONE_DURING_VIEW_CHANGE",
")",
":",
"# No more 3PC messages will be processed since maximum catchup",
"# rounds have been done",
"self",
".",
"master_replica",
".",
"last_prepared_before_view_change",
"=",
"None",
"return",
"False",
"return",
"True"
] |
Check if received a quorum of view change done messages and if yes
check if caught up till the
Check if all requests ordered till last prepared certificate
Check if last catchup resulted in no txns
|
[
"Check",
"if",
"received",
"a",
"quorum",
"of",
"view",
"change",
"done",
"messages",
"and",
"if",
"yes",
"check",
"if",
"caught",
"up",
"till",
"the",
"Check",
"if",
"all",
"requests",
"ordered",
"till",
"last",
"prepared",
"certificate",
"Check",
"if",
"last",
"catchup",
"resulted",
"in",
"no",
"txns"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2275-L2298
|
234,295
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.doDynamicValidation
|
def doDynamicValidation(self, request: Request):
"""
State based validation
"""
self.execute_hook(NodeHooks.PRE_DYNAMIC_VALIDATION, request=request)
# Digest validation
ledger_id, seq_no = self.seqNoDB.get_by_payload_digest(request.payload_digest)
if ledger_id is not None and seq_no is not None:
raise SuspiciousPrePrepare('Trying to order already ordered request')
ledger = self.getLedger(self.ledger_id_for_request(request))
for txn in ledger.uncommittedTxns:
if get_payload_digest(txn) == request.payload_digest:
raise SuspiciousPrePrepare('Trying to order already ordered request')
operation = request.operation
req_handler = self.get_req_handler(txn_type=operation[TXN_TYPE])
req_handler.validate(request)
self.execute_hook(NodeHooks.POST_DYNAMIC_VALIDATION, request=request)
|
python
|
def doDynamicValidation(self, request: Request):
"""
State based validation
"""
self.execute_hook(NodeHooks.PRE_DYNAMIC_VALIDATION, request=request)
# Digest validation
ledger_id, seq_no = self.seqNoDB.get_by_payload_digest(request.payload_digest)
if ledger_id is not None and seq_no is not None:
raise SuspiciousPrePrepare('Trying to order already ordered request')
ledger = self.getLedger(self.ledger_id_for_request(request))
for txn in ledger.uncommittedTxns:
if get_payload_digest(txn) == request.payload_digest:
raise SuspiciousPrePrepare('Trying to order already ordered request')
operation = request.operation
req_handler = self.get_req_handler(txn_type=operation[TXN_TYPE])
req_handler.validate(request)
self.execute_hook(NodeHooks.POST_DYNAMIC_VALIDATION, request=request)
|
[
"def",
"doDynamicValidation",
"(",
"self",
",",
"request",
":",
"Request",
")",
":",
"self",
".",
"execute_hook",
"(",
"NodeHooks",
".",
"PRE_DYNAMIC_VALIDATION",
",",
"request",
"=",
"request",
")",
"# Digest validation",
"ledger_id",
",",
"seq_no",
"=",
"self",
".",
"seqNoDB",
".",
"get_by_payload_digest",
"(",
"request",
".",
"payload_digest",
")",
"if",
"ledger_id",
"is",
"not",
"None",
"and",
"seq_no",
"is",
"not",
"None",
":",
"raise",
"SuspiciousPrePrepare",
"(",
"'Trying to order already ordered request'",
")",
"ledger",
"=",
"self",
".",
"getLedger",
"(",
"self",
".",
"ledger_id_for_request",
"(",
"request",
")",
")",
"for",
"txn",
"in",
"ledger",
".",
"uncommittedTxns",
":",
"if",
"get_payload_digest",
"(",
"txn",
")",
"==",
"request",
".",
"payload_digest",
":",
"raise",
"SuspiciousPrePrepare",
"(",
"'Trying to order already ordered request'",
")",
"operation",
"=",
"request",
".",
"operation",
"req_handler",
"=",
"self",
".",
"get_req_handler",
"(",
"txn_type",
"=",
"operation",
"[",
"TXN_TYPE",
"]",
")",
"req_handler",
".",
"validate",
"(",
"request",
")",
"self",
".",
"execute_hook",
"(",
"NodeHooks",
".",
"POST_DYNAMIC_VALIDATION",
",",
"request",
"=",
"request",
")"
] |
State based validation
|
[
"State",
"based",
"validation"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2401-L2421
|
234,296
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.applyReq
|
def applyReq(self, request: Request, cons_time: int):
"""
Apply request to appropriate ledger and state. `cons_time` is the
UTC epoch at which consensus was reached.
"""
self.execute_hook(NodeHooks.PRE_REQUEST_APPLICATION, request=request,
cons_time=cons_time)
req_handler = self.get_req_handler(txn_type=request.operation[TXN_TYPE])
seq_no, txn = req_handler.apply(request, cons_time)
ledger_id = self.ledger_id_for_request(request)
self.execute_hook(NodeHooks.POST_REQUEST_APPLICATION, request=request,
cons_time=cons_time, ledger_id=ledger_id,
seq_no=seq_no, txn=txn)
|
python
|
def applyReq(self, request: Request, cons_time: int):
"""
Apply request to appropriate ledger and state. `cons_time` is the
UTC epoch at which consensus was reached.
"""
self.execute_hook(NodeHooks.PRE_REQUEST_APPLICATION, request=request,
cons_time=cons_time)
req_handler = self.get_req_handler(txn_type=request.operation[TXN_TYPE])
seq_no, txn = req_handler.apply(request, cons_time)
ledger_id = self.ledger_id_for_request(request)
self.execute_hook(NodeHooks.POST_REQUEST_APPLICATION, request=request,
cons_time=cons_time, ledger_id=ledger_id,
seq_no=seq_no, txn=txn)
|
[
"def",
"applyReq",
"(",
"self",
",",
"request",
":",
"Request",
",",
"cons_time",
":",
"int",
")",
":",
"self",
".",
"execute_hook",
"(",
"NodeHooks",
".",
"PRE_REQUEST_APPLICATION",
",",
"request",
"=",
"request",
",",
"cons_time",
"=",
"cons_time",
")",
"req_handler",
"=",
"self",
".",
"get_req_handler",
"(",
"txn_type",
"=",
"request",
".",
"operation",
"[",
"TXN_TYPE",
"]",
")",
"seq_no",
",",
"txn",
"=",
"req_handler",
".",
"apply",
"(",
"request",
",",
"cons_time",
")",
"ledger_id",
"=",
"self",
".",
"ledger_id_for_request",
"(",
"request",
")",
"self",
".",
"execute_hook",
"(",
"NodeHooks",
".",
"POST_REQUEST_APPLICATION",
",",
"request",
"=",
"request",
",",
"cons_time",
"=",
"cons_time",
",",
"ledger_id",
"=",
"ledger_id",
",",
"seq_no",
"=",
"seq_no",
",",
"txn",
"=",
"txn",
")"
] |
Apply request to appropriate ledger and state. `cons_time` is the
UTC epoch at which consensus was reached.
|
[
"Apply",
"request",
"to",
"appropriate",
"ledger",
"and",
"state",
".",
"cons_time",
"is",
"the",
"UTC",
"epoch",
"at",
"which",
"consensus",
"was",
"reached",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2423-L2435
|
234,297
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.processRequest
|
def processRequest(self, request: Request, frm: str):
"""
Handle a REQUEST from the client.
If the request has already been executed, the node re-sends the reply to
the client. Otherwise, the node acknowledges the client request, adds it
to its list of client requests, and sends a PROPAGATE to the
remaining nodes.
:param request: the REQUEST from the client
:param frm: the name of the client that sent this REQUEST
"""
logger.debug("{} received client request: {} from {}".
format(self.name, request, frm))
self.nodeRequestSpikeMonitorData['accum'] += 1
# TODO: What if client sends requests with same request id quickly so
# before reply for one is generated, the other comes. In that
# case we need to keep track of what requests ids node has seen
# in-memory and once request with a particular request id is processed,
# it should be removed from that in-memory DS.
# If request is already processed(there is a reply for the
# request in
# the node's transaction store then return the reply from the
# transaction store)
# TODO: What if the reply was a REQNACK? Its not gonna be found in the
# replies.
txn_type = request.operation[TXN_TYPE]
if self.is_action(txn_type):
self.process_action(request, frm)
elif txn_type == GET_TXN:
self.handle_get_txn_req(request, frm)
self.total_read_request_number += 1
elif self.is_query(txn_type):
self.process_query(request, frm)
self.total_read_request_number += 1
elif self.can_write_txn(txn_type):
reply = self.getReplyFromLedgerForRequest(request)
if reply:
logger.debug("{} returning reply from already processed "
"REQUEST: {}".format(self, request))
self.transmitToClient(reply, frm)
return
# If the node is not already processing the request
if not self.isProcessingReq(request.key):
self.startedProcessingReq(request.key, frm)
# forced request should be processed before consensus
self.handle_request_if_forced(request)
# If not already got the propagate request(PROPAGATE) for the
# corresponding client request(REQUEST)
self.recordAndPropagate(request, frm)
self.send_ack_to_client((request.identifier, request.reqId), frm)
else:
raise InvalidClientRequest(
request.identifier,
request.reqId,
'Pool is in readonly mode, try again in 60 seconds')
|
python
|
def processRequest(self, request: Request, frm: str):
"""
Handle a REQUEST from the client.
If the request has already been executed, the node re-sends the reply to
the client. Otherwise, the node acknowledges the client request, adds it
to its list of client requests, and sends a PROPAGATE to the
remaining nodes.
:param request: the REQUEST from the client
:param frm: the name of the client that sent this REQUEST
"""
logger.debug("{} received client request: {} from {}".
format(self.name, request, frm))
self.nodeRequestSpikeMonitorData['accum'] += 1
# TODO: What if client sends requests with same request id quickly so
# before reply for one is generated, the other comes. In that
# case we need to keep track of what requests ids node has seen
# in-memory and once request with a particular request id is processed,
# it should be removed from that in-memory DS.
# If request is already processed(there is a reply for the
# request in
# the node's transaction store then return the reply from the
# transaction store)
# TODO: What if the reply was a REQNACK? Its not gonna be found in the
# replies.
txn_type = request.operation[TXN_TYPE]
if self.is_action(txn_type):
self.process_action(request, frm)
elif txn_type == GET_TXN:
self.handle_get_txn_req(request, frm)
self.total_read_request_number += 1
elif self.is_query(txn_type):
self.process_query(request, frm)
self.total_read_request_number += 1
elif self.can_write_txn(txn_type):
reply = self.getReplyFromLedgerForRequest(request)
if reply:
logger.debug("{} returning reply from already processed "
"REQUEST: {}".format(self, request))
self.transmitToClient(reply, frm)
return
# If the node is not already processing the request
if not self.isProcessingReq(request.key):
self.startedProcessingReq(request.key, frm)
# forced request should be processed before consensus
self.handle_request_if_forced(request)
# If not already got the propagate request(PROPAGATE) for the
# corresponding client request(REQUEST)
self.recordAndPropagate(request, frm)
self.send_ack_to_client((request.identifier, request.reqId), frm)
else:
raise InvalidClientRequest(
request.identifier,
request.reqId,
'Pool is in readonly mode, try again in 60 seconds')
|
[
"def",
"processRequest",
"(",
"self",
",",
"request",
":",
"Request",
",",
"frm",
":",
"str",
")",
":",
"logger",
".",
"debug",
"(",
"\"{} received client request: {} from {}\"",
".",
"format",
"(",
"self",
".",
"name",
",",
"request",
",",
"frm",
")",
")",
"self",
".",
"nodeRequestSpikeMonitorData",
"[",
"'accum'",
"]",
"+=",
"1",
"# TODO: What if client sends requests with same request id quickly so",
"# before reply for one is generated, the other comes. In that",
"# case we need to keep track of what requests ids node has seen",
"# in-memory and once request with a particular request id is processed,",
"# it should be removed from that in-memory DS.",
"# If request is already processed(there is a reply for the",
"# request in",
"# the node's transaction store then return the reply from the",
"# transaction store)",
"# TODO: What if the reply was a REQNACK? Its not gonna be found in the",
"# replies.",
"txn_type",
"=",
"request",
".",
"operation",
"[",
"TXN_TYPE",
"]",
"if",
"self",
".",
"is_action",
"(",
"txn_type",
")",
":",
"self",
".",
"process_action",
"(",
"request",
",",
"frm",
")",
"elif",
"txn_type",
"==",
"GET_TXN",
":",
"self",
".",
"handle_get_txn_req",
"(",
"request",
",",
"frm",
")",
"self",
".",
"total_read_request_number",
"+=",
"1",
"elif",
"self",
".",
"is_query",
"(",
"txn_type",
")",
":",
"self",
".",
"process_query",
"(",
"request",
",",
"frm",
")",
"self",
".",
"total_read_request_number",
"+=",
"1",
"elif",
"self",
".",
"can_write_txn",
"(",
"txn_type",
")",
":",
"reply",
"=",
"self",
".",
"getReplyFromLedgerForRequest",
"(",
"request",
")",
"if",
"reply",
":",
"logger",
".",
"debug",
"(",
"\"{} returning reply from already processed \"",
"\"REQUEST: {}\"",
".",
"format",
"(",
"self",
",",
"request",
")",
")",
"self",
".",
"transmitToClient",
"(",
"reply",
",",
"frm",
")",
"return",
"# If the node is not already processing the request",
"if",
"not",
"self",
".",
"isProcessingReq",
"(",
"request",
".",
"key",
")",
":",
"self",
".",
"startedProcessingReq",
"(",
"request",
".",
"key",
",",
"frm",
")",
"# forced request should be processed before consensus",
"self",
".",
"handle_request_if_forced",
"(",
"request",
")",
"# If not already got the propagate request(PROPAGATE) for the",
"# corresponding client request(REQUEST)",
"self",
".",
"recordAndPropagate",
"(",
"request",
",",
"frm",
")",
"self",
".",
"send_ack_to_client",
"(",
"(",
"request",
".",
"identifier",
",",
"request",
".",
"reqId",
")",
",",
"frm",
")",
"else",
":",
"raise",
"InvalidClientRequest",
"(",
"request",
".",
"identifier",
",",
"request",
".",
"reqId",
",",
"'Pool is in readonly mode, try again in 60 seconds'",
")"
] |
Handle a REQUEST from the client.
If the request has already been executed, the node re-sends the reply to
the client. Otherwise, the node acknowledges the client request, adds it
to its list of client requests, and sends a PROPAGATE to the
remaining nodes.
:param request: the REQUEST from the client
:param frm: the name of the client that sent this REQUEST
|
[
"Handle",
"a",
"REQUEST",
"from",
"the",
"client",
".",
"If",
"the",
"request",
"has",
"already",
"been",
"executed",
"the",
"node",
"re",
"-",
"sends",
"the",
"reply",
"to",
"the",
"client",
".",
"Otherwise",
"the",
"node",
"acknowledges",
"the",
"client",
"request",
"adds",
"it",
"to",
"its",
"list",
"of",
"client",
"requests",
"and",
"sends",
"a",
"PROPAGATE",
"to",
"the",
"remaining",
"nodes",
"."
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2464-L2528
|
234,298
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.processPropagate
|
def processPropagate(self, msg: Propagate, frm):
"""
Process one propagateRequest sent to this node asynchronously
- If this propagateRequest hasn't been seen by this node, then broadcast
it to all nodes after verifying the the signature.
- Add the client to blacklist if its signature is invalid
:param msg: the propagateRequest
:param frm: the name of the node which sent this `msg`
"""
logger.debug("{} received propagated request: {}".
format(self.name, msg))
request = TxnUtilConfig.client_request_class(**msg.request)
clientName = msg.senderClient
if not self.isProcessingReq(request.key):
ledger_id, seq_no = self.seqNoDB.get_by_payload_digest(request.payload_digest)
if ledger_id is not None and seq_no is not None:
self._clean_req_from_verified(request)
logger.debug("{} ignoring propagated request {} "
"since it has been already ordered"
.format(self.name, msg))
return
self.startedProcessingReq(request.key, clientName)
# forced request should be processed before consensus
self.handle_request_if_forced(request)
else:
if clientName is not None and \
not self.is_sender_known_for_req(request.key):
# Since some propagates might not include the client name
self.set_sender_for_req(request.key,
clientName)
self.requests.add_propagate(request, frm)
self.propagate(request, clientName)
self.tryForwarding(request)
|
python
|
def processPropagate(self, msg: Propagate, frm):
"""
Process one propagateRequest sent to this node asynchronously
- If this propagateRequest hasn't been seen by this node, then broadcast
it to all nodes after verifying the the signature.
- Add the client to blacklist if its signature is invalid
:param msg: the propagateRequest
:param frm: the name of the node which sent this `msg`
"""
logger.debug("{} received propagated request: {}".
format(self.name, msg))
request = TxnUtilConfig.client_request_class(**msg.request)
clientName = msg.senderClient
if not self.isProcessingReq(request.key):
ledger_id, seq_no = self.seqNoDB.get_by_payload_digest(request.payload_digest)
if ledger_id is not None and seq_no is not None:
self._clean_req_from_verified(request)
logger.debug("{} ignoring propagated request {} "
"since it has been already ordered"
.format(self.name, msg))
return
self.startedProcessingReq(request.key, clientName)
# forced request should be processed before consensus
self.handle_request_if_forced(request)
else:
if clientName is not None and \
not self.is_sender_known_for_req(request.key):
# Since some propagates might not include the client name
self.set_sender_for_req(request.key,
clientName)
self.requests.add_propagate(request, frm)
self.propagate(request, clientName)
self.tryForwarding(request)
|
[
"def",
"processPropagate",
"(",
"self",
",",
"msg",
":",
"Propagate",
",",
"frm",
")",
":",
"logger",
".",
"debug",
"(",
"\"{} received propagated request: {}\"",
".",
"format",
"(",
"self",
".",
"name",
",",
"msg",
")",
")",
"request",
"=",
"TxnUtilConfig",
".",
"client_request_class",
"(",
"*",
"*",
"msg",
".",
"request",
")",
"clientName",
"=",
"msg",
".",
"senderClient",
"if",
"not",
"self",
".",
"isProcessingReq",
"(",
"request",
".",
"key",
")",
":",
"ledger_id",
",",
"seq_no",
"=",
"self",
".",
"seqNoDB",
".",
"get_by_payload_digest",
"(",
"request",
".",
"payload_digest",
")",
"if",
"ledger_id",
"is",
"not",
"None",
"and",
"seq_no",
"is",
"not",
"None",
":",
"self",
".",
"_clean_req_from_verified",
"(",
"request",
")",
"logger",
".",
"debug",
"(",
"\"{} ignoring propagated request {} \"",
"\"since it has been already ordered\"",
".",
"format",
"(",
"self",
".",
"name",
",",
"msg",
")",
")",
"return",
"self",
".",
"startedProcessingReq",
"(",
"request",
".",
"key",
",",
"clientName",
")",
"# forced request should be processed before consensus",
"self",
".",
"handle_request_if_forced",
"(",
"request",
")",
"else",
":",
"if",
"clientName",
"is",
"not",
"None",
"and",
"not",
"self",
".",
"is_sender_known_for_req",
"(",
"request",
".",
"key",
")",
":",
"# Since some propagates might not include the client name",
"self",
".",
"set_sender_for_req",
"(",
"request",
".",
"key",
",",
"clientName",
")",
"self",
".",
"requests",
".",
"add_propagate",
"(",
"request",
",",
"frm",
")",
"self",
".",
"propagate",
"(",
"request",
",",
"clientName",
")",
"self",
".",
"tryForwarding",
"(",
"request",
")"
] |
Process one propagateRequest sent to this node asynchronously
- If this propagateRequest hasn't been seen by this node, then broadcast
it to all nodes after verifying the the signature.
- Add the client to blacklist if its signature is invalid
:param msg: the propagateRequest
:param frm: the name of the node which sent this `msg`
|
[
"Process",
"one",
"propagateRequest",
"sent",
"to",
"this",
"node",
"asynchronously"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2569-L2610
|
234,299
|
hyperledger/indy-plenum
|
plenum/server/node.py
|
Node.handle_get_txn_req
|
def handle_get_txn_req(self, request: Request, frm: str):
"""
Handle GET_TXN request
"""
ledger_id = request.operation.get(f.LEDGER_ID.nm, DOMAIN_LEDGER_ID)
if ledger_id not in self.ledger_to_req_handler:
self.send_nack_to_client((request.identifier, request.reqId),
'Invalid ledger id {}'.format(ledger_id),
frm)
return
seq_no = request.operation.get(DATA)
self.send_ack_to_client((request.identifier, request.reqId), frm)
ledger = self.getLedger(ledger_id)
try:
txn = self.getReplyFromLedger(ledger, seq_no)
except KeyError:
txn = None
if txn is None:
logger.debug(
"{} can not handle GET_TXN request: ledger doesn't "
"have txn with seqNo={}".format(self, str(seq_no)))
result = {
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
TXN_TYPE: request.operation[TXN_TYPE],
DATA: None
}
if txn:
result[DATA] = txn.result
result[f.SEQ_NO.nm] = get_seq_no(txn.result)
self.transmitToClient(Reply(result), frm)
|
python
|
def handle_get_txn_req(self, request: Request, frm: str):
"""
Handle GET_TXN request
"""
ledger_id = request.operation.get(f.LEDGER_ID.nm, DOMAIN_LEDGER_ID)
if ledger_id not in self.ledger_to_req_handler:
self.send_nack_to_client((request.identifier, request.reqId),
'Invalid ledger id {}'.format(ledger_id),
frm)
return
seq_no = request.operation.get(DATA)
self.send_ack_to_client((request.identifier, request.reqId), frm)
ledger = self.getLedger(ledger_id)
try:
txn = self.getReplyFromLedger(ledger, seq_no)
except KeyError:
txn = None
if txn is None:
logger.debug(
"{} can not handle GET_TXN request: ledger doesn't "
"have txn with seqNo={}".format(self, str(seq_no)))
result = {
f.IDENTIFIER.nm: request.identifier,
f.REQ_ID.nm: request.reqId,
TXN_TYPE: request.operation[TXN_TYPE],
DATA: None
}
if txn:
result[DATA] = txn.result
result[f.SEQ_NO.nm] = get_seq_no(txn.result)
self.transmitToClient(Reply(result), frm)
|
[
"def",
"handle_get_txn_req",
"(",
"self",
",",
"request",
":",
"Request",
",",
"frm",
":",
"str",
")",
":",
"ledger_id",
"=",
"request",
".",
"operation",
".",
"get",
"(",
"f",
".",
"LEDGER_ID",
".",
"nm",
",",
"DOMAIN_LEDGER_ID",
")",
"if",
"ledger_id",
"not",
"in",
"self",
".",
"ledger_to_req_handler",
":",
"self",
".",
"send_nack_to_client",
"(",
"(",
"request",
".",
"identifier",
",",
"request",
".",
"reqId",
")",
",",
"'Invalid ledger id {}'",
".",
"format",
"(",
"ledger_id",
")",
",",
"frm",
")",
"return",
"seq_no",
"=",
"request",
".",
"operation",
".",
"get",
"(",
"DATA",
")",
"self",
".",
"send_ack_to_client",
"(",
"(",
"request",
".",
"identifier",
",",
"request",
".",
"reqId",
")",
",",
"frm",
")",
"ledger",
"=",
"self",
".",
"getLedger",
"(",
"ledger_id",
")",
"try",
":",
"txn",
"=",
"self",
".",
"getReplyFromLedger",
"(",
"ledger",
",",
"seq_no",
")",
"except",
"KeyError",
":",
"txn",
"=",
"None",
"if",
"txn",
"is",
"None",
":",
"logger",
".",
"debug",
"(",
"\"{} can not handle GET_TXN request: ledger doesn't \"",
"\"have txn with seqNo={}\"",
".",
"format",
"(",
"self",
",",
"str",
"(",
"seq_no",
")",
")",
")",
"result",
"=",
"{",
"f",
".",
"IDENTIFIER",
".",
"nm",
":",
"request",
".",
"identifier",
",",
"f",
".",
"REQ_ID",
".",
"nm",
":",
"request",
".",
"reqId",
",",
"TXN_TYPE",
":",
"request",
".",
"operation",
"[",
"TXN_TYPE",
"]",
",",
"DATA",
":",
"None",
"}",
"if",
"txn",
":",
"result",
"[",
"DATA",
"]",
"=",
"txn",
".",
"result",
"result",
"[",
"f",
".",
"SEQ_NO",
".",
"nm",
"]",
"=",
"get_seq_no",
"(",
"txn",
".",
"result",
")",
"self",
".",
"transmitToClient",
"(",
"Reply",
"(",
"result",
")",
",",
"frm",
")"
] |
Handle GET_TXN request
|
[
"Handle",
"GET_TXN",
"request"
] |
dcd144e238af7f17a869ffc9412f13dc488b7020
|
https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2634-L2670
|
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.