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 listlengths 20 707 | docstring stringlengths 3 17.3k | docstring_tokens listlengths 3 222 | sha stringlengths 40 40 | url stringlengths 87 242 | partition stringclasses 1 value | idx int64 0 252k |
|---|---|---|---|---|---|---|---|---|---|---|---|---|
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",
... | 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 | train | 229,100 |
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 | train | 229,101 |
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",
"("... | 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 | train | 229,102 |
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 | train | 229,103 |
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",
... | Start ZAP authentication | [
"Start",
"ZAP",
"authentication"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/authenticator.py#L88-L93 | train | 229,104 |
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",
"."... | Stop ZAP authentication | [
"Stop",
"ZAP",
"authentication"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/stp_zmq/authenticator.py#L95-L102 | train | 229,105 |
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",
",",
... | 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 | train | 229,106 |
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",
",... | 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 | train | 229,107 |
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... | 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 | train | 229,108 |
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 | train | 229,109 |
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",
",",
"No... | 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 | train | 229,110 |
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",
"... | 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 | train | 229,111 |
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",
")",
":",
"remoteNam... | 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 | train | 229,112 |
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 sto... | 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 | train | 229,113 |
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_si... | helper function for parseLedgerForHaAndKeys | [
"helper",
"function",
"for",
"parseLedgerForHaAndKeys"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/stack_manager.py#L58-L98 | train | 229,114 |
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",
"=",
... | 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 | train | 229,115 |
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",
"(",
")",
"+",
... | 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 | train | 229,116 |
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",
"(",
... | 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 | train | 229,117 |
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",
... | 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 | train | 229,118 |
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",
".",
"onPoolMembers... | 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 | train | 229,119 |
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'",
"."... | 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 | train | 229,120 |
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... | 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 | train | 229,121 |
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 \""... | 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 | train | 229,122 |
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",
"(",
... | 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 | train | 229,123 |
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",
"... | .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 | train | 229,124 |
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",... | 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 | train | 229,125 |
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",
".",
"m... | 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 | train | 229,126 |
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",
... | 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 | train | 229,127 |
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... | 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 | train | 229,128 |
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",
".",
"_obs... | 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 | train | 229,129 |
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 | train | 229,130 |
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",
",",
"]",
... | 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 | train | 229,131 |
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",... | 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",
"nod... | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L1587-L1597 | train | 229,132 |
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_requi... | 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 | train | 229,133 |
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",
":"... | 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 | train | 229,134 |
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",
")",
... | 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 | train | 229,135 |
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",
... | 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 | train | 229,136 |
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"... | 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 | train | 229,137 |
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",
... | 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 | train | 229,138 |
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",
"(",... | 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 | train | 229,139 |
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",
".",
"appen... | 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 | train | 229,140 |
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",
","... | 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 | train | 229,141 |
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",
"]",
",",
... | 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 | train | 229,142 |
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",
".",
... | 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 | train | 229,143 |
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",
",",
"... | 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 | train | 229,144 |
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 | train | 229,145 |
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",
":",
"... | 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 | train | 229,146 |
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 {}\... | 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 | train | 229,147 |
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",
".... | 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",
"... | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2275-L2298 | train | 229,148 |
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"... | State based validation | [
"State",
"based",
"validation"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2401-L2421 | train | 229,149 |
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",
")",
... | 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 | train | 229,150 |
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",
")",
")"... | 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"... | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2464-L2528 | train | 229,151 |
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",... | 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 | train | 229,152 |
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",... | Handle GET_TXN request | [
"Handle",
"GET_TXN",
"request"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2634-L2670 | train | 229,153 |
hyperledger/indy-plenum | plenum/server/node.py | Node.processOrdered | def processOrdered(self, ordered: Ordered):
"""
Execute ordered request
:param ordered: an ordered request
:return: whether executed
"""
if ordered.instId not in self.instances.ids:
logger.warning('{} got ordered request for instance {} which '
'does not exist'.format(self, ordered.instId))
return False
if ordered.instId != self.instances.masterId:
# Requests from backup replicas are not executed
logger.trace("{} got ordered requests from backup replica {}"
.format(self, ordered.instId))
with self.metrics.measure_time(MetricsName.MONITOR_REQUEST_ORDERED_TIME):
self.monitor.requestOrdered(ordered.valid_reqIdr + ordered.invalid_reqIdr,
ordered.instId,
self.requests,
byMaster=False)
return False
logger.trace("{} got ordered requests from master replica"
.format(self))
logger.debug("{} executing Ordered batch {} {} of {} requests; state root {}; txn root {}"
.format(self.name,
ordered.viewNo,
ordered.ppSeqNo,
len(ordered.valid_reqIdr),
ordered.stateRootHash,
ordered.txnRootHash))
three_pc_batch = ThreePcBatch.from_ordered(ordered)
if self.db_manager.ledgers[AUDIT_LEDGER_ID].uncommittedRootHash is None:
# if we order request during view change
# in between catchup rounds, then the 3PC batch will not be applied,
# since it was reverted before catchup started, and only COMMITs were
# processed in between catchup that led to this ORDERED msg
logger.info("{} applying stashed requests for batch {} {} of {} requests; state root {}; txn root {}"
.format(self.name,
three_pc_batch.view_no,
three_pc_batch.pp_seq_no,
len(three_pc_batch.valid_digests),
three_pc_batch.state_root,
three_pc_batch.txn_root))
self.apply_stashed_reqs(three_pc_batch)
self.executeBatch(three_pc_batch,
ordered.valid_reqIdr,
ordered.invalid_reqIdr,
ordered.auditTxnRootHash)
with self.metrics.measure_time(MetricsName.MONITOR_REQUEST_ORDERED_TIME):
self.monitor.requestOrdered(ordered.valid_reqIdr + ordered.invalid_reqIdr,
ordered.instId,
self.requests,
byMaster=True)
return True | python | def processOrdered(self, ordered: Ordered):
"""
Execute ordered request
:param ordered: an ordered request
:return: whether executed
"""
if ordered.instId not in self.instances.ids:
logger.warning('{} got ordered request for instance {} which '
'does not exist'.format(self, ordered.instId))
return False
if ordered.instId != self.instances.masterId:
# Requests from backup replicas are not executed
logger.trace("{} got ordered requests from backup replica {}"
.format(self, ordered.instId))
with self.metrics.measure_time(MetricsName.MONITOR_REQUEST_ORDERED_TIME):
self.monitor.requestOrdered(ordered.valid_reqIdr + ordered.invalid_reqIdr,
ordered.instId,
self.requests,
byMaster=False)
return False
logger.trace("{} got ordered requests from master replica"
.format(self))
logger.debug("{} executing Ordered batch {} {} of {} requests; state root {}; txn root {}"
.format(self.name,
ordered.viewNo,
ordered.ppSeqNo,
len(ordered.valid_reqIdr),
ordered.stateRootHash,
ordered.txnRootHash))
three_pc_batch = ThreePcBatch.from_ordered(ordered)
if self.db_manager.ledgers[AUDIT_LEDGER_ID].uncommittedRootHash is None:
# if we order request during view change
# in between catchup rounds, then the 3PC batch will not be applied,
# since it was reverted before catchup started, and only COMMITs were
# processed in between catchup that led to this ORDERED msg
logger.info("{} applying stashed requests for batch {} {} of {} requests; state root {}; txn root {}"
.format(self.name,
three_pc_batch.view_no,
three_pc_batch.pp_seq_no,
len(three_pc_batch.valid_digests),
three_pc_batch.state_root,
three_pc_batch.txn_root))
self.apply_stashed_reqs(three_pc_batch)
self.executeBatch(three_pc_batch,
ordered.valid_reqIdr,
ordered.invalid_reqIdr,
ordered.auditTxnRootHash)
with self.metrics.measure_time(MetricsName.MONITOR_REQUEST_ORDERED_TIME):
self.monitor.requestOrdered(ordered.valid_reqIdr + ordered.invalid_reqIdr,
ordered.instId,
self.requests,
byMaster=True)
return True | [
"def",
"processOrdered",
"(",
"self",
",",
"ordered",
":",
"Ordered",
")",
":",
"if",
"ordered",
".",
"instId",
"not",
"in",
"self",
".",
"instances",
".",
"ids",
":",
"logger",
".",
"warning",
"(",
"'{} got ordered request for instance {} which '",
"'does not e... | Execute ordered request
:param ordered: an ordered request
:return: whether executed | [
"Execute",
"ordered",
"request"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2673-L2735 | train | 229,154 |
hyperledger/indy-plenum | plenum/server/node.py | Node.force_process_ordered | def force_process_ordered(self):
"""
Take any messages from replica that have been ordered and process
them, this should be done rarely, like before catchup starts
so a more current LedgerStatus can be sent.
can be called either
1. when node is participating, this happens just before catchup starts
so the node can have the latest ledger status or
2. when node is not participating but a round of catchup is about to be
started, here is forces all the replica ordered messages to be appended
to the stashed ordered requests and the stashed ordered requests are
processed with appropriate checks
"""
for instance_id, messages in self.replicas.take_ordereds_out_of_turn():
num_processed = 0
for message in messages:
self.try_processing_ordered(message)
num_processed += 1
logger.info('{} processed {} Ordered batches for instance {} '
'before starting catch up'
.format(self, num_processed, instance_id)) | python | def force_process_ordered(self):
"""
Take any messages from replica that have been ordered and process
them, this should be done rarely, like before catchup starts
so a more current LedgerStatus can be sent.
can be called either
1. when node is participating, this happens just before catchup starts
so the node can have the latest ledger status or
2. when node is not participating but a round of catchup is about to be
started, here is forces all the replica ordered messages to be appended
to the stashed ordered requests and the stashed ordered requests are
processed with appropriate checks
"""
for instance_id, messages in self.replicas.take_ordereds_out_of_turn():
num_processed = 0
for message in messages:
self.try_processing_ordered(message)
num_processed += 1
logger.info('{} processed {} Ordered batches for instance {} '
'before starting catch up'
.format(self, num_processed, instance_id)) | [
"def",
"force_process_ordered",
"(",
"self",
")",
":",
"for",
"instance_id",
",",
"messages",
"in",
"self",
".",
"replicas",
".",
"take_ordereds_out_of_turn",
"(",
")",
":",
"num_processed",
"=",
"0",
"for",
"message",
"in",
"messages",
":",
"self",
".",
"tr... | Take any messages from replica that have been ordered and process
them, this should be done rarely, like before catchup starts
so a more current LedgerStatus can be sent.
can be called either
1. when node is participating, this happens just before catchup starts
so the node can have the latest ledger status or
2. when node is not participating but a round of catchup is about to be
started, here is forces all the replica ordered messages to be appended
to the stashed ordered requests and the stashed ordered requests are
processed with appropriate checks | [
"Take",
"any",
"messages",
"from",
"replica",
"that",
"have",
"been",
"ordered",
"and",
"process",
"them",
"this",
"should",
"be",
"done",
"rarely",
"like",
"before",
"catchup",
"starts",
"so",
"a",
"more",
"current",
"LedgerStatus",
"can",
"be",
"sent",
"."... | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2737-L2758 | train | 229,155 |
hyperledger/indy-plenum | plenum/server/node.py | Node.processEscalatedException | def processEscalatedException(self, ex):
"""
Process an exception escalated from a Replica
"""
if isinstance(ex, SuspiciousNode):
self.reportSuspiciousNodeEx(ex)
else:
raise RuntimeError("unhandled replica-escalated exception") from ex | python | def processEscalatedException(self, ex):
"""
Process an exception escalated from a Replica
"""
if isinstance(ex, SuspiciousNode):
self.reportSuspiciousNodeEx(ex)
else:
raise RuntimeError("unhandled replica-escalated exception") from ex | [
"def",
"processEscalatedException",
"(",
"self",
",",
"ex",
")",
":",
"if",
"isinstance",
"(",
"ex",
",",
"SuspiciousNode",
")",
":",
"self",
".",
"reportSuspiciousNodeEx",
"(",
"ex",
")",
"else",
":",
"raise",
"RuntimeError",
"(",
"\"unhandled replica-escalated... | Process an exception escalated from a Replica | [
"Process",
"an",
"exception",
"escalated",
"from",
"a",
"Replica"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L2766-L2773 | train | 229,156 |
hyperledger/indy-plenum | plenum/server/node.py | Node.lost_master_primary | def lost_master_primary(self):
"""
Schedule an primary connection check which in turn can send a view
change message
"""
self.primaries_disconnection_times[self.master_replica.instId] = time.perf_counter()
self._schedule_view_change() | python | def lost_master_primary(self):
"""
Schedule an primary connection check which in turn can send a view
change message
"""
self.primaries_disconnection_times[self.master_replica.instId] = time.perf_counter()
self._schedule_view_change() | [
"def",
"lost_master_primary",
"(",
"self",
")",
":",
"self",
".",
"primaries_disconnection_times",
"[",
"self",
".",
"master_replica",
".",
"instId",
"]",
"=",
"time",
".",
"perf_counter",
"(",
")",
"self",
".",
"_schedule_view_change",
"(",
")"
] | Schedule an primary connection check which in turn can send a view
change message | [
"Schedule",
"an",
"primary",
"connection",
"check",
"which",
"in",
"turn",
"can",
"send",
"a",
"view",
"change",
"message"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3134-L3140 | train | 229,157 |
hyperledger/indy-plenum | plenum/server/node.py | Node.executeBatch | def executeBatch(self, three_pc_batch: ThreePcBatch,
valid_reqs_keys: List, invalid_reqs_keys: List,
audit_txn_root) -> None:
"""
Execute the REQUEST sent to this Node
:param view_no: the view number (See glossary)
:param pp_time: the time at which PRE-PREPARE was sent
:param valid_reqs: list of valid client requests keys
:param valid_reqs: list of invalid client requests keys
"""
# We need hashes in apply and str in commit
three_pc_batch.txn_root = Ledger.hashToStr(three_pc_batch.txn_root)
three_pc_batch.state_root = Ledger.hashToStr(three_pc_batch.state_root)
for req_key in valid_reqs_keys:
self.execute_hook(NodeHooks.PRE_REQUEST_COMMIT, req_key=req_key,
pp_time=three_pc_batch.pp_time,
state_root=three_pc_batch.state_root,
txn_root=three_pc_batch.txn_root)
self.execute_hook(NodeHooks.PRE_BATCH_COMMITTED,
ledger_id=three_pc_batch.ledger_id,
pp_time=three_pc_batch.pp_time,
reqs_keys=valid_reqs_keys,
state_root=three_pc_batch.state_root,
txn_root=three_pc_batch.txn_root)
try:
committedTxns = self.get_executer(three_pc_batch.ledger_id)(three_pc_batch)
except Exception as exc:
logger.error(
"{} commit failed for batch request, error {}, view no {}, "
"ppSeqNo {}, ledger {}, state root {}, txn root {}, "
"requests: {}".format(
self, repr(exc), three_pc_batch.view_no, three_pc_batch.pp_seq_no,
three_pc_batch.ledger_id, three_pc_batch.state_root,
three_pc_batch.txn_root, [req_idr for req_idr in valid_reqs_keys]
)
)
raise
for req_key in valid_reqs_keys + invalid_reqs_keys:
if req_key in self.requests:
self.mark_request_as_executed(self.requests[req_key].request)
else:
# Means that this request is dropped from the main requests queue due to timeout,
# but anyway it is ordered and executed normally
logger.debug('{} normally executed request {} which object has been dropped '
'from the requests queue'.format(self, req_key))
pass
# TODO is it possible to get len(committedTxns) != len(valid_reqs)
# someday
if not committedTxns:
return
logger.debug("{} committed batch request, view no {}, ppSeqNo {}, "
"ledger {}, state root {}, txn root {}, requests: {}".
format(self, three_pc_batch.view_no, three_pc_batch.pp_seq_no,
three_pc_batch.ledger_id, three_pc_batch.state_root,
three_pc_batch.txn_root, [key for key in valid_reqs_keys]))
for txn in committedTxns:
self.execute_hook(NodeHooks.POST_REQUEST_COMMIT, txn=txn,
pp_time=three_pc_batch.pp_time, state_root=three_pc_batch.state_root,
txn_root=three_pc_batch.txn_root)
first_txn_seq_no = get_seq_no(committedTxns[0])
last_txn_seq_no = get_seq_no(committedTxns[-1])
reqs = []
reqs_list_built = True
for req_key in valid_reqs_keys:
if req_key in self.requests:
reqs.append(self.requests[req_key].request.as_dict)
else:
logger.warning("Could not build requests list for observers due to non-existent requests")
reqs_list_built = False
break
if reqs_list_built:
batch_committed_msg = BatchCommitted(reqs,
three_pc_batch.ledger_id,
0,
three_pc_batch.view_no,
three_pc_batch.pp_seq_no,
three_pc_batch.pp_time,
three_pc_batch.state_root,
three_pc_batch.txn_root,
first_txn_seq_no,
last_txn_seq_no,
audit_txn_root,
three_pc_batch.primaries)
self._observable.append_input(batch_committed_msg, self.name) | python | def executeBatch(self, three_pc_batch: ThreePcBatch,
valid_reqs_keys: List, invalid_reqs_keys: List,
audit_txn_root) -> None:
"""
Execute the REQUEST sent to this Node
:param view_no: the view number (See glossary)
:param pp_time: the time at which PRE-PREPARE was sent
:param valid_reqs: list of valid client requests keys
:param valid_reqs: list of invalid client requests keys
"""
# We need hashes in apply and str in commit
three_pc_batch.txn_root = Ledger.hashToStr(three_pc_batch.txn_root)
three_pc_batch.state_root = Ledger.hashToStr(three_pc_batch.state_root)
for req_key in valid_reqs_keys:
self.execute_hook(NodeHooks.PRE_REQUEST_COMMIT, req_key=req_key,
pp_time=three_pc_batch.pp_time,
state_root=three_pc_batch.state_root,
txn_root=three_pc_batch.txn_root)
self.execute_hook(NodeHooks.PRE_BATCH_COMMITTED,
ledger_id=three_pc_batch.ledger_id,
pp_time=three_pc_batch.pp_time,
reqs_keys=valid_reqs_keys,
state_root=three_pc_batch.state_root,
txn_root=three_pc_batch.txn_root)
try:
committedTxns = self.get_executer(three_pc_batch.ledger_id)(three_pc_batch)
except Exception as exc:
logger.error(
"{} commit failed for batch request, error {}, view no {}, "
"ppSeqNo {}, ledger {}, state root {}, txn root {}, "
"requests: {}".format(
self, repr(exc), three_pc_batch.view_no, three_pc_batch.pp_seq_no,
three_pc_batch.ledger_id, three_pc_batch.state_root,
three_pc_batch.txn_root, [req_idr for req_idr in valid_reqs_keys]
)
)
raise
for req_key in valid_reqs_keys + invalid_reqs_keys:
if req_key in self.requests:
self.mark_request_as_executed(self.requests[req_key].request)
else:
# Means that this request is dropped from the main requests queue due to timeout,
# but anyway it is ordered and executed normally
logger.debug('{} normally executed request {} which object has been dropped '
'from the requests queue'.format(self, req_key))
pass
# TODO is it possible to get len(committedTxns) != len(valid_reqs)
# someday
if not committedTxns:
return
logger.debug("{} committed batch request, view no {}, ppSeqNo {}, "
"ledger {}, state root {}, txn root {}, requests: {}".
format(self, three_pc_batch.view_no, three_pc_batch.pp_seq_no,
three_pc_batch.ledger_id, three_pc_batch.state_root,
three_pc_batch.txn_root, [key for key in valid_reqs_keys]))
for txn in committedTxns:
self.execute_hook(NodeHooks.POST_REQUEST_COMMIT, txn=txn,
pp_time=three_pc_batch.pp_time, state_root=three_pc_batch.state_root,
txn_root=three_pc_batch.txn_root)
first_txn_seq_no = get_seq_no(committedTxns[0])
last_txn_seq_no = get_seq_no(committedTxns[-1])
reqs = []
reqs_list_built = True
for req_key in valid_reqs_keys:
if req_key in self.requests:
reqs.append(self.requests[req_key].request.as_dict)
else:
logger.warning("Could not build requests list for observers due to non-existent requests")
reqs_list_built = False
break
if reqs_list_built:
batch_committed_msg = BatchCommitted(reqs,
three_pc_batch.ledger_id,
0,
three_pc_batch.view_no,
three_pc_batch.pp_seq_no,
three_pc_batch.pp_time,
three_pc_batch.state_root,
three_pc_batch.txn_root,
first_txn_seq_no,
last_txn_seq_no,
audit_txn_root,
three_pc_batch.primaries)
self._observable.append_input(batch_committed_msg, self.name) | [
"def",
"executeBatch",
"(",
"self",
",",
"three_pc_batch",
":",
"ThreePcBatch",
",",
"valid_reqs_keys",
":",
"List",
",",
"invalid_reqs_keys",
":",
"List",
",",
"audit_txn_root",
")",
"->",
"None",
":",
"# We need hashes in apply and str in commit",
"three_pc_batch",
... | Execute the REQUEST sent to this Node
:param view_no: the view number (See glossary)
:param pp_time: the time at which PRE-PREPARE was sent
:param valid_reqs: list of valid client requests keys
:param valid_reqs: list of invalid client requests keys | [
"Execute",
"the",
"REQUEST",
"sent",
"to",
"this",
"Node"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3251-L3346 | train | 229,158 |
hyperledger/indy-plenum | plenum/server/node.py | Node.addNewRole | def addNewRole(self, txn):
"""
Adds a new client or steward to this node based on transaction type.
"""
# If the client authenticator is a simple authenticator then add verkey.
# For a custom authenticator, handle appropriately.
# NOTE: The following code should not be used in production
if isinstance(self.clientAuthNr.core_authenticator, SimpleAuthNr):
txn_data = get_payload_data(txn)
identifier = txn_data[TARGET_NYM]
verkey = txn_data.get(VERKEY)
v = DidVerifier(verkey, identifier=identifier)
if identifier not in self.clientAuthNr.core_authenticator.clients:
role = txn_data.get(ROLE)
if role not in (STEWARD, TRUSTEE, None):
logger.debug("Role if present must be {} and not {}".
format(Roles.STEWARD.name, role))
return
self.clientAuthNr.core_authenticator.addIdr(identifier,
verkey=v.verkey,
role=role) | python | def addNewRole(self, txn):
"""
Adds a new client or steward to this node based on transaction type.
"""
# If the client authenticator is a simple authenticator then add verkey.
# For a custom authenticator, handle appropriately.
# NOTE: The following code should not be used in production
if isinstance(self.clientAuthNr.core_authenticator, SimpleAuthNr):
txn_data = get_payload_data(txn)
identifier = txn_data[TARGET_NYM]
verkey = txn_data.get(VERKEY)
v = DidVerifier(verkey, identifier=identifier)
if identifier not in self.clientAuthNr.core_authenticator.clients:
role = txn_data.get(ROLE)
if role not in (STEWARD, TRUSTEE, None):
logger.debug("Role if present must be {} and not {}".
format(Roles.STEWARD.name, role))
return
self.clientAuthNr.core_authenticator.addIdr(identifier,
verkey=v.verkey,
role=role) | [
"def",
"addNewRole",
"(",
"self",
",",
"txn",
")",
":",
"# If the client authenticator is a simple authenticator then add verkey.",
"# For a custom authenticator, handle appropriately.",
"# NOTE: The following code should not be used in production",
"if",
"isinstance",
"(",
"self",
".... | Adds a new client or steward to this node based on transaction type. | [
"Adds",
"a",
"new",
"client",
"or",
"steward",
"to",
"this",
"node",
"based",
"on",
"transaction",
"type",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3441-L3461 | train | 229,159 |
hyperledger/indy-plenum | plenum/server/node.py | Node.ensureKeysAreSetup | def ensureKeysAreSetup(self):
"""
Check whether the keys are setup in the local STP keep.
Raises KeysNotFoundException if not found.
"""
if not areKeysSetup(self.name, self.keys_dir):
raise REx(REx.reason.format(self.name) + self.keygenScript) | python | def ensureKeysAreSetup(self):
"""
Check whether the keys are setup in the local STP keep.
Raises KeysNotFoundException if not found.
"""
if not areKeysSetup(self.name, self.keys_dir):
raise REx(REx.reason.format(self.name) + self.keygenScript) | [
"def",
"ensureKeysAreSetup",
"(",
"self",
")",
":",
"if",
"not",
"areKeysSetup",
"(",
"self",
".",
"name",
",",
"self",
".",
"keys_dir",
")",
":",
"raise",
"REx",
"(",
"REx",
".",
"reason",
".",
"format",
"(",
"self",
".",
"name",
")",
"+",
"self",
... | Check whether the keys are setup in the local STP keep.
Raises KeysNotFoundException if not found. | [
"Check",
"whether",
"the",
"keys",
"are",
"setup",
"in",
"the",
"local",
"STP",
"keep",
".",
"Raises",
"KeysNotFoundException",
"if",
"not",
"found",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3478-L3484 | train | 229,160 |
hyperledger/indy-plenum | plenum/server/node.py | Node.reportSuspiciousNodeEx | def reportSuspiciousNodeEx(self, ex: SuspiciousNode):
"""
Report suspicion on a node on the basis of an exception
"""
self.reportSuspiciousNode(ex.node, ex.reason, ex.code, ex.offendingMsg) | python | def reportSuspiciousNodeEx(self, ex: SuspiciousNode):
"""
Report suspicion on a node on the basis of an exception
"""
self.reportSuspiciousNode(ex.node, ex.reason, ex.code, ex.offendingMsg) | [
"def",
"reportSuspiciousNodeEx",
"(",
"self",
",",
"ex",
":",
"SuspiciousNode",
")",
":",
"self",
".",
"reportSuspiciousNode",
"(",
"ex",
".",
"node",
",",
"ex",
".",
"reason",
",",
"ex",
".",
"code",
",",
"ex",
".",
"offendingMsg",
")"
] | Report suspicion on a node on the basis of an exception | [
"Report",
"suspicion",
"on",
"a",
"node",
"on",
"the",
"basis",
"of",
"an",
"exception"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3492-L3496 | train | 229,161 |
hyperledger/indy-plenum | plenum/server/node.py | Node.reportSuspiciousNode | def reportSuspiciousNode(self,
nodeName: str,
reason=None,
code: int = None,
offendingMsg=None):
"""
Report suspicion on a node and add it to this node's blacklist.
:param nodeName: name of the node to report suspicion on
:param reason: the reason for suspicion
"""
logger.warning("{} raised suspicion on node {} for {}; suspicion code "
"is {}".format(self, nodeName, reason, code))
# TODO need a more general solution here
# TODO: Should not blacklist client on a single InvalidSignature.
# Should track if a lot of requests with incorrect signatures have been
# made in a short amount of time, only then blacklist client.
# if code == InvalidSignature.code:
# self.blacklistNode(nodeName,
# reason=InvalidSignature.reason,
# code=InvalidSignature.code)
# TODO: Consider blacklisting nodes again.
# if code in self.suspicions:
# self.blacklistNode(nodeName,
# reason=self.suspicions[code],
# code=code)
if code in (s.code for s in (Suspicions.PPR_DIGEST_WRONG,
Suspicions.PPR_REJECT_WRONG,
Suspicions.PPR_TXN_WRONG,
Suspicions.PPR_STATE_WRONG,
Suspicions.PPR_PLUGIN_EXCEPTION,
Suspicions.PPR_SUB_SEQ_NO_WRONG,
Suspicions.PPR_NOT_FINAL,
Suspicions.PPR_WITH_ORDERED_REQUEST,
Suspicions.PPR_AUDIT_TXN_ROOT_HASH_WRONG,
Suspicions.PPR_BLS_MULTISIG_WRONG,
Suspicions.PPR_TIME_WRONG,
)):
logger.display('{}{} got one of primary suspicions codes {}'.format(VIEW_CHANGE_PREFIX, self, code))
self.view_changer.on_suspicious_primary(Suspicions.get_by_code(code))
if offendingMsg:
self.discard(offendingMsg, reason, logger.debug) | python | def reportSuspiciousNode(self,
nodeName: str,
reason=None,
code: int = None,
offendingMsg=None):
"""
Report suspicion on a node and add it to this node's blacklist.
:param nodeName: name of the node to report suspicion on
:param reason: the reason for suspicion
"""
logger.warning("{} raised suspicion on node {} for {}; suspicion code "
"is {}".format(self, nodeName, reason, code))
# TODO need a more general solution here
# TODO: Should not blacklist client on a single InvalidSignature.
# Should track if a lot of requests with incorrect signatures have been
# made in a short amount of time, only then blacklist client.
# if code == InvalidSignature.code:
# self.blacklistNode(nodeName,
# reason=InvalidSignature.reason,
# code=InvalidSignature.code)
# TODO: Consider blacklisting nodes again.
# if code in self.suspicions:
# self.blacklistNode(nodeName,
# reason=self.suspicions[code],
# code=code)
if code in (s.code for s in (Suspicions.PPR_DIGEST_WRONG,
Suspicions.PPR_REJECT_WRONG,
Suspicions.PPR_TXN_WRONG,
Suspicions.PPR_STATE_WRONG,
Suspicions.PPR_PLUGIN_EXCEPTION,
Suspicions.PPR_SUB_SEQ_NO_WRONG,
Suspicions.PPR_NOT_FINAL,
Suspicions.PPR_WITH_ORDERED_REQUEST,
Suspicions.PPR_AUDIT_TXN_ROOT_HASH_WRONG,
Suspicions.PPR_BLS_MULTISIG_WRONG,
Suspicions.PPR_TIME_WRONG,
)):
logger.display('{}{} got one of primary suspicions codes {}'.format(VIEW_CHANGE_PREFIX, self, code))
self.view_changer.on_suspicious_primary(Suspicions.get_by_code(code))
if offendingMsg:
self.discard(offendingMsg, reason, logger.debug) | [
"def",
"reportSuspiciousNode",
"(",
"self",
",",
"nodeName",
":",
"str",
",",
"reason",
"=",
"None",
",",
"code",
":",
"int",
"=",
"None",
",",
"offendingMsg",
"=",
"None",
")",
":",
"logger",
".",
"warning",
"(",
"\"{} raised suspicion on node {} for {}; susp... | Report suspicion on a node and add it to this node's blacklist.
:param nodeName: name of the node to report suspicion on
:param reason: the reason for suspicion | [
"Report",
"suspicion",
"on",
"a",
"node",
"and",
"add",
"it",
"to",
"this",
"node",
"s",
"blacklist",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3498-L3543 | train | 229,162 |
hyperledger/indy-plenum | plenum/server/node.py | Node.reportSuspiciousClient | def reportSuspiciousClient(self, clientName: str, reason):
"""
Report suspicion on a client and add it to this node's blacklist.
:param clientName: name of the client to report suspicion on
:param reason: the reason for suspicion
"""
logger.warning("{} raised suspicion on client {} for {}"
.format(self, clientName, reason))
self.blacklistClient(clientName) | python | def reportSuspiciousClient(self, clientName: str, reason):
"""
Report suspicion on a client and add it to this node's blacklist.
:param clientName: name of the client to report suspicion on
:param reason: the reason for suspicion
"""
logger.warning("{} raised suspicion on client {} for {}"
.format(self, clientName, reason))
self.blacklistClient(clientName) | [
"def",
"reportSuspiciousClient",
"(",
"self",
",",
"clientName",
":",
"str",
",",
"reason",
")",
":",
"logger",
".",
"warning",
"(",
"\"{} raised suspicion on client {} for {}\"",
".",
"format",
"(",
"self",
",",
"clientName",
",",
"reason",
")",
")",
"self",
... | Report suspicion on a client and add it to this node's blacklist.
:param clientName: name of the client to report suspicion on
:param reason: the reason for suspicion | [
"Report",
"suspicion",
"on",
"a",
"client",
"and",
"add",
"it",
"to",
"this",
"node",
"s",
"blacklist",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3545-L3554 | train | 229,163 |
hyperledger/indy-plenum | plenum/server/node.py | Node.blacklistClient | def blacklistClient(self, clientName: str,
reason: str = None, code: int = None):
"""
Add the client specified by `clientName` to this node's blacklist
"""
msg = "{} blacklisting client {}".format(self, clientName)
if reason:
msg += " for reason {}".format(reason)
logger.display(msg)
self.clientBlacklister.blacklist(clientName) | python | def blacklistClient(self, clientName: str,
reason: str = None, code: int = None):
"""
Add the client specified by `clientName` to this node's blacklist
"""
msg = "{} blacklisting client {}".format(self, clientName)
if reason:
msg += " for reason {}".format(reason)
logger.display(msg)
self.clientBlacklister.blacklist(clientName) | [
"def",
"blacklistClient",
"(",
"self",
",",
"clientName",
":",
"str",
",",
"reason",
":",
"str",
"=",
"None",
",",
"code",
":",
"int",
"=",
"None",
")",
":",
"msg",
"=",
"\"{} blacklisting client {}\"",
".",
"format",
"(",
"self",
",",
"clientName",
")",... | Add the client specified by `clientName` to this node's blacklist | [
"Add",
"the",
"client",
"specified",
"by",
"clientName",
"to",
"this",
"node",
"s",
"blacklist"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3565-L3574 | train | 229,164 |
hyperledger/indy-plenum | plenum/server/node.py | Node.blacklistNode | def blacklistNode(self, nodeName: str, reason: str = None, code: int = None):
"""
Add the node specified by `nodeName` to this node's blacklist
"""
msg = "{} blacklisting node {}".format(self, nodeName)
if reason:
msg += " for reason {}".format(reason)
if code:
msg += " for code {}".format(code)
logger.display(msg)
self.nodeBlacklister.blacklist(nodeName) | python | def blacklistNode(self, nodeName: str, reason: str = None, code: int = None):
"""
Add the node specified by `nodeName` to this node's blacklist
"""
msg = "{} blacklisting node {}".format(self, nodeName)
if reason:
msg += " for reason {}".format(reason)
if code:
msg += " for code {}".format(code)
logger.display(msg)
self.nodeBlacklister.blacklist(nodeName) | [
"def",
"blacklistNode",
"(",
"self",
",",
"nodeName",
":",
"str",
",",
"reason",
":",
"str",
"=",
"None",
",",
"code",
":",
"int",
"=",
"None",
")",
":",
"msg",
"=",
"\"{} blacklisting node {}\"",
".",
"format",
"(",
"self",
",",
"nodeName",
")",
"if",... | Add the node specified by `nodeName` to this node's blacklist | [
"Add",
"the",
"node",
"specified",
"by",
"nodeName",
"to",
"this",
"node",
"s",
"blacklist"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3585-L3595 | train | 229,165 |
hyperledger/indy-plenum | plenum/server/node.py | Node.logstats | def logstats(self):
"""
Print the node's current statistics to log.
"""
lines = [
"node {} current stats".format(self),
"--------------------------------------------------------",
"node inbox size : {}".format(len(self.nodeInBox)),
"client inbox size : {}".format(len(self.clientInBox)),
"age (seconds) : {}".format(time.time() - self.created),
"next check for reconnect: {}".format(time.perf_counter() -
self.nodestack.nextCheck),
"node connections : {}".format(self.nodestack.conns),
"f : {}".format(self.f),
"master instance : {}".format(self.instances.masterId),
"replicas : {}".format(len(self.replicas)),
"view no : {}".format(self.viewNo),
"rank : {}".format(self.rank),
"msgs to replicas : {}".format(self.replicas.sum_inbox_len),
"msgs to view changer : {}".format(len(self.msgsToViewChanger)),
"action queue : {} {}".format(len(self.actionQueue),
id(self.actionQueue)),
"action queue stash : {} {}".format(len(self.aqStash),
id(self.aqStash)),
]
logger.info("\n".join(lines), extra={"cli": False}) | python | def logstats(self):
"""
Print the node's current statistics to log.
"""
lines = [
"node {} current stats".format(self),
"--------------------------------------------------------",
"node inbox size : {}".format(len(self.nodeInBox)),
"client inbox size : {}".format(len(self.clientInBox)),
"age (seconds) : {}".format(time.time() - self.created),
"next check for reconnect: {}".format(time.perf_counter() -
self.nodestack.nextCheck),
"node connections : {}".format(self.nodestack.conns),
"f : {}".format(self.f),
"master instance : {}".format(self.instances.masterId),
"replicas : {}".format(len(self.replicas)),
"view no : {}".format(self.viewNo),
"rank : {}".format(self.rank),
"msgs to replicas : {}".format(self.replicas.sum_inbox_len),
"msgs to view changer : {}".format(len(self.msgsToViewChanger)),
"action queue : {} {}".format(len(self.actionQueue),
id(self.actionQueue)),
"action queue stash : {} {}".format(len(self.aqStash),
id(self.aqStash)),
]
logger.info("\n".join(lines), extra={"cli": False}) | [
"def",
"logstats",
"(",
"self",
")",
":",
"lines",
"=",
"[",
"\"node {} current stats\"",
".",
"format",
"(",
"self",
")",
",",
"\"--------------------------------------------------------\"",
",",
"\"node inbox size : {}\"",
".",
"format",
"(",
"len",
"(",
"se... | Print the node's current statistics to log. | [
"Print",
"the",
"node",
"s",
"current",
"statistics",
"to",
"log",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3685-L3711 | train | 229,166 |
hyperledger/indy-plenum | plenum/server/node.py | Node.logNodeInfo | def logNodeInfo(self):
"""
Print the node's info to log for the REST backend to read.
"""
self.nodeInfo['data'] = self.collectNodeInfo()
with closing(open(os.path.join(self.ledger_dir, 'node_info'), 'w')) \
as logNodeInfoFile:
logNodeInfoFile.write(json.dumps(self.nodeInfo['data'])) | python | def logNodeInfo(self):
"""
Print the node's info to log for the REST backend to read.
"""
self.nodeInfo['data'] = self.collectNodeInfo()
with closing(open(os.path.join(self.ledger_dir, 'node_info'), 'w')) \
as logNodeInfoFile:
logNodeInfoFile.write(json.dumps(self.nodeInfo['data'])) | [
"def",
"logNodeInfo",
"(",
"self",
")",
":",
"self",
".",
"nodeInfo",
"[",
"'data'",
"]",
"=",
"self",
".",
"collectNodeInfo",
"(",
")",
"with",
"closing",
"(",
"open",
"(",
"os",
".",
"path",
".",
"join",
"(",
"self",
".",
"ledger_dir",
",",
"'node_... | Print the node's info to log for the REST backend to read. | [
"Print",
"the",
"node",
"s",
"info",
"to",
"log",
"for",
"the",
"REST",
"backend",
"to",
"read",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/node.py#L3738-L3746 | train | 229,167 |
hyperledger/indy-plenum | plenum/common/perf_util.py | get_collection_sizes | def get_collection_sizes(obj, collections: Optional[Tuple]=None,
get_only_non_empty=False):
"""
Iterates over `collections` of the gives object and gives its byte size
and number of items in collection
"""
from pympler import asizeof
collections = collections or (list, dict, set, deque, abc.Sized)
if not isinstance(collections, tuple):
collections = tuple(collections)
result = []
for attr_name in dir(obj):
attr = getattr(obj, attr_name)
if isinstance(attr, collections) and (
not get_only_non_empty or len(attr) > 0):
result.append(
(attr_name, len(attr), asizeof.asizeof(attr, detail=1)))
return result | python | def get_collection_sizes(obj, collections: Optional[Tuple]=None,
get_only_non_empty=False):
"""
Iterates over `collections` of the gives object and gives its byte size
and number of items in collection
"""
from pympler import asizeof
collections = collections or (list, dict, set, deque, abc.Sized)
if not isinstance(collections, tuple):
collections = tuple(collections)
result = []
for attr_name in dir(obj):
attr = getattr(obj, attr_name)
if isinstance(attr, collections) and (
not get_only_non_empty or len(attr) > 0):
result.append(
(attr_name, len(attr), asizeof.asizeof(attr, detail=1)))
return result | [
"def",
"get_collection_sizes",
"(",
"obj",
",",
"collections",
":",
"Optional",
"[",
"Tuple",
"]",
"=",
"None",
",",
"get_only_non_empty",
"=",
"False",
")",
":",
"from",
"pympler",
"import",
"asizeof",
"collections",
"=",
"collections",
"or",
"(",
"list",
"... | Iterates over `collections` of the gives object and gives its byte size
and number of items in collection | [
"Iterates",
"over",
"collections",
"of",
"the",
"gives",
"object",
"and",
"gives",
"its",
"byte",
"size",
"and",
"number",
"of",
"items",
"in",
"collection"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/perf_util.py#L52-L70 | train | 229,168 |
hyperledger/indy-plenum | ledger/error.py | returns_true_or_raises | def returns_true_or_raises(f):
"""A safety net.
Decorator for functions that are only allowed to return True or raise
an exception.
Args:
f: A function whose only expected return value is True.
Returns:
A wrapped functions whose guaranteed only return value is True.
"""
@functools.wraps(f)
def wrapped(*args, **kwargs):
ret = f(*args, **kwargs)
if ret is not True:
raise RuntimeError("Unexpected return value %r" % ret)
return True
return wrapped | python | def returns_true_or_raises(f):
"""A safety net.
Decorator for functions that are only allowed to return True or raise
an exception.
Args:
f: A function whose only expected return value is True.
Returns:
A wrapped functions whose guaranteed only return value is True.
"""
@functools.wraps(f)
def wrapped(*args, **kwargs):
ret = f(*args, **kwargs)
if ret is not True:
raise RuntimeError("Unexpected return value %r" % ret)
return True
return wrapped | [
"def",
"returns_true_or_raises",
"(",
"f",
")",
":",
"@",
"functools",
".",
"wraps",
"(",
"f",
")",
"def",
"wrapped",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
":",
"ret",
"=",
"f",
"(",
"*",
"args",
",",
"*",
"*",
"kwargs",
")",
"if",
"r... | A safety net.
Decorator for functions that are only allowed to return True or raise
an exception.
Args:
f: A function whose only expected return value is True.
Returns:
A wrapped functions whose guaranteed only return value is True. | [
"A",
"safety",
"net",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/ledger/error.py#L126-L144 | train | 229,169 |
hyperledger/indy-plenum | plenum/server/instances.py | Instances.backupIds | def backupIds(self) -> Sequence[int]:
"""
Return the list of replicas that don't belong to the master protocol
instance
"""
return [id for id in self.started.keys() if id != 0] | python | def backupIds(self) -> Sequence[int]:
"""
Return the list of replicas that don't belong to the master protocol
instance
"""
return [id for id in self.started.keys() if id != 0] | [
"def",
"backupIds",
"(",
"self",
")",
"->",
"Sequence",
"[",
"int",
"]",
":",
"return",
"[",
"id",
"for",
"id",
"in",
"self",
".",
"started",
".",
"keys",
"(",
")",
"if",
"id",
"!=",
"0",
"]"
] | Return the list of replicas that don't belong to the master protocol
instance | [
"Return",
"the",
"list",
"of",
"replicas",
"that",
"don",
"t",
"belong",
"to",
"the",
"master",
"protocol",
"instance"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/instances.py#L37-L42 | train | 229,170 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger._hasViewChangeQuorum | def _hasViewChangeQuorum(self):
# This method should just be present for master instance.
"""
Checks whether n-f nodes completed view change and whether one
of them is the next primary
"""
num_of_ready_nodes = len(self._view_change_done)
diff = self.quorum - num_of_ready_nodes
if diff > 0:
logger.info('{} needs {} ViewChangeDone messages'.format(self, diff))
return False
logger.info("{} got view change quorum ({} >= {})".
format(self.name, num_of_ready_nodes, self.quorum))
return True | python | def _hasViewChangeQuorum(self):
# This method should just be present for master instance.
"""
Checks whether n-f nodes completed view change and whether one
of them is the next primary
"""
num_of_ready_nodes = len(self._view_change_done)
diff = self.quorum - num_of_ready_nodes
if diff > 0:
logger.info('{} needs {} ViewChangeDone messages'.format(self, diff))
return False
logger.info("{} got view change quorum ({} >= {})".
format(self.name, num_of_ready_nodes, self.quorum))
return True | [
"def",
"_hasViewChangeQuorum",
"(",
"self",
")",
":",
"# This method should just be present for master instance.",
"num_of_ready_nodes",
"=",
"len",
"(",
"self",
".",
"_view_change_done",
")",
"diff",
"=",
"self",
".",
"quorum",
"-",
"num_of_ready_nodes",
"if",
"diff",
... | Checks whether n-f nodes completed view change and whether one
of them is the next primary | [
"Checks",
"whether",
"n",
"-",
"f",
"nodes",
"completed",
"view",
"change",
"and",
"whether",
"one",
"of",
"them",
"is",
"the",
"next",
"primary"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L234-L248 | train | 229,171 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger.process_instance_change_msg | def process_instance_change_msg(self, instChg: InstanceChange, frm: str) -> None:
"""
Validate and process an instance change request.
:param instChg: the instance change request
:param frm: the name of the node that sent this `msg`
"""
if frm not in self.provider.connected_nodes():
self.provider.discard(
instChg,
"received instance change request: {} from {} "
"which is not in connected list: {}".format(
instChg, frm, self.provider.connected_nodes()), logger.info)
return
logger.info("{} received instance change request: {} from {}".format(self, instChg, frm))
# TODO: add sender to blacklist?
if not isinstance(instChg.viewNo, int):
self.provider.discard(
instChg, "{}field view_no has incorrect type: {}".format(
VIEW_CHANGE_PREFIX, type(instChg.viewNo)))
elif instChg.viewNo <= self.view_no:
self.provider.discard(
instChg,
"Received instance change request with view no {} "
"which is not more than its view no {}".format(
instChg.viewNo, self.view_no), logger.info)
else:
# Record instance changes for views but send instance change
# only when found master to be degraded. if quorum of view changes
# found then change view even if master not degraded
self._on_verified_instance_change_msg(instChg, frm)
if self.instance_changes.has_inst_chng_from(instChg.viewNo, self.name):
logger.info("{} received instance change message {} but has already "
"sent an instance change message".format(self, instChg))
elif not self.provider.is_master_degraded():
logger.info("{} received instance change message {} but did not "
"find the master to be slow".format(self, instChg))
else:
logger.display("{}{} found master degraded after receiving instance change"
" message from {}".format(VIEW_CHANGE_PREFIX, self, frm))
self.sendInstanceChange(instChg.viewNo) | python | def process_instance_change_msg(self, instChg: InstanceChange, frm: str) -> None:
"""
Validate and process an instance change request.
:param instChg: the instance change request
:param frm: the name of the node that sent this `msg`
"""
if frm not in self.provider.connected_nodes():
self.provider.discard(
instChg,
"received instance change request: {} from {} "
"which is not in connected list: {}".format(
instChg, frm, self.provider.connected_nodes()), logger.info)
return
logger.info("{} received instance change request: {} from {}".format(self, instChg, frm))
# TODO: add sender to blacklist?
if not isinstance(instChg.viewNo, int):
self.provider.discard(
instChg, "{}field view_no has incorrect type: {}".format(
VIEW_CHANGE_PREFIX, type(instChg.viewNo)))
elif instChg.viewNo <= self.view_no:
self.provider.discard(
instChg,
"Received instance change request with view no {} "
"which is not more than its view no {}".format(
instChg.viewNo, self.view_no), logger.info)
else:
# Record instance changes for views but send instance change
# only when found master to be degraded. if quorum of view changes
# found then change view even if master not degraded
self._on_verified_instance_change_msg(instChg, frm)
if self.instance_changes.has_inst_chng_from(instChg.viewNo, self.name):
logger.info("{} received instance change message {} but has already "
"sent an instance change message".format(self, instChg))
elif not self.provider.is_master_degraded():
logger.info("{} received instance change message {} but did not "
"find the master to be slow".format(self, instChg))
else:
logger.display("{}{} found master degraded after receiving instance change"
" message from {}".format(VIEW_CHANGE_PREFIX, self, frm))
self.sendInstanceChange(instChg.viewNo) | [
"def",
"process_instance_change_msg",
"(",
"self",
",",
"instChg",
":",
"InstanceChange",
",",
"frm",
":",
"str",
")",
"->",
"None",
":",
"if",
"frm",
"not",
"in",
"self",
".",
"provider",
".",
"connected_nodes",
"(",
")",
":",
"self",
".",
"provider",
"... | Validate and process an instance change request.
:param instChg: the instance change request
:param frm: the name of the node that sent this `msg` | [
"Validate",
"and",
"process",
"an",
"instance",
"change",
"request",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L373-L416 | train | 229,172 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger.process_vchd_msg | def process_vchd_msg(self, msg: ViewChangeDone, sender: str) -> bool:
"""
Processes ViewChangeDone messages. Once n-f messages have been
received, decides on a primary for specific replica.
:param msg: ViewChangeDone message
:param sender: the name of the node from which this message was sent
"""
logger.info("{}'s primary selector started processing of ViewChangeDone msg from {} : {}".
format(self.name, sender, msg))
view_no = msg.viewNo
if self.view_no != view_no:
self.provider.discard(msg, '{} got Primary from {} for view no {} '
'whereas current view no is {}'.
format(self, sender, view_no, self.view_no),
logMethod=logger.info)
return False
new_primary_name = msg.name
if new_primary_name == self.previous_master_primary:
self.provider.discard(msg, '{} got Primary from {} for {} who was primary of '
'master in previous view too'.
format(self, sender, new_primary_name),
logMethod=logger.info)
return False
# Since a node can send ViewChangeDone more than one time
self._on_verified_view_change_done_msg(msg, sender)
# TODO why do we check that after the message tracking
if self.provider.has_primary():
self.provider.discard(msg, "it already decided primary which is {}".
format(self.provider.current_primary_name()), logger.info)
return False
self._start_selection() | python | def process_vchd_msg(self, msg: ViewChangeDone, sender: str) -> bool:
"""
Processes ViewChangeDone messages. Once n-f messages have been
received, decides on a primary for specific replica.
:param msg: ViewChangeDone message
:param sender: the name of the node from which this message was sent
"""
logger.info("{}'s primary selector started processing of ViewChangeDone msg from {} : {}".
format(self.name, sender, msg))
view_no = msg.viewNo
if self.view_no != view_no:
self.provider.discard(msg, '{} got Primary from {} for view no {} '
'whereas current view no is {}'.
format(self, sender, view_no, self.view_no),
logMethod=logger.info)
return False
new_primary_name = msg.name
if new_primary_name == self.previous_master_primary:
self.provider.discard(msg, '{} got Primary from {} for {} who was primary of '
'master in previous view too'.
format(self, sender, new_primary_name),
logMethod=logger.info)
return False
# Since a node can send ViewChangeDone more than one time
self._on_verified_view_change_done_msg(msg, sender)
# TODO why do we check that after the message tracking
if self.provider.has_primary():
self.provider.discard(msg, "it already decided primary which is {}".
format(self.provider.current_primary_name()), logger.info)
return False
self._start_selection() | [
"def",
"process_vchd_msg",
"(",
"self",
",",
"msg",
":",
"ViewChangeDone",
",",
"sender",
":",
"str",
")",
"->",
"bool",
":",
"logger",
".",
"info",
"(",
"\"{}'s primary selector started processing of ViewChangeDone msg from {} : {}\"",
".",
"format",
"(",
"self",
"... | Processes ViewChangeDone messages. Once n-f messages have been
received, decides on a primary for specific replica.
:param msg: ViewChangeDone message
:param sender: the name of the node from which this message was sent | [
"Processes",
"ViewChangeDone",
"messages",
".",
"Once",
"n",
"-",
"f",
"messages",
"have",
"been",
"received",
"decides",
"on",
"a",
"primary",
"for",
"specific",
"replica",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L418-L452 | train | 229,173 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger.sendInstanceChange | def sendInstanceChange(self, view_no: int,
suspicion=Suspicions.PRIMARY_DEGRADED):
"""
Broadcast an instance change request to all the remaining nodes
:param view_no: the view number when the instance change is requested
"""
# If not found any sent instance change messages in last
# `ViewChangeWindowSize` seconds or the last sent instance change
# message was sent long enough ago then instance change message can be
# sent otherwise no.
canSendInsChange, cooldown = self.insChngThrottler.acquire()
if canSendInsChange:
logger.info(
"{}{} sending an instance change with view_no {}"
" since {}".format(
VIEW_CHANGE_PREFIX,
self,
view_no,
suspicion.reason))
logger.info("{}{} metrics for monitor: {}"
.format(MONITORING_PREFIX, self,
self.provider.pretty_metrics()))
msg = self._create_instance_change_msg(view_no, suspicion.code)
self.send(msg)
# record instance change vote for self and try to change the view
# if quorum is reached
self._on_verified_instance_change_msg(msg, self.name)
else:
logger.info("{} cannot send instance change sooner then {} seconds".format(self, cooldown)) | python | def sendInstanceChange(self, view_no: int,
suspicion=Suspicions.PRIMARY_DEGRADED):
"""
Broadcast an instance change request to all the remaining nodes
:param view_no: the view number when the instance change is requested
"""
# If not found any sent instance change messages in last
# `ViewChangeWindowSize` seconds or the last sent instance change
# message was sent long enough ago then instance change message can be
# sent otherwise no.
canSendInsChange, cooldown = self.insChngThrottler.acquire()
if canSendInsChange:
logger.info(
"{}{} sending an instance change with view_no {}"
" since {}".format(
VIEW_CHANGE_PREFIX,
self,
view_no,
suspicion.reason))
logger.info("{}{} metrics for monitor: {}"
.format(MONITORING_PREFIX, self,
self.provider.pretty_metrics()))
msg = self._create_instance_change_msg(view_no, suspicion.code)
self.send(msg)
# record instance change vote for self and try to change the view
# if quorum is reached
self._on_verified_instance_change_msg(msg, self.name)
else:
logger.info("{} cannot send instance change sooner then {} seconds".format(self, cooldown)) | [
"def",
"sendInstanceChange",
"(",
"self",
",",
"view_no",
":",
"int",
",",
"suspicion",
"=",
"Suspicions",
".",
"PRIMARY_DEGRADED",
")",
":",
"# If not found any sent instance change messages in last",
"# `ViewChangeWindowSize` seconds or the last sent instance change",
"# messag... | Broadcast an instance change request to all the remaining nodes
:param view_no: the view number when the instance change is requested | [
"Broadcast",
"an",
"instance",
"change",
"request",
"to",
"all",
"the",
"remaining",
"nodes"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L475-L505 | train | 229,174 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger._canViewChange | def _canViewChange(self, proposedViewNo: int) -> (bool, str):
"""
Return whether there's quorum for view change for the proposed view
number and its view is less than or equal to the proposed view
"""
msg = None
quorum = self.quorums.view_change.value
if not self.instance_changes.has_quorum(proposedViewNo, quorum):
msg = '{} has no quorum for view {}'.format(self, proposedViewNo)
elif not proposedViewNo > self.view_no:
msg = '{} is in higher view more than {}'.format(
self, proposedViewNo)
return not bool(msg), msg | python | def _canViewChange(self, proposedViewNo: int) -> (bool, str):
"""
Return whether there's quorum for view change for the proposed view
number and its view is less than or equal to the proposed view
"""
msg = None
quorum = self.quorums.view_change.value
if not self.instance_changes.has_quorum(proposedViewNo, quorum):
msg = '{} has no quorum for view {}'.format(self, proposedViewNo)
elif not proposedViewNo > self.view_no:
msg = '{} is in higher view more than {}'.format(
self, proposedViewNo)
return not bool(msg), msg | [
"def",
"_canViewChange",
"(",
"self",
",",
"proposedViewNo",
":",
"int",
")",
"->",
"(",
"bool",
",",
"str",
")",
":",
"msg",
"=",
"None",
"quorum",
"=",
"self",
".",
"quorums",
".",
"view_change",
".",
"value",
"if",
"not",
"self",
".",
"instance_chan... | Return whether there's quorum for view change for the proposed view
number and its view is less than or equal to the proposed view | [
"Return",
"whether",
"there",
"s",
"quorum",
"for",
"view",
"change",
"for",
"the",
"proposed",
"view",
"number",
"and",
"its",
"view",
"is",
"less",
"than",
"or",
"equal",
"to",
"the",
"proposed",
"view"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L548-L561 | train | 229,175 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger.start_view_change | def start_view_change(self, proposed_view_no: int, continue_vc=False):
"""
Trigger the view change process.
:param proposed_view_no: the new view number after view change.
"""
# TODO: consider moving this to pool manager
# TODO: view change is a special case, which can have different
# implementations - we need to make this logic pluggable
if self.pre_vc_strategy and (not continue_vc):
self.pre_view_change_in_progress = True
self.pre_vc_strategy.prepare_view_change(proposed_view_no)
return
elif self.pre_vc_strategy:
self.pre_vc_strategy.on_strategy_complete()
self.previous_view_no = self.view_no
self.view_no = proposed_view_no
self.pre_view_change_in_progress = False
self.view_change_in_progress = True
self.previous_master_primary = self.provider.current_primary_name()
self.set_defaults()
self._process_vcd_for_future_view()
self.initInsChngThrottling()
self.provider.notify_view_change_start()
self.provider.start_catchup() | python | def start_view_change(self, proposed_view_no: int, continue_vc=False):
"""
Trigger the view change process.
:param proposed_view_no: the new view number after view change.
"""
# TODO: consider moving this to pool manager
# TODO: view change is a special case, which can have different
# implementations - we need to make this logic pluggable
if self.pre_vc_strategy and (not continue_vc):
self.pre_view_change_in_progress = True
self.pre_vc_strategy.prepare_view_change(proposed_view_no)
return
elif self.pre_vc_strategy:
self.pre_vc_strategy.on_strategy_complete()
self.previous_view_no = self.view_no
self.view_no = proposed_view_no
self.pre_view_change_in_progress = False
self.view_change_in_progress = True
self.previous_master_primary = self.provider.current_primary_name()
self.set_defaults()
self._process_vcd_for_future_view()
self.initInsChngThrottling()
self.provider.notify_view_change_start()
self.provider.start_catchup() | [
"def",
"start_view_change",
"(",
"self",
",",
"proposed_view_no",
":",
"int",
",",
"continue_vc",
"=",
"False",
")",
":",
"# TODO: consider moving this to pool manager",
"# TODO: view change is a special case, which can have different",
"# implementations - we need to make this logic... | Trigger the view change process.
:param proposed_view_no: the new view number after view change. | [
"Trigger",
"the",
"view",
"change",
"process",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L563-L591 | train | 229,176 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger._verify_primary | def _verify_primary(self, new_primary, ledger_info):
"""
This method is called when sufficient number of ViewChangeDone
received and makes steps to switch to the new primary
"""
expected_primary = self.provider.next_primary_name()
if new_primary != expected_primary:
logger.error("{}{} expected next primary to be {}, but majority "
"declared {} instead for view {}"
.format(PRIMARY_SELECTION_PREFIX, self.name,
expected_primary, new_primary, self.view_no))
return False
self._primary_verified = True
return True | python | def _verify_primary(self, new_primary, ledger_info):
"""
This method is called when sufficient number of ViewChangeDone
received and makes steps to switch to the new primary
"""
expected_primary = self.provider.next_primary_name()
if new_primary != expected_primary:
logger.error("{}{} expected next primary to be {}, but majority "
"declared {} instead for view {}"
.format(PRIMARY_SELECTION_PREFIX, self.name,
expected_primary, new_primary, self.view_no))
return False
self._primary_verified = True
return True | [
"def",
"_verify_primary",
"(",
"self",
",",
"new_primary",
",",
"ledger_info",
")",
":",
"expected_primary",
"=",
"self",
".",
"provider",
".",
"next_primary_name",
"(",
")",
"if",
"new_primary",
"!=",
"expected_primary",
":",
"logger",
".",
"error",
"(",
"\"{... | This method is called when sufficient number of ViewChangeDone
received and makes steps to switch to the new primary | [
"This",
"method",
"is",
"called",
"when",
"sufficient",
"number",
"of",
"ViewChangeDone",
"received",
"and",
"makes",
"steps",
"to",
"switch",
"to",
"the",
"new",
"primary"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L691-L705 | train | 229,177 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger._send_view_change_done_message | def _send_view_change_done_message(self):
"""
Sends ViewChangeDone message to other protocol participants
"""
new_primary_name = self.provider.next_primary_name()
ledger_summary = self.provider.ledger_summary()
message = ViewChangeDone(self.view_no,
new_primary_name,
ledger_summary)
logger.info("{} is sending ViewChangeDone msg to all : {}".format(self, message))
self.send(message)
self._on_verified_view_change_done_msg(message, self.name) | python | def _send_view_change_done_message(self):
"""
Sends ViewChangeDone message to other protocol participants
"""
new_primary_name = self.provider.next_primary_name()
ledger_summary = self.provider.ledger_summary()
message = ViewChangeDone(self.view_no,
new_primary_name,
ledger_summary)
logger.info("{} is sending ViewChangeDone msg to all : {}".format(self, message))
self.send(message)
self._on_verified_view_change_done_msg(message, self.name) | [
"def",
"_send_view_change_done_message",
"(",
"self",
")",
":",
"new_primary_name",
"=",
"self",
".",
"provider",
".",
"next_primary_name",
"(",
")",
"ledger_summary",
"=",
"self",
".",
"provider",
".",
"ledger_summary",
"(",
")",
"message",
"=",
"ViewChangeDone",... | Sends ViewChangeDone message to other protocol participants | [
"Sends",
"ViewChangeDone",
"message",
"to",
"other",
"protocol",
"participants"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L708-L721 | train | 229,178 |
hyperledger/indy-plenum | plenum/server/view_change/view_changer.py | ViewChanger.get_msgs_for_lagged_nodes | def get_msgs_for_lagged_nodes(self) -> List[ViewChangeDone]:
# Should not return a list, only done for compatibility with interface
"""
Returns the last accepted `ViewChangeDone` message.
If no view change has happened returns ViewChangeDone
with view no 0 to a newly joined node
"""
# TODO: Consider a case where more than one node joins immediately,
# then one of the node might not have an accepted
# ViewChangeDone message
messages = []
accepted = self._accepted_view_change_done_message
if accepted:
messages.append(ViewChangeDone(self.last_completed_view_no, *accepted))
elif self.name in self._view_change_done:
messages.append(ViewChangeDone(self.last_completed_view_no,
*self._view_change_done[self.name]))
else:
logger.info('{} has no ViewChangeDone message to send for view {}'.
format(self, self.view_no))
return messages | python | def get_msgs_for_lagged_nodes(self) -> List[ViewChangeDone]:
# Should not return a list, only done for compatibility with interface
"""
Returns the last accepted `ViewChangeDone` message.
If no view change has happened returns ViewChangeDone
with view no 0 to a newly joined node
"""
# TODO: Consider a case where more than one node joins immediately,
# then one of the node might not have an accepted
# ViewChangeDone message
messages = []
accepted = self._accepted_view_change_done_message
if accepted:
messages.append(ViewChangeDone(self.last_completed_view_no, *accepted))
elif self.name in self._view_change_done:
messages.append(ViewChangeDone(self.last_completed_view_no,
*self._view_change_done[self.name]))
else:
logger.info('{} has no ViewChangeDone message to send for view {}'.
format(self, self.view_no))
return messages | [
"def",
"get_msgs_for_lagged_nodes",
"(",
"self",
")",
"->",
"List",
"[",
"ViewChangeDone",
"]",
":",
"# Should not return a list, only done for compatibility with interface",
"# TODO: Consider a case where more than one node joins immediately,",
"# then one of the node might not have an ac... | Returns the last accepted `ViewChangeDone` message.
If no view change has happened returns ViewChangeDone
with view no 0 to a newly joined node | [
"Returns",
"the",
"last",
"accepted",
"ViewChangeDone",
"message",
".",
"If",
"no",
"view",
"change",
"has",
"happened",
"returns",
"ViewChangeDone",
"with",
"view",
"no",
"0",
"to",
"a",
"newly",
"joined",
"node"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/view_change/view_changer.py#L724-L744 | train | 229,179 |
hyperledger/indy-plenum | plenum/common/messages/fields.py | FieldBase.validate | def validate(self, val):
"""
Performs basic validation of field value and then passes it for
specific validation.
:param val: field value to validate
:return: error message or None
"""
if self.nullable and val is None:
return
type_er = self.__type_check(val)
if type_er:
return type_er
spec_err = self._specific_validation(val)
if spec_err:
return spec_err | python | def validate(self, val):
"""
Performs basic validation of field value and then passes it for
specific validation.
:param val: field value to validate
:return: error message or None
"""
if self.nullable and val is None:
return
type_er = self.__type_check(val)
if type_er:
return type_er
spec_err = self._specific_validation(val)
if spec_err:
return spec_err | [
"def",
"validate",
"(",
"self",
",",
"val",
")",
":",
"if",
"self",
".",
"nullable",
"and",
"val",
"is",
"None",
":",
"return",
"type_er",
"=",
"self",
".",
"__type_check",
"(",
"val",
")",
"if",
"type_er",
":",
"return",
"type_er",
"spec_err",
"=",
... | Performs basic validation of field value and then passes it for
specific validation.
:param val: field value to validate
:return: error message or None | [
"Performs",
"basic",
"validation",
"of",
"field",
"value",
"and",
"then",
"passes",
"it",
"for",
"specific",
"validation",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/messages/fields.py#L51-L68 | train | 229,180 |
hyperledger/indy-plenum | plenum/common/signer_did.py | DidSigner.sign | def sign(self, msg: Dict) -> Dict:
"""
Return a signature for the given message.
"""
ser = serialize_msg_for_signing(msg, topLevelKeysToIgnore=[f.SIG.nm])
bsig = self.naclSigner.signature(ser)
sig = base58.b58encode(bsig).decode("utf-8")
return sig | python | def sign(self, msg: Dict) -> Dict:
"""
Return a signature for the given message.
"""
ser = serialize_msg_for_signing(msg, topLevelKeysToIgnore=[f.SIG.nm])
bsig = self.naclSigner.signature(ser)
sig = base58.b58encode(bsig).decode("utf-8")
return sig | [
"def",
"sign",
"(",
"self",
",",
"msg",
":",
"Dict",
")",
"->",
"Dict",
":",
"ser",
"=",
"serialize_msg_for_signing",
"(",
"msg",
",",
"topLevelKeysToIgnore",
"=",
"[",
"f",
".",
"SIG",
".",
"nm",
"]",
")",
"bsig",
"=",
"self",
".",
"naclSigner",
"."... | Return a signature for the given message. | [
"Return",
"a",
"signature",
"for",
"the",
"given",
"message",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/common/signer_did.py#L122-L129 | train | 229,181 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.lastPrePrepareSeqNo | def lastPrePrepareSeqNo(self, n):
"""
This will _lastPrePrepareSeqNo to values greater than its previous
values else it will not. To forcefully override as in case of `revert`,
directly set `self._lastPrePrepareSeqNo`
"""
if n > self._lastPrePrepareSeqNo:
self._lastPrePrepareSeqNo = n
else:
self.logger.debug(
'{} cannot set lastPrePrepareSeqNo to {} as its '
'already {}'.format(
self, n, self._lastPrePrepareSeqNo)) | python | def lastPrePrepareSeqNo(self, n):
"""
This will _lastPrePrepareSeqNo to values greater than its previous
values else it will not. To forcefully override as in case of `revert`,
directly set `self._lastPrePrepareSeqNo`
"""
if n > self._lastPrePrepareSeqNo:
self._lastPrePrepareSeqNo = n
else:
self.logger.debug(
'{} cannot set lastPrePrepareSeqNo to {} as its '
'already {}'.format(
self, n, self._lastPrePrepareSeqNo)) | [
"def",
"lastPrePrepareSeqNo",
"(",
"self",
",",
"n",
")",
":",
"if",
"n",
">",
"self",
".",
"_lastPrePrepareSeqNo",
":",
"self",
".",
"_lastPrePrepareSeqNo",
"=",
"n",
"else",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"'{} cannot set lastPrePrepareSeqNo t... | This will _lastPrePrepareSeqNo to values greater than its previous
values else it will not. To forcefully override as in case of `revert`,
directly set `self._lastPrePrepareSeqNo` | [
"This",
"will",
"_lastPrePrepareSeqNo",
"to",
"values",
"greater",
"than",
"its",
"previous",
"values",
"else",
"it",
"will",
"not",
".",
"To",
"forcefully",
"override",
"as",
"in",
"case",
"of",
"revert",
"directly",
"set",
"self",
".",
"_lastPrePrepareSeqNo"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L515-L527 | train | 229,182 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.primaryName | def primaryName(self, value: Optional[str]) -> None:
"""
Set the value of isPrimary.
:param value: the value to set isPrimary to
"""
if value is not None:
self.warned_no_primary = False
self.primaryNames[self.viewNo] = value
self.compact_primary_names()
if value != self._primaryName:
self._primaryName = value
self.logger.info("{} setting primaryName for view no {} to: {}".
format(self, self.viewNo, value))
if value is None:
# Since the GC needs to happen after a primary has been
# decided.
return
self._gc_before_new_view()
if self.__should_reset_watermarks_before_new_view():
self._reset_watermarks_before_new_view() | python | def primaryName(self, value: Optional[str]) -> None:
"""
Set the value of isPrimary.
:param value: the value to set isPrimary to
"""
if value is not None:
self.warned_no_primary = False
self.primaryNames[self.viewNo] = value
self.compact_primary_names()
if value != self._primaryName:
self._primaryName = value
self.logger.info("{} setting primaryName for view no {} to: {}".
format(self, self.viewNo, value))
if value is None:
# Since the GC needs to happen after a primary has been
# decided.
return
self._gc_before_new_view()
if self.__should_reset_watermarks_before_new_view():
self._reset_watermarks_before_new_view() | [
"def",
"primaryName",
"(",
"self",
",",
"value",
":",
"Optional",
"[",
"str",
"]",
")",
"->",
"None",
":",
"if",
"value",
"is",
"not",
"None",
":",
"self",
".",
"warned_no_primary",
"=",
"False",
"self",
".",
"primaryNames",
"[",
"self",
".",
"viewNo",... | Set the value of isPrimary.
:param value: the value to set isPrimary to | [
"Set",
"the",
"value",
"of",
"isPrimary",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L598-L618 | train | 229,183 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.get_lowest_probable_prepared_certificate_in_view | def get_lowest_probable_prepared_certificate_in_view(
self, view_no) -> Optional[int]:
"""
Return lowest pp_seq_no of the view for which can be prepared but
choose from unprocessed PRE-PREPAREs and PREPAREs.
"""
# TODO: Naive implementation, dont need to iterate over the complete
# data structures, fix this later
seq_no_pp = SortedList() # pp_seq_no of PRE-PREPAREs
# pp_seq_no of PREPAREs with count of PREPAREs for each
seq_no_p = set()
for (v, p) in self.prePreparesPendingPrevPP:
if v == view_no:
seq_no_pp.add(p)
if v > view_no:
break
for (v, p), pr in self.preparesWaitingForPrePrepare.items():
if v == view_no and len(pr) >= self.quorums.prepare.value:
seq_no_p.add(p)
for n in seq_no_pp:
if n in seq_no_p:
return n
return None | python | def get_lowest_probable_prepared_certificate_in_view(
self, view_no) -> Optional[int]:
"""
Return lowest pp_seq_no of the view for which can be prepared but
choose from unprocessed PRE-PREPAREs and PREPAREs.
"""
# TODO: Naive implementation, dont need to iterate over the complete
# data structures, fix this later
seq_no_pp = SortedList() # pp_seq_no of PRE-PREPAREs
# pp_seq_no of PREPAREs with count of PREPAREs for each
seq_no_p = set()
for (v, p) in self.prePreparesPendingPrevPP:
if v == view_no:
seq_no_pp.add(p)
if v > view_no:
break
for (v, p), pr in self.preparesWaitingForPrePrepare.items():
if v == view_no and len(pr) >= self.quorums.prepare.value:
seq_no_p.add(p)
for n in seq_no_pp:
if n in seq_no_p:
return n
return None | [
"def",
"get_lowest_probable_prepared_certificate_in_view",
"(",
"self",
",",
"view_no",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"# TODO: Naive implementation, dont need to iterate over the complete",
"# data structures, fix this later",
"seq_no_pp",
"=",
"SortedList",
"(",
... | Return lowest pp_seq_no of the view for which can be prepared but
choose from unprocessed PRE-PREPAREs and PREPAREs. | [
"Return",
"lowest",
"pp_seq_no",
"of",
"the",
"view",
"for",
"which",
"can",
"be",
"prepared",
"but",
"choose",
"from",
"unprocessed",
"PRE",
"-",
"PREPAREs",
"and",
"PREPAREs",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L692-L717 | train | 229,184 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.is_primary_in_view | def is_primary_in_view(self, viewNo: int) -> Optional[bool]:
"""
Return whether this replica was primary in the given view
"""
if viewNo not in self.primaryNames:
return False
return self.primaryNames[viewNo] == self.name | python | def is_primary_in_view(self, viewNo: int) -> Optional[bool]:
"""
Return whether this replica was primary in the given view
"""
if viewNo not in self.primaryNames:
return False
return self.primaryNames[viewNo] == self.name | [
"def",
"is_primary_in_view",
"(",
"self",
",",
"viewNo",
":",
"int",
")",
"->",
"Optional",
"[",
"bool",
"]",
":",
"if",
"viewNo",
"not",
"in",
"self",
".",
"primaryNames",
":",
"return",
"False",
"return",
"self",
".",
"primaryNames",
"[",
"viewNo",
"]"... | Return whether this replica was primary in the given view | [
"Return",
"whether",
"this",
"replica",
"was",
"primary",
"in",
"the",
"given",
"view"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L747-L753 | train | 229,185 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.processReqDuringBatch | def processReqDuringBatch(
self,
req: Request,
cons_time: int):
"""
This method will do dynamic validation and apply requests.
If there is any errors during validation it would be raised
"""
if self.isMaster:
self.node.doDynamicValidation(req)
self.node.applyReq(req, cons_time) | python | def processReqDuringBatch(
self,
req: Request,
cons_time: int):
"""
This method will do dynamic validation and apply requests.
If there is any errors during validation it would be raised
"""
if self.isMaster:
self.node.doDynamicValidation(req)
self.node.applyReq(req, cons_time) | [
"def",
"processReqDuringBatch",
"(",
"self",
",",
"req",
":",
"Request",
",",
"cons_time",
":",
"int",
")",
":",
"if",
"self",
".",
"isMaster",
":",
"self",
".",
"node",
".",
"doDynamicValidation",
"(",
"req",
")",
"self",
".",
"node",
".",
"applyReq",
... | This method will do dynamic validation and apply requests.
If there is any errors during validation it would be raised | [
"This",
"method",
"will",
"do",
"dynamic",
"validation",
"and",
"apply",
"requests",
".",
"If",
"there",
"is",
"any",
"errors",
"during",
"validation",
"it",
"would",
"be",
"raised"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L902-L912 | train | 229,186 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.serviceQueues | def serviceQueues(self, limit=None):
"""
Process `limit` number of messages in the inBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
"""
# TODO should handle SuspiciousNode here
r = self.dequeue_pre_prepares()
r += self.inBoxRouter.handleAllSync(self.inBox, limit)
r += self.send_3pc_batch()
r += self._serviceActions()
return r | python | def serviceQueues(self, limit=None):
"""
Process `limit` number of messages in the inBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed
"""
# TODO should handle SuspiciousNode here
r = self.dequeue_pre_prepares()
r += self.inBoxRouter.handleAllSync(self.inBox, limit)
r += self.send_3pc_batch()
r += self._serviceActions()
return r | [
"def",
"serviceQueues",
"(",
"self",
",",
"limit",
"=",
"None",
")",
":",
"# TODO should handle SuspiciousNode here",
"r",
"=",
"self",
".",
"dequeue_pre_prepares",
"(",
")",
"r",
"+=",
"self",
".",
"inBoxRouter",
".",
"handleAllSync",
"(",
"self",
".",
"inBox... | Process `limit` number of messages in the inBox.
:param limit: the maximum number of messages to process
:return: the number of messages successfully processed | [
"Process",
"limit",
"number",
"of",
"messages",
"in",
"the",
"inBox",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1043-L1055 | train | 229,187 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.tryPrepare | def tryPrepare(self, pp: PrePrepare):
"""
Try to send the Prepare message if the PrePrepare message is ready to
be passed into the Prepare phase.
"""
rv, msg = self.canPrepare(pp)
if rv:
self.doPrepare(pp)
else:
self.logger.debug("{} cannot send PREPARE since {}".format(self, msg)) | python | def tryPrepare(self, pp: PrePrepare):
"""
Try to send the Prepare message if the PrePrepare message is ready to
be passed into the Prepare phase.
"""
rv, msg = self.canPrepare(pp)
if rv:
self.doPrepare(pp)
else:
self.logger.debug("{} cannot send PREPARE since {}".format(self, msg)) | [
"def",
"tryPrepare",
"(",
"self",
",",
"pp",
":",
"PrePrepare",
")",
":",
"rv",
",",
"msg",
"=",
"self",
".",
"canPrepare",
"(",
"pp",
")",
"if",
"rv",
":",
"self",
".",
"doPrepare",
"(",
"pp",
")",
"else",
":",
"self",
".",
"logger",
".",
"debug... | Try to send the Prepare message if the PrePrepare message is ready to
be passed into the Prepare phase. | [
"Try",
"to",
"send",
"the",
"Prepare",
"message",
"if",
"the",
"PrePrepare",
"message",
"is",
"ready",
"to",
"be",
"passed",
"into",
"the",
"Prepare",
"phase",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1293-L1302 | train | 229,188 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.processPrepare | def processPrepare(self, prepare: Prepare, sender: str) -> None:
"""
Validate and process the PREPARE specified.
If validation is successful, create a COMMIT and broadcast it.
:param prepare: a PREPARE msg
:param sender: name of the node that sent the PREPARE
"""
key = (prepare.viewNo, prepare.ppSeqNo)
self.logger.debug("{} received PREPARE{} from {}".format(self, key, sender))
# TODO move this try/except up higher
try:
if self.validatePrepare(prepare, sender):
self.addToPrepares(prepare, sender)
self.stats.inc(TPCStat.PrepareRcvd)
self.logger.debug("{} processed incoming PREPARE {}".format(
self, (prepare.viewNo, prepare.ppSeqNo)))
else:
# TODO let's have isValidPrepare throw an exception that gets
# handled and possibly logged higher
self.logger.trace("{} cannot process incoming PREPARE".format(self))
except SuspiciousNode as ex:
self.report_suspicious_node(ex) | python | def processPrepare(self, prepare: Prepare, sender: str) -> None:
"""
Validate and process the PREPARE specified.
If validation is successful, create a COMMIT and broadcast it.
:param prepare: a PREPARE msg
:param sender: name of the node that sent the PREPARE
"""
key = (prepare.viewNo, prepare.ppSeqNo)
self.logger.debug("{} received PREPARE{} from {}".format(self, key, sender))
# TODO move this try/except up higher
try:
if self.validatePrepare(prepare, sender):
self.addToPrepares(prepare, sender)
self.stats.inc(TPCStat.PrepareRcvd)
self.logger.debug("{} processed incoming PREPARE {}".format(
self, (prepare.viewNo, prepare.ppSeqNo)))
else:
# TODO let's have isValidPrepare throw an exception that gets
# handled and possibly logged higher
self.logger.trace("{} cannot process incoming PREPARE".format(self))
except SuspiciousNode as ex:
self.report_suspicious_node(ex) | [
"def",
"processPrepare",
"(",
"self",
",",
"prepare",
":",
"Prepare",
",",
"sender",
":",
"str",
")",
"->",
"None",
":",
"key",
"=",
"(",
"prepare",
".",
"viewNo",
",",
"prepare",
".",
"ppSeqNo",
")",
"self",
".",
"logger",
".",
"debug",
"(",
"\"{} r... | Validate and process the PREPARE specified.
If validation is successful, create a COMMIT and broadcast it.
:param prepare: a PREPARE msg
:param sender: name of the node that sent the PREPARE | [
"Validate",
"and",
"process",
"the",
"PREPARE",
"specified",
".",
"If",
"validation",
"is",
"successful",
"create",
"a",
"COMMIT",
"and",
"broadcast",
"it",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1306-L1329 | train | 229,189 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.processCommit | def processCommit(self, commit: Commit, sender: str) -> None:
"""
Validate and process the COMMIT specified.
If validation is successful, return the message to the node.
:param commit: an incoming COMMIT message
:param sender: name of the node that sent the COMMIT
"""
self.logger.debug("{} received COMMIT{} from {}".format(
self, (commit.viewNo, commit.ppSeqNo), sender))
if self.validateCommit(commit, sender):
self.stats.inc(TPCStat.CommitRcvd)
self.addToCommits(commit, sender)
self.logger.debug("{} processed incoming COMMIT{}".format(
self, (commit.viewNo, commit.ppSeqNo))) | python | def processCommit(self, commit: Commit, sender: str) -> None:
"""
Validate and process the COMMIT specified.
If validation is successful, return the message to the node.
:param commit: an incoming COMMIT message
:param sender: name of the node that sent the COMMIT
"""
self.logger.debug("{} received COMMIT{} from {}".format(
self, (commit.viewNo, commit.ppSeqNo), sender))
if self.validateCommit(commit, sender):
self.stats.inc(TPCStat.CommitRcvd)
self.addToCommits(commit, sender)
self.logger.debug("{} processed incoming COMMIT{}".format(
self, (commit.viewNo, commit.ppSeqNo))) | [
"def",
"processCommit",
"(",
"self",
",",
"commit",
":",
"Commit",
",",
"sender",
":",
"str",
")",
"->",
"None",
":",
"self",
".",
"logger",
".",
"debug",
"(",
"\"{} received COMMIT{} from {}\"",
".",
"format",
"(",
"self",
",",
"(",
"commit",
".",
"view... | Validate and process the COMMIT specified.
If validation is successful, return the message to the node.
:param commit: an incoming COMMIT message
:param sender: name of the node that sent the COMMIT | [
"Validate",
"and",
"process",
"the",
"COMMIT",
"specified",
".",
"If",
"validation",
"is",
"successful",
"return",
"the",
"message",
"to",
"the",
"node",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1333-L1348 | train | 229,190 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.tryCommit | def tryCommit(self, prepare: Prepare):
"""
Try to commit if the Prepare message is ready to be passed into the
commit phase.
"""
rv, reason = self.canCommit(prepare)
if rv:
self.doCommit(prepare)
else:
self.logger.debug("{} cannot send COMMIT since {}".format(self, reason)) | python | def tryCommit(self, prepare: Prepare):
"""
Try to commit if the Prepare message is ready to be passed into the
commit phase.
"""
rv, reason = self.canCommit(prepare)
if rv:
self.doCommit(prepare)
else:
self.logger.debug("{} cannot send COMMIT since {}".format(self, reason)) | [
"def",
"tryCommit",
"(",
"self",
",",
"prepare",
":",
"Prepare",
")",
":",
"rv",
",",
"reason",
"=",
"self",
".",
"canCommit",
"(",
"prepare",
")",
"if",
"rv",
":",
"self",
".",
"doCommit",
"(",
"prepare",
")",
"else",
":",
"self",
".",
"logger",
"... | Try to commit if the Prepare message is ready to be passed into the
commit phase. | [
"Try",
"to",
"commit",
"if",
"the",
"Prepare",
"message",
"is",
"ready",
"to",
"be",
"passed",
"into",
"the",
"commit",
"phase",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1350-L1359 | train | 229,191 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.tryOrder | def tryOrder(self, commit: Commit):
"""
Try to order if the Commit message is ready to be ordered.
"""
canOrder, reason = self.canOrder(commit)
if canOrder:
self.logger.trace("{} returning request to node".format(self))
self.doOrder(commit)
else:
self.logger.debug("{} cannot return request to node: {}".format(self, reason))
return canOrder | python | def tryOrder(self, commit: Commit):
"""
Try to order if the Commit message is ready to be ordered.
"""
canOrder, reason = self.canOrder(commit)
if canOrder:
self.logger.trace("{} returning request to node".format(self))
self.doOrder(commit)
else:
self.logger.debug("{} cannot return request to node: {}".format(self, reason))
return canOrder | [
"def",
"tryOrder",
"(",
"self",
",",
"commit",
":",
"Commit",
")",
":",
"canOrder",
",",
"reason",
"=",
"self",
".",
"canOrder",
"(",
"commit",
")",
"if",
"canOrder",
":",
"self",
".",
"logger",
".",
"trace",
"(",
"\"{} returning request to node\"",
".",
... | Try to order if the Commit message is ready to be ordered. | [
"Try",
"to",
"order",
"if",
"the",
"Commit",
"message",
"is",
"ready",
"to",
"be",
"ordered",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1361-L1371 | train | 229,192 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.nonFinalisedReqs | def nonFinalisedReqs(self, reqKeys: List[Tuple[str, int]]):
"""
Check if there are any requests which are not finalised, i.e for
which there are not enough PROPAGATEs
"""
return {key for key in reqKeys if not self.requests.is_finalised(key)} | python | def nonFinalisedReqs(self, reqKeys: List[Tuple[str, int]]):
"""
Check if there are any requests which are not finalised, i.e for
which there are not enough PROPAGATEs
"""
return {key for key in reqKeys if not self.requests.is_finalised(key)} | [
"def",
"nonFinalisedReqs",
"(",
"self",
",",
"reqKeys",
":",
"List",
"[",
"Tuple",
"[",
"str",
",",
"int",
"]",
"]",
")",
":",
"return",
"{",
"key",
"for",
"key",
"in",
"reqKeys",
"if",
"not",
"self",
".",
"requests",
".",
"is_finalised",
"(",
"key",... | Check if there are any requests which are not finalised, i.e for
which there are not enough PROPAGATEs | [
"Check",
"if",
"there",
"are",
"any",
"requests",
"which",
"are",
"not",
"finalised",
"i",
".",
"e",
"for",
"which",
"there",
"are",
"not",
"enough",
"PROPAGATEs"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1428-L1433 | train | 229,193 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica._can_process_pre_prepare | def _can_process_pre_prepare(self, pre_prepare: PrePrepare, sender: str) -> Optional[int]:
"""
Decide whether this replica is eligible to process a PRE-PREPARE.
:param pre_prepare: a PRE-PREPARE msg to process
:param sender: the name of the node that sent the PRE-PREPARE msg
"""
# TODO: Check whether it is rejecting PRE-PREPARE from previous view
# PRE-PREPARE should not be sent from non primary
if not self.isMsgFromPrimary(pre_prepare, sender):
return PP_CHECK_NOT_FROM_PRIMARY
# Already has a PRE-PREPARE with same 3 phase key
if (pre_prepare.viewNo, pre_prepare.ppSeqNo) in self.prePrepares:
return PP_CHECK_DUPLICATE
if not self.is_pre_prepare_time_acceptable(pre_prepare, sender):
return PP_CHECK_WRONG_TIME
if compare_3PC_keys((pre_prepare.viewNo, pre_prepare.ppSeqNo),
self.__last_pp_3pc) > 0:
return PP_CHECK_OLD # ignore old pre-prepare
if self.nonFinalisedReqs(pre_prepare.reqIdr):
return PP_CHECK_REQUEST_NOT_FINALIZED
if not self.__is_next_pre_prepare(pre_prepare.viewNo,
pre_prepare.ppSeqNo):
return PP_CHECK_NOT_NEXT
if f.POOL_STATE_ROOT_HASH.nm in pre_prepare and \
pre_prepare.poolStateRootHash != self.stateRootHash(POOL_LEDGER_ID):
return PP_CHECK_INCORRECT_POOL_STATE_ROOT
# BLS multi-sig:
status = self._bls_bft_replica.validate_pre_prepare(pre_prepare,
sender)
if status is not None:
return status
return None | python | def _can_process_pre_prepare(self, pre_prepare: PrePrepare, sender: str) -> Optional[int]:
"""
Decide whether this replica is eligible to process a PRE-PREPARE.
:param pre_prepare: a PRE-PREPARE msg to process
:param sender: the name of the node that sent the PRE-PREPARE msg
"""
# TODO: Check whether it is rejecting PRE-PREPARE from previous view
# PRE-PREPARE should not be sent from non primary
if not self.isMsgFromPrimary(pre_prepare, sender):
return PP_CHECK_NOT_FROM_PRIMARY
# Already has a PRE-PREPARE with same 3 phase key
if (pre_prepare.viewNo, pre_prepare.ppSeqNo) in self.prePrepares:
return PP_CHECK_DUPLICATE
if not self.is_pre_prepare_time_acceptable(pre_prepare, sender):
return PP_CHECK_WRONG_TIME
if compare_3PC_keys((pre_prepare.viewNo, pre_prepare.ppSeqNo),
self.__last_pp_3pc) > 0:
return PP_CHECK_OLD # ignore old pre-prepare
if self.nonFinalisedReqs(pre_prepare.reqIdr):
return PP_CHECK_REQUEST_NOT_FINALIZED
if not self.__is_next_pre_prepare(pre_prepare.viewNo,
pre_prepare.ppSeqNo):
return PP_CHECK_NOT_NEXT
if f.POOL_STATE_ROOT_HASH.nm in pre_prepare and \
pre_prepare.poolStateRootHash != self.stateRootHash(POOL_LEDGER_ID):
return PP_CHECK_INCORRECT_POOL_STATE_ROOT
# BLS multi-sig:
status = self._bls_bft_replica.validate_pre_prepare(pre_prepare,
sender)
if status is not None:
return status
return None | [
"def",
"_can_process_pre_prepare",
"(",
"self",
",",
"pre_prepare",
":",
"PrePrepare",
",",
"sender",
":",
"str",
")",
"->",
"Optional",
"[",
"int",
"]",
":",
"# TODO: Check whether it is rejecting PRE-PREPARE from previous view",
"# PRE-PREPARE should not be sent from non pr... | Decide whether this replica is eligible to process a PRE-PREPARE.
:param pre_prepare: a PRE-PREPARE msg to process
:param sender: the name of the node that sent the PRE-PREPARE msg | [
"Decide",
"whether",
"this",
"replica",
"is",
"eligible",
"to",
"process",
"a",
"PRE",
"-",
"PREPARE",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1539-L1579 | train | 229,194 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.addToPrePrepares | def addToPrePrepares(self, pp: PrePrepare) -> None:
"""
Add the specified PRE-PREPARE to this replica's list of received
PRE-PREPAREs and try sending PREPARE
:param pp: the PRE-PREPARE to add to the list
"""
key = (pp.viewNo, pp.ppSeqNo)
self.prePrepares[key] = pp
self.lastPrePrepareSeqNo = pp.ppSeqNo
self.last_accepted_pre_prepare_time = pp.ppTime
self.dequeue_prepares(*key)
self.dequeue_commits(*key)
self.stats.inc(TPCStat.PrePrepareRcvd)
self.tryPrepare(pp) | python | def addToPrePrepares(self, pp: PrePrepare) -> None:
"""
Add the specified PRE-PREPARE to this replica's list of received
PRE-PREPAREs and try sending PREPARE
:param pp: the PRE-PREPARE to add to the list
"""
key = (pp.viewNo, pp.ppSeqNo)
self.prePrepares[key] = pp
self.lastPrePrepareSeqNo = pp.ppSeqNo
self.last_accepted_pre_prepare_time = pp.ppTime
self.dequeue_prepares(*key)
self.dequeue_commits(*key)
self.stats.inc(TPCStat.PrePrepareRcvd)
self.tryPrepare(pp) | [
"def",
"addToPrePrepares",
"(",
"self",
",",
"pp",
":",
"PrePrepare",
")",
"->",
"None",
":",
"key",
"=",
"(",
"pp",
".",
"viewNo",
",",
"pp",
".",
"ppSeqNo",
")",
"self",
".",
"prePrepares",
"[",
"key",
"]",
"=",
"pp",
"self",
".",
"lastPrePrepareSe... | Add the specified PRE-PREPARE to this replica's list of received
PRE-PREPAREs and try sending PREPARE
:param pp: the PRE-PREPARE to add to the list | [
"Add",
"the",
"specified",
"PRE",
"-",
"PREPARE",
"to",
"this",
"replica",
"s",
"list",
"of",
"received",
"PRE",
"-",
"PREPAREs",
"and",
"try",
"sending",
"PREPARE"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1581-L1595 | train | 229,195 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.canPrepare | def canPrepare(self, ppReq) -> (bool, str):
"""
Return whether the batch of requests in the PRE-PREPARE can
proceed to the PREPARE step.
:param ppReq: any object with identifier and requestId attributes
"""
if self.has_sent_prepare(ppReq):
return False, 'has already sent PREPARE for {}'.format(ppReq)
return True, '' | python | def canPrepare(self, ppReq) -> (bool, str):
"""
Return whether the batch of requests in the PRE-PREPARE can
proceed to the PREPARE step.
:param ppReq: any object with identifier and requestId attributes
"""
if self.has_sent_prepare(ppReq):
return False, 'has already sent PREPARE for {}'.format(ppReq)
return True, '' | [
"def",
"canPrepare",
"(",
"self",
",",
"ppReq",
")",
"->",
"(",
"bool",
",",
"str",
")",
":",
"if",
"self",
".",
"has_sent_prepare",
"(",
"ppReq",
")",
":",
"return",
"False",
",",
"'has already sent PREPARE for {}'",
".",
"format",
"(",
"ppReq",
")",
"r... | Return whether the batch of requests in the PRE-PREPARE can
proceed to the PREPARE step.
:param ppReq: any object with identifier and requestId attributes | [
"Return",
"whether",
"the",
"batch",
"of",
"requests",
"in",
"the",
"PRE",
"-",
"PREPARE",
"can",
"proceed",
"to",
"the",
"PREPARE",
"step",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1600-L1609 | train | 229,196 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.validatePrepare | def validatePrepare(self, prepare: Prepare, sender: str) -> bool:
"""
Return whether the PREPARE specified is valid.
:param prepare: the PREPARE to validate
:param sender: the name of the node that sent the PREPARE
:return: True if PREPARE is valid, False otherwise
"""
key = (prepare.viewNo, prepare.ppSeqNo)
primaryStatus = self.isPrimaryForMsg(prepare)
ppReq = self.getPrePrepare(*key)
# If a non primary replica and receiving a PREPARE request before a
# PRE-PREPARE request, then proceed
# PREPARE should not be sent from primary
if self.isMsgFromPrimary(prepare, sender):
raise SuspiciousNode(sender, Suspicions.PR_FRM_PRIMARY, prepare)
# If non primary replica
if primaryStatus is False:
if self.prepares.hasPrepareFrom(prepare, sender):
raise SuspiciousNode(
sender, Suspicions.DUPLICATE_PR_SENT, prepare)
# If PRE-PREPARE not received for the PREPARE, might be slow
# network
if not ppReq:
self.enqueue_prepare(prepare, sender)
self._setup_last_ordered_for_non_master()
return False
# If primary replica
if primaryStatus is True:
if self.prepares.hasPrepareFrom(prepare, sender):
raise SuspiciousNode(
sender, Suspicions.DUPLICATE_PR_SENT, prepare)
# If PRE-PREPARE was not sent for this PREPARE, certainly
# malicious behavior
elif not ppReq:
raise SuspiciousNode(
sender, Suspicions.UNKNOWN_PR_SENT, prepare)
if primaryStatus is None and not ppReq:
self.enqueue_prepare(prepare, sender)
self._setup_last_ordered_for_non_master()
return False
if prepare.digest != ppReq.digest:
raise SuspiciousNode(sender, Suspicions.PR_DIGEST_WRONG, prepare)
elif prepare.stateRootHash != ppReq.stateRootHash:
raise SuspiciousNode(sender, Suspicions.PR_STATE_WRONG,
prepare)
elif prepare.txnRootHash != ppReq.txnRootHash:
raise SuspiciousNode(sender, Suspicions.PR_TXN_WRONG,
prepare)
elif prepare.auditTxnRootHash != ppReq.auditTxnRootHash:
raise SuspiciousNode(sender, Suspicions.PR_AUDIT_TXN_ROOT_HASH_WRONG,
prepare)
try:
self.execute_hook(ReplicaHooks.VALIDATE_PR, prepare, ppReq)
except Exception as ex:
self.logger.warning('{} encountered exception in replica '
'hook {} : {}'.
format(self, ReplicaHooks.VALIDATE_PR, ex))
raise SuspiciousNode(sender, Suspicions.PR_PLUGIN_EXCEPTION,
prepare)
# BLS multi-sig:
self._bls_bft_replica.validate_prepare(prepare, sender)
return True | python | def validatePrepare(self, prepare: Prepare, sender: str) -> bool:
"""
Return whether the PREPARE specified is valid.
:param prepare: the PREPARE to validate
:param sender: the name of the node that sent the PREPARE
:return: True if PREPARE is valid, False otherwise
"""
key = (prepare.viewNo, prepare.ppSeqNo)
primaryStatus = self.isPrimaryForMsg(prepare)
ppReq = self.getPrePrepare(*key)
# If a non primary replica and receiving a PREPARE request before a
# PRE-PREPARE request, then proceed
# PREPARE should not be sent from primary
if self.isMsgFromPrimary(prepare, sender):
raise SuspiciousNode(sender, Suspicions.PR_FRM_PRIMARY, prepare)
# If non primary replica
if primaryStatus is False:
if self.prepares.hasPrepareFrom(prepare, sender):
raise SuspiciousNode(
sender, Suspicions.DUPLICATE_PR_SENT, prepare)
# If PRE-PREPARE not received for the PREPARE, might be slow
# network
if not ppReq:
self.enqueue_prepare(prepare, sender)
self._setup_last_ordered_for_non_master()
return False
# If primary replica
if primaryStatus is True:
if self.prepares.hasPrepareFrom(prepare, sender):
raise SuspiciousNode(
sender, Suspicions.DUPLICATE_PR_SENT, prepare)
# If PRE-PREPARE was not sent for this PREPARE, certainly
# malicious behavior
elif not ppReq:
raise SuspiciousNode(
sender, Suspicions.UNKNOWN_PR_SENT, prepare)
if primaryStatus is None and not ppReq:
self.enqueue_prepare(prepare, sender)
self._setup_last_ordered_for_non_master()
return False
if prepare.digest != ppReq.digest:
raise SuspiciousNode(sender, Suspicions.PR_DIGEST_WRONG, prepare)
elif prepare.stateRootHash != ppReq.stateRootHash:
raise SuspiciousNode(sender, Suspicions.PR_STATE_WRONG,
prepare)
elif prepare.txnRootHash != ppReq.txnRootHash:
raise SuspiciousNode(sender, Suspicions.PR_TXN_WRONG,
prepare)
elif prepare.auditTxnRootHash != ppReq.auditTxnRootHash:
raise SuspiciousNode(sender, Suspicions.PR_AUDIT_TXN_ROOT_HASH_WRONG,
prepare)
try:
self.execute_hook(ReplicaHooks.VALIDATE_PR, prepare, ppReq)
except Exception as ex:
self.logger.warning('{} encountered exception in replica '
'hook {} : {}'.
format(self, ReplicaHooks.VALIDATE_PR, ex))
raise SuspiciousNode(sender, Suspicions.PR_PLUGIN_EXCEPTION,
prepare)
# BLS multi-sig:
self._bls_bft_replica.validate_prepare(prepare, sender)
return True | [
"def",
"validatePrepare",
"(",
"self",
",",
"prepare",
":",
"Prepare",
",",
"sender",
":",
"str",
")",
"->",
"bool",
":",
"key",
"=",
"(",
"prepare",
".",
"viewNo",
",",
"prepare",
".",
"ppSeqNo",
")",
"primaryStatus",
"=",
"self",
".",
"isPrimaryForMsg"... | Return whether the PREPARE specified is valid.
:param prepare: the PREPARE to validate
:param sender: the name of the node that sent the PREPARE
:return: True if PREPARE is valid, False otherwise | [
"Return",
"whether",
"the",
"PREPARE",
"specified",
"is",
"valid",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1611-L1682 | train | 229,197 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.addToPrepares | def addToPrepares(self, prepare: Prepare, sender: str):
"""
Add the specified PREPARE to this replica's list of received
PREPAREs and try sending COMMIT
:param prepare: the PREPARE to add to the list
"""
# BLS multi-sig:
self._bls_bft_replica.process_prepare(prepare, sender)
self.prepares.addVote(prepare, sender)
self.dequeue_commits(prepare.viewNo, prepare.ppSeqNo)
self.tryCommit(prepare) | python | def addToPrepares(self, prepare: Prepare, sender: str):
"""
Add the specified PREPARE to this replica's list of received
PREPAREs and try sending COMMIT
:param prepare: the PREPARE to add to the list
"""
# BLS multi-sig:
self._bls_bft_replica.process_prepare(prepare, sender)
self.prepares.addVote(prepare, sender)
self.dequeue_commits(prepare.viewNo, prepare.ppSeqNo)
self.tryCommit(prepare) | [
"def",
"addToPrepares",
"(",
"self",
",",
"prepare",
":",
"Prepare",
",",
"sender",
":",
"str",
")",
":",
"# BLS multi-sig:",
"self",
".",
"_bls_bft_replica",
".",
"process_prepare",
"(",
"prepare",
",",
"sender",
")",
"self",
".",
"prepares",
".",
"addVote"... | Add the specified PREPARE to this replica's list of received
PREPAREs and try sending COMMIT
:param prepare: the PREPARE to add to the list | [
"Add",
"the",
"specified",
"PREPARE",
"to",
"this",
"replica",
"s",
"list",
"of",
"received",
"PREPAREs",
"and",
"try",
"sending",
"COMMIT"
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1684-L1696 | train | 229,198 |
hyperledger/indy-plenum | plenum/server/replica.py | Replica.canCommit | def canCommit(self, prepare: Prepare) -> (bool, str):
"""
Return whether the specified PREPARE can proceed to the Commit
step.
Decision criteria:
- If this replica has got just n-f-1 PREPARE requests then commit request.
- If less than n-f-1 PREPARE requests then probably there's no consensus on
the request; don't commit
- If more than n-f-1 then already sent COMMIT; don't commit
:param prepare: the PREPARE
"""
quorum = self.quorums.prepare.value
if not self.prepares.hasQuorum(prepare, quorum):
return False, 'does not have prepare quorum for {}'.format(prepare)
if self.hasCommitted(prepare):
return False, 'has already sent COMMIT for {}'.format(prepare)
return True, '' | python | def canCommit(self, prepare: Prepare) -> (bool, str):
"""
Return whether the specified PREPARE can proceed to the Commit
step.
Decision criteria:
- If this replica has got just n-f-1 PREPARE requests then commit request.
- If less than n-f-1 PREPARE requests then probably there's no consensus on
the request; don't commit
- If more than n-f-1 then already sent COMMIT; don't commit
:param prepare: the PREPARE
"""
quorum = self.quorums.prepare.value
if not self.prepares.hasQuorum(prepare, quorum):
return False, 'does not have prepare quorum for {}'.format(prepare)
if self.hasCommitted(prepare):
return False, 'has already sent COMMIT for {}'.format(prepare)
return True, '' | [
"def",
"canCommit",
"(",
"self",
",",
"prepare",
":",
"Prepare",
")",
"->",
"(",
"bool",
",",
"str",
")",
":",
"quorum",
"=",
"self",
".",
"quorums",
".",
"prepare",
".",
"value",
"if",
"not",
"self",
".",
"prepares",
".",
"hasQuorum",
"(",
"prepare"... | Return whether the specified PREPARE can proceed to the Commit
step.
Decision criteria:
- If this replica has got just n-f-1 PREPARE requests then commit request.
- If less than n-f-1 PREPARE requests then probably there's no consensus on
the request; don't commit
- If more than n-f-1 then already sent COMMIT; don't commit
:param prepare: the PREPARE | [
"Return",
"whether",
"the",
"specified",
"PREPARE",
"can",
"proceed",
"to",
"the",
"Commit",
"step",
"."
] | dcd144e238af7f17a869ffc9412f13dc488b7020 | https://github.com/hyperledger/indy-plenum/blob/dcd144e238af7f17a869ffc9412f13dc488b7020/plenum/server/replica.py#L1740-L1759 | train | 229,199 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.