def setup_message_logging(base_dir: str) -> None:
"""
Delete existing logging-file and set-up logging handler, filter and formatter.
"""
log_filter = SovrinLogMessageFilter()
if os.path.exists(LOG_FILE_NAME):
os.remove(LOG_FILE_NAME)
file_handler = SovrinLogHandler(LOG_FILE_NAME)
file_handler.setLevel(LOGGING_LEVEL)
file_handler.addFilter(log_filter)
file_handler.formatter = logging.Formatter(
fmt=getConfig().logFormat, style=getConfig().logFormatStyle)
logging.root.addHandler(file_handler)
# if os.path.exists("unfiltered_" + LOG_FILE_NAME):
# os.remove("unfiltered_" + LOG_FILE_NAME)
# unfiltered_file_handler = SovrinLogHandler("unfiltered_" + LOG_FILE_NAME)
#
# unfiltered_file_handler.setLevel(LOGGING_LEVEL)
# unfiltered_file_handler.formatter = logging.Formatter(fmt=getConfig().logFormat,
# style=getConfig().logFormatStyle)
#
# logging.root.addHandler(unfiltered_file_handler)3
logging.info("### Base directory is: {} ###".format(base_dir))
def __init__(self,
name: str = None,
basedirpath: str = None,
client: Client = None,
port: int = None,
loop=None,
config=None,
endpointArgs=None):
self.endpoint = None
if port:
checkPortAvailable(HA("0.0.0.0", port))
Motor.__init__(self)
self.loop = loop or asyncio.get_event_loop()
self._eventListeners = {} # Dict[str, set(Callable)]
self._name = name or 'Agent'
self._port = port
self.config = config or getConfig()
self.basedirpath = basedirpath or os.path.expanduser(
self.config.baseDir)
self.endpointArgs = endpointArgs
# Client used to connect to Sovrin and forward on owner's txns
self._client = client # type: Client
# known identifiers of this agent's owner
self.ownerIdentifiers = {} # type: Dict[Identifier, Identity]
def __init__(self,
name: str,
nodeReg: Dict[str, HA] = None,
ha: Union[HA, Tuple[str, int]] = None,
peerHA: Union[HA, Tuple[str, int]] = None,
basedirpath: str = None,
config=None,
sighex: str = None):
config = config or getConfig()
super().__init__(name, nodeReg, ha, basedirpath, config, sighex)
self.graphStore = self.getGraphStore()
self.autoDiscloseAttributes = False
self.requestedPendingTxns = False
self.hasAnonCreds = bool(peerHA)
if self.hasAnonCreds:
self.peerHA = peerHA if isinstance(peerHA, HA) else HA(*peerHA)
stackargs = dict(name=self.stackName,
ha=peerHA,
main=True,
auto=AutoMode.always)
self.peerMsgRoutes = []
self.peerMsgRouter = Router(*self.peerMsgRoutes)
self.peerStack = SimpleStack(stackargs,
msgHandler=self.handlePeerMessage)
self.peerStack.sign = self.sign
self.peerInbox = deque()
self._observers = {} # type Dict[str, Callable]
self._observerSet = set(
) # makes it easier to guard against duplicates
def __init__(self,
name,
nodeRegistry=None,
clientAuthNr=None,
ha=None,
cliname=None,
cliha=None,
basedirpath=None,
primaryDecider=None,
pluginPaths: Iterable[str] = None,
storage=None,
config=None):
self.config = config or getConfig()
self.graphStore = self.getGraphStorage(name)
super().__init__(name=name,
nodeRegistry=nodeRegistry,
clientAuthNr=clientAuthNr,
ha=ha,
cliname=cliname,
cliha=cliha,
basedirpath=basedirpath,
primaryDecider=primaryDecider,
pluginPaths=pluginPaths,
storage=storage,
config=self.config)
self._addTxnsToGraphIfNeeded()
self.configLedger = self.getConfigLedger()
self.ledgerManager.addLedger(
2,
self.configLedger,
postCatchupCompleteClbk=self.postConfigLedgerCaughtUp,
postTxnAddedToLedgerClbk=self.postTxnFromCatchupAddedToLedger)
self.upgrader = self.getUpgrader()
self.nodeMsgRouter.routes[Request] = self.processNodeRequest
self.nodeAuthNr = self.defaultNodeAuthNr()
def createAgent(agentClass,
name,
wallet=None,
basedirpath=None,
port=None,
loop=None,
clientClass=Client):
config = getConfig()
if not wallet:
wallet = Wallet(name)
wallet.addIdentifier(signer=SimpleSigner(
seed=randomString(32).encode('utf-8')))
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
_, clientPort = genHa()
client = clientClass(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedirpath)
return agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port,
loop=loop)
def getBulldogLogger():
config = getConfig()
path = expanduser('{}'.format(config.baseDir))
filePath = '{}/bulldog.log'.format(path)
try:
if not exists(filePath):
with open(filePath, mode='a+'):
# we just want to create a file if not exists
# don't do anything else with file handler
pass
log = getLogger()
log.setLevel(logging.DEBUG)
formatter = logging.Formatter('%(asctime)s %(message)s')
fileHandler = logging.FileHandler(filePath, mode='a')
fileHandler.setLevel(logging.DEBUG)
fileHandler.setFormatter(formatter)
log.addHandler(fileHandler)
return log
except OSError:
print('Could not create log file')
raise Exception
def __init__(self,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None):
if not basedirpath:
config = getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
portParam, = self.getPassedArgs()
super().__init__('Thrift Bank',
basedirpath,
client,
wallet,
portParam or port,
loop=loop)
# maps invitation nonces to internal ids
self._invites = {"77fbf9dc8c8e6acde33de98c6d747b28c": 1}
self.availableClaims = []
# mapping between requester identifier and corresponding available claims
self.requesterAvailClaims = {}
def __init__(self,
name: str=None,
basedirpath: str=None,
client: Client=None,
port: int=None,
loop=None,
config=None,
endpointArgs=None):
self.endpoint = None
if port:
checkPortAvailable(HA("0.0.0.0", port))
Motor.__init__(self)
self.loop = loop or asyncio.get_event_loop()
self._eventListeners = {} # Dict[str, set(Callable)]
self._name = name or 'Agent'
self._port = port
self.config = config or getConfig()
self.basedirpath = basedirpath or os.path.expanduser(self.config.baseDir)
self.endpointArgs = endpointArgs
# Client used to connect to Sovrin and forward on owner's txns
self._client = client # type: Client
# known identifiers of this agent's owner
self.ownerIdentifiers = {} # type: Dict[Identifier, Identity]
self.logger = logger
def createAgent(agentClass,
name,
wallet=None,
basedirpath=None,
port=None,
loop=None,
clientClass=Client):
config = getConfig()
if not wallet:
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner(
seed=randomString(32).encode('utf-8')))
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
client = create_client(base_dir_path=basedirpath, client_class=clientClass)
return agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port,
loop=loop)
def __init__(self,
name: str=None,
nodeReg: Dict[str, HA]=None,
ha: Union[HA, Tuple[str, int]]=None,
peerHA: Union[HA, Tuple[str, int]]=None,
basedirpath: str=None,
config=None,
sighex: str=None):
config = config or getConfig()
super().__init__(name,
nodeReg,
ha,
basedirpath,
config,
sighex)
self.autoDiscloseAttributes = False
self.requestedPendingTxns = False
self.hasAnonCreds = bool(peerHA)
if self.hasAnonCreds:
self.peerHA = peerHA if isinstance(peerHA, HA) else HA(*peerHA)
stackargs = dict(name=self.stackName,
ha=peerHA,
main=True,
auth_mode=AuthMode.ALLOW_ANY.value)
self.peerMsgRoutes = []
self.peerMsgRouter = Router(*self.peerMsgRoutes)
self.peerStack = self.peerStackClass(stackargs,
msgHandler=self.handlePeerMessage)
self.peerStack.sign = self.sign
self.peerInbox = deque()
self._observers = {} # type Dict[str, Callable]
self._observerSet = set() # makes it easier to guard against duplicates
def getBulldogLogger(basedirpath=None):
key = basedirpath or 'default'
logger = bulldogLoggerMap.get(key)
if logger:
return logger
basedir = basedirpath or getConfig().baseDir
path = expanduser('{}'.format(basedir))
filePath = '{}/bulldog.log'.format(path)
try:
if not exists(filePath):
with open(filePath, mode='a+'):
# we just want to create a file if not exists
# don't do anything else with file handler
pass
log = getLogger()
log.setLevel(agentLoggingLevel)
formatter = logging.Formatter('%(asctime)s %(message)s')
fileHandler = logging.FileHandler(filePath, mode='a')
fileHandler.setLevel(agentLoggingLevel)
fileHandler.setFormatter(formatter)
log.addHandler(fileHandler)
bulldogLoggerMap[key] = log
return log
except OSError as e:
print('Could not create log file: {}'.format(str(e)))
raise Exception
def __init__(self,
name: str,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None,
config=None,
endpointArgs=None):
config = config or getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
portParam, _ = self.getPassedArgs()
self.logger = getlogger()
super().__init__(name, basedirpath, client, wallet,
portParam or port, loop=loop, config=config,
endpointArgs=endpointArgs)
self.claimVersionNumber = 0.01
self._invites = {}
self.updateClaimVersionFile(self.getClaimVersionFileName())
signal.signal(signal.SIGTERM, self.exit_gracefully)
self.setupLogging(self.getLoggerFilePath())
def testScheduleNodeUpgrade(nodeSet):
"""
Tests that upgrade scheduling works. For that it starts mock
control service, schedules upgrade for near future and then checks that
service received notification.
"""
from sovrin_common.config_util import getConfig
config = getConfig()
loop = asyncio.get_event_loop()
server, indicator = loop.run_until_complete(
_createServer(host=config.controlServiceHost,
port=config.controlServicePort))
indicator.add_done_callback(_stopServer(server))
node = nodeSet[0]
# ATTENTION! nodeId and ledger must not be None, but there
# we do not call methods that use them, so we can pass None
# We do it because node from nodeSet is some testable object, not real
# node, so it has no nodeId and ledger that we can use
upgrader = Upgrader(nodeId=None,
nodeName=None,
dataDir=node.dataLocation,
config=config,
ledger=None)
upgrader._callUpgradeAgent(time.time(),
"1.2",
failTimeout=1000,
upgrade_id=None)
result = loop.run_until_complete(eventuallySoon(_checkFuture(indicator)))
expectedResult = UpgradeMessage(version)
assert result == expectedResult.toJson()
def createAgent(agentClass,
name,
wallet=None,
basedirpath=None,
port=None,
loop=None,
clientClass=Client):
config = getConfig()
if not wallet:
wallet = Wallet(name)
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
_, clientPort = genHa()
client = clientClass(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=basedirpath)
return agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port,
loop=loop)
def __init__(self,
name: str,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None,
config=None,
endpointArgs=None):
config = config or getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
portParam, _ = self.getPassedArgs()
self.logger = getlogger()
super().__init__(name,
basedirpath,
client,
wallet,
portParam or port,
loop=loop,
config=config,
endpointArgs=endpointArgs)
self.claimVersionNumber = 0.01
self._invites = {}
self.updateClaimVersionFile(self.getClaimVersionFileName())
signal.signal(signal.SIGTERM, self.exit_gracefully)
self.setupLogging(self.getLoggerFilePath())
def initialize_node_environment(name, base_dir, sigseed=None,
override_keep=False,
config=None):
config = config or getConfig()
base_dir = base_dir or config.baseDir
cleanup_environment(name, base_dir)
vk = p_initialize_node_environment(name, base_dir, sigseed, override_keep)
return vk
def cleanupDataLocation(self):
self.cleanupDirectory(self.dataLocation)
config = getConfig()
if config.ReqReplyStore == "orientdb" or config.ClientIdentityGraph:
try:
self._getOrientDbStore().client.db_drop(self.name)
logger.debug("Dropped db {}".format(self.name))
except Exception as ex:
logger.debug("Error while dropping db {}: {}".format(
self.name, ex))
def initialize_node_environment(name,
base_dir,
sigseed=None,
override_keep=False,
config=None):
config = config or getConfig()
base_dir = base_dir or config.baseDir
cleanup_environment(name, base_dir)
vk = p_initialize_node_environment(name, base_dir, sigseed, override_keep)
return vk
def create_client(base_dir_path=None, client_class=Client):
config = getConfig()
if not base_dir_path:
base_dir_path = config.baseDir
_, clientPort = genHa()
client = client_class(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=base_dir_path)
return client
def run_agent(cls, agent: Agent, looper=None, bootstrap=None, with_cli=False):
try:
config = getConfig()
if with_cli:
runAgentCli(agent, config, looper=looper, bootstrap=bootstrap)
else:
runAgent(agent, looper, bootstrap)
return agent
except Exception as exc:
error = "Agent startup failed: [cause : {}]".format(str(exc))
logger.error(getFormattedErrorMsg(error))
def create_client(base_dir_path=None, client_class=Client):
config = getConfig()
if not base_dir_path:
base_dir_path = config.baseDir
_, clientPort = genHa()
client = client_class(randomString(6),
ha=("0.0.0.0", clientPort),
basedirpath=base_dir_path)
return client
def __init__(self,
name,
nodeRegistry=None,
clientAuthNr=None,
ha=None,
cliname=None,
cliha=None,
basedirpath=None,
primaryDecider=None,
pluginPaths: Iterable[str] = None,
storage=None,
config=None):
self.config = config or getConfig()
# TODO: 3 ugly lines ahead, don't know how to avoid
# self.stateTreeStore = None
self.idrCache = None
self.attributeStore = None
super().__init__(name=name,
nodeRegistry=nodeRegistry,
clientAuthNr=clientAuthNr,
ha=ha,
cliname=cliname,
cliha=cliha,
basedirpath=basedirpath,
primaryDecider=primaryDecider,
pluginPaths=pluginPaths,
storage=storage,
config=self.config)
# TODO: ugly line ahead, don't know how to avoid
self.clientAuthNr = clientAuthNr or self.defaultAuthNr()
self.configLedger = self.getConfigLedger()
self.ledgerManager.addLedger(
CONFIG_LEDGER_ID,
self.configLedger,
postCatchupCompleteClbk=self.postConfigLedgerCaughtUp,
postTxnAddedToLedgerClbk=self.postTxnFromCatchupAddedToLedger)
self.on_new_ledger_added(CONFIG_LEDGER_ID)
self.states[CONFIG_LEDGER_ID] = self.loadConfigState()
self.upgrader = self.getUpgrader()
self.poolCfg = self.getPoolConfig()
self.configReqHandler = self.getConfigReqHandler()
self.initConfigState()
self.requestExecuter[CONFIG_LEDGER_ID] = self.executeConfigTxns
self.nodeMsgRouter.routes[Request] = self.processNodeRequest
self.nodeAuthNr = self.defaultNodeAuthNr()
def __init__(self, genesis_txns, base_dir, config=None, loop=None, steward: Steward=None):
super().__init__(loop=loop)
self.base_dir = base_dir
self.genesis_txns = genesis_txns
self.config = config or getConfig(self.base_dir)
self._generate_genesis_files()
self._steward = steward
if steward is not None:
self._steward_agent = WalletedAgent(name="steward1",
basedirpath=self.base_dir,
client=self.create_client(5005),
wallet=steward.wallet,
port=8781)
self.add(self._steward_agent)
def run_agent(cls,
agent: Agent,
looper=None,
bootstrap=None,
with_cli=False):
try:
config = getConfig()
if with_cli:
runAgentCli(agent, config, looper=looper, bootstrap=bootstrap)
else:
runAgent(agent, looper, bootstrap)
return agent
except Exception as exc:
error = "Agent startup failed: [cause : {}]".format(str(exc))
logger.error(getFormattedErrorMsg(error))
def __init__(self,
name: str = None,
basedirpath: str = None,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None,
attrRepo=None,
config=None,
endpointArgs=None):
Agent.__init__(self,
name,
basedirpath,
client,
port,
loop=loop,
config=config,
endpointArgs=endpointArgs)
self.config = getConfig(basedirpath)
self._wallet = None
self._walletSaver = None
updateWalletsBaseDirNameIfOutdated(self.config)
# restore any active wallet belonging to this agent
self._restoreWallet()
# if no persisted wallet is restored and a wallet is passed,
# then use given wallet, else ignore the given wallet
if not self.wallet and wallet:
self.wallet = wallet
# if wallet is not yet set, then create a wallet
if not self.wallet:
self.wallet = Wallet(name)
self._attrRepo = attrRepo or AttributeRepoInMemory()
Walleted.__init__(self)
if self.client:
self._initIssuerProverVerifier()
self._restoreIssuerWallet()
def __init__(self,
name,
nodeRegistry=None,
clientAuthNr=None,
ha=None,
cliname=None,
cliha=None,
basedirpath=None,
primaryDecider=None,
pluginPaths: Iterable[str] = None,
storage=None,
config=None):
self.config = config or getConfig()
# TODO: 3 ugly lines ahead, don't know how to avoid
# self.stateTreeStore = None
self.idrCache = None
self.attributeStore = None
super().__init__(name=name,
nodeRegistry=nodeRegistry,
clientAuthNr=clientAuthNr,
ha=ha,
cliname=cliname,
cliha=cliha,
basedirpath=basedirpath,
primaryDecider=primaryDecider,
pluginPaths=pluginPaths,
storage=storage,
config=self.config)
# TODO: ugly line ahead, don't know how to avoid
self.clientAuthNr = clientAuthNr or self.defaultAuthNr()
self.configLedger = self.getConfigLedger()
self.ledgerManager.addLedger(CONFIG_LEDGER_ID, self.configLedger,
postCatchupCompleteClbk=self.postConfigLedgerCaughtUp,
postTxnAddedToLedgerClbk=self.postTxnFromCatchupAddedToLedger)
self.on_new_ledger_added(CONFIG_LEDGER_ID)
self.states[CONFIG_LEDGER_ID] = self.loadConfigState()
self.upgrader = self.getUpgrader()
self.configReqHandler = self.getConfigReqHandler()
self.initConfigState()
self.requestExecuter[CONFIG_LEDGER_ID] = self.executeConfigTxns
self.nodeMsgRouter.routes[Request] = self.processNodeRequest
self.nodeAuthNr = self.defaultNodeAuthNr()
def cleanupDataLocation(self):
loc = os.path.join(self.baseDir, "data/clients", self.name)
logger.debug('Cleaning up location {} of test client {}'.format(
loc, self.name))
try:
shutil.rmtree(loc)
except Exception as ex:
logger.debug(
"Error while removing temporary directory {}".format(ex))
config = getConfig()
if config.ReqReplyStore == "orientdb" or config.ClientIdentityGraph:
try:
self._getOrientDbStore().client.db_drop(self.name)
logger.debug("Dropped db {}".format(self.name))
except Exception as ex:
logger.debug("Error while dropping db {}: {}".format(
self.name, ex))
def build_wallet_core(wallet_name, seed_file):
config = getConfig()
baseDir = os.path.expanduser(config.baseDir)
seedFilePath = '{}/{}'.format(baseDir, seed_file)
seed = wallet_name + '0'*(32 - len(wallet_name))
# if seed file is available, read seed from it
if os.path.isfile(seedFilePath):
with open(seedFilePath, mode='r+') as file:
seed = file.read().strip(' \t\n\r')
wallet = Wallet(wallet_name)
seed = bytes(seed, encoding='utf-8')
wallet.addIdentifier(signer=SimpleSigner(seed=seed))
return wallet
def build_wallet_core(wallet_name, seed_file):
config = getConfig()
baseDir = os.path.expanduser(config.baseDir)
seedFilePath = '{}/{}'.format(baseDir, seed_file)
seed = wallet_name + '0' * (32 - len(wallet_name))
# if seed file is available, read seed from it
if os.path.isfile(seedFilePath):
with open(seedFilePath, mode='r+') as file:
seed = file.read().strip(' \t\n\r')
wallet = Wallet(wallet_name)
seed = bytes(seed, encoding='utf-8')
wallet.addIdentifier(signer=DidSigner(seed=seed))
return wallet
def create_local_pool(base_dir, node_size=4):
conf = getConfig(base_dir)
pool_dir = os.path.join(base_dir, "pool")
# TODO: Need to come back to this why we need this cleanup
shutil.rmtree(pool_dir, ignore_errors=True)
stewards = []
node_conf = []
nodes = []
genesis_txns = []
for i in range(node_size):
w = Wallet("steward")
s = Steward(wallet=w)
s.wallet.addIdentifier()
stewards.append(s)
n_config = adict(name='Node' + str(i + 1),
basedirpath=pool_dir,
ha=('127.0.0.1', 9700 + (i * 2)),
cliha=('127.0.0.1', 9700 + (i * 2) + 1))
n_verkey = initialize_node_environment(name=n_config.name,
base_dir=n_config.basedirpath,
override_keep=True,
config=conf,
sigseed=randomSeed())
s.set_node(n_config, verkey=n_verkey)
node_conf.append(n_config)
genesis_txns += s.generate_genesis_txns()
pool = LocalPool(genesis_txns, pool_dir, steward=stewards[0])
for c in node_conf:
n = Node(**c)
pool.add(n)
nodes.append(n)
pool.runFor(5)
return pool
def create_local_pool(base_dir, node_size=4):
conf = getConfig(base_dir)
pool_dir = os.path.join(base_dir, "pool")
# TODO: Need to come back to this why we need this cleanup
shutil.rmtree(pool_dir, ignore_errors=True)
stewards = []
node_conf = []
nodes = []
genesis_txns = []
for i in range(node_size):
w = Wallet("steward")
s = Steward(wallet=w)
s.wallet.addIdentifier()
stewards.append(s)
n_config = adict(name='Node'+str(i+1),
basedirpath=pool_dir,
ha=('127.0.0.1', 9700+(i * 2)),
cliha=('127.0.0.1', 9700+(i * 2)+1))
n_verkey = initialize_node_environment(name=n_config.name,
base_dir=n_config.basedirpath,
override_keep=True,
config=conf,
sigseed=randomSeed())
s.set_node(n_config, verkey=n_verkey)
node_conf.append(n_config)
genesis_txns += s.generate_genesis_txns()
pool = LocalPool(genesis_txns, pool_dir, steward=stewards[0])
for c in node_conf:
n = Node(**c)
pool.add(n)
nodes.append(n)
pool.runFor(5)
return pool
def buildBulldogWallet():
config = getConfig()
baseDir = os.path.expanduser(config.baseDir)
seedFileName = 'bulldog-seed'
seedFilePath = '{}/{}'.format(baseDir, seedFileName)
seed = 'Bulldog0000000000000000000000000'
# if seed file is available, read seed from it
if os.path.isfile(seedFilePath):
try:
with open(seedFilePath, mode='r+') as file:
seed = file.read().strip(' \t\n\r')
except OSError as e:
bulldogLogger.warn('Error occurred while reading seed file:'
'error:{}'.format(e))
raise e
return buildAgentWallet('Bulldog', bytes(seed, encoding='utf-8'))
def __init__(self,
name: str,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None,
config=None,
endpointArgs=None):
config = config or getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
portParam, _ = self.getPassedArgs()
self.logger = getlogger()
super().__init__(name,
basedirpath,
client,
wallet,
portParam or port,
loop=loop,
config=config,
endpointArgs=endpointArgs)
self.claimVersionNumber = 0.01
# available claims to anyone whose connection is accepted by the agent
self.availableClaimsToAll = []
# available claims only for certain invitation (by nonce)
self.availableClaimsByNonce = {}
# mapping between specific identifier and available claims which would
# have been available once they have provided requested information
# like proof etc.
self.availableClaimsByIdentifier = {}
self._invites = {}
self.updateClaimVersionFile(self.getClaimVersionFileName())
def createAgent(agentClass, name, wallet=None, basedirpath=None, port=None,
loop=None, clientClass=Client):
config = getConfig()
if not wallet:
wallet = Wallet(name)
wallet.addIdentifier(signer=DidSigner(
seed=randomString(32).encode('utf-8')))
if not basedirpath:
basedirpath = config.baseDir
if not port:
_, port = genHa()
client = create_client(base_dir_path=basedirpath, client_class=clientClass)
return agentClass(basedirpath=basedirpath,
client=client,
wallet=wallet,
port=port,
loop=loop)
def __init__(self,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None):
if not basedirpath:
config = getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
portParam, = self.getPassedArgs()
super().__init__('Thrift Bank',
basedirpath,
client,
wallet,
portParam or port,
loop=loop)
# maps invitation nonces to internal ids
self._invites = {"77fbf9dc8c8e6acde33de98c6d747b28c": 1}
def __init__(self,
genesis_txns,
base_dir,
config=None,
loop=None,
steward: Steward = None):
super().__init__(loop=loop)
self.base_dir = base_dir
self.genesis_txns = genesis_txns
self.config = config or getConfig(self.base_dir)
self._generate_genesis_files()
self._steward = steward
if steward is not None:
self._steward_agent = WalletedAgent(
name="steward1",
basedirpath=self.base_dir,
client=self.create_client(5005),
wallet=steward.wallet,
port=8781)
self.add(self._steward_agent)
def __init__(self,
name: str = None,
basedirpath: str = None,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None,
attrRepo=None,
config=None,
endpointArgs=None):
Agent.__init__(self, name, basedirpath, client, port, loop=loop,
config=config, endpointArgs=endpointArgs)
self.config = getConfig(basedirpath)
self._wallet = None
self._walletSaver = None
# restore any active wallet belonging to this agent
self._restoreWallet()
# if no persisted wallet is restored and a wallet is passed,
# then use given wallet, else ignore the given wallet
if not self.wallet and wallet:
self.wallet = wallet
# if wallet is not yet set, then create a wallet
if not self.wallet:
self.wallet = Wallet(name)
self._attrRepo = attrRepo or AttributeRepoInMemory()
Walleted.__init__(self)
if self.client:
self._initIssuerProverVerifier()
self._restoreIssuerWallet()
from plenum.common.util import randomString
from stp_core.loop.eventually import eventually
from plenum.test.helper import waitForSufficientRepliesForRequests
from plenum.test import waits as plenumWaits
from sovrin_client.client.wallet.upgrade import Upgrade
from sovrin_node.server.upgrader import Upgrader
from sovrin_node.utils.node_control_tool import NodeControlTool
from sovrin_common.config_util import getConfig
import subprocess
import os
import multiprocessing
import socket
import json
config = getConfig()
def sendUpgrade(client, wallet, upgradeData):
upgrade = Upgrade(**upgradeData, trustee=wallet.defaultId)
wallet.doPoolUpgrade(upgrade)
reqs = wallet.preparePending()
req, = client.submitReqs(*reqs)
return upgrade, req
def ensureUpgradeSent(looper, trustee, trusteeWallet, upgradeData):
upgrade, req = sendUpgrade(trustee, trusteeWallet, upgradeData)
waitForSufficientRepliesForRequests(looper, trustee, requests=[req])
def check():
def getLoggerFilePath(self, name=None):
config = getConfig()
path = expanduser('{}'.format(config.baseDir))
return '{}/{}.log'.format(path, (name
or self.name).replace(" ",
"-").lower())
def __init__(self,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None):
if not basedirpath:
config = getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
portParam, = self.getPassedArgs()
super().__init__('Acme Corp',
basedirpath,
client,
wallet,
portParam or port,
loop=loop)
self.availableClaims = []
# maps invitation nonces to internal ids
self._invites = {
"57fbf9dc8c8e6acde33de98c6d747b28c": 1,
"3a2eb72eca8b404e8d412c5bf79f2640": 2,
"8513d1397e87cada4214e2a650f603eb": 3,
"810b78be79f29fc81335abaa4ee1c5e8": 4
}
self._attrDefJobCert = AttribDef('Acme Job Certificat', [
AttribType('first_name', encode=True),
AttribType('last_name', encode=True),
AttribType('employee_status', encode=True),
AttribType('experience', encode=True),
AttribType('salary_bracket', encode=True)
])
self._attrDefJobApp = AttribDef('Acme Job Application', [
AttribType('first_name', encode=True),
AttribType('last_name', encode=True),
AttribType('phone_number', encode=True),
AttribType('degree', encode=True),
AttribType('status', encode=True),
AttribType('ssn', encode=True)
])
# maps internal ids to attributes
self._attrsJobCert = {
1:
self._attrDefJobCert.attribs(
first_name="Alice",
last_name="Garcia",
employee_status="Permanent",
experience="3 years",
salary_bracket="between $50,000 to $100,000"),
2:
self._attrDefJobCert.attribs(
first_name="Carol",
last_name="Atkinson",
employee_status="Permanent",
experience="2 years",
salary_bracket="between $60,000 to $90,000"),
3:
self._attrDefJobCert.attribs(
first_name="Frank",
last_name="Jeffrey",
employee_status="Temporary",
experience="4 years",
salary_bracket="between $40,000 to $80,000"),
4:
self._attrDefJobCert.attribs(
first_name="Craig",
last_name="Richards",
employee_status="On Contract",
experience="3 years",
salary_bracket="between $50,000 to $70,000")
}
self._schemaJobCertKey = SchemaKey("Job-Certificate", "0.2",
self.wallet.defaultId)
self._schemaJobAppKey = SchemaKey("Job-Application", "0.2",
self.wallet.defaultId)
def getLoggerFilePath(self, name=None):
config = getConfig()
path = expanduser('{}'.format(config.baseDir))
return '{}/{}.log'.format(path, (name or self.name).replace(" ", "-").lower())
def __init__(self,
basedirpath: str,
client: Client = None,
wallet: Wallet = None,
port: int = None,
loop=None):
if not basedirpath:
config = getConfig()
basedirpath = basedirpath or os.path.expanduser(config.baseDir)
portParam, = self.getPassedArgs()
super().__init__('Faber College',
basedirpath,
client,
wallet,
portParam or port,
loop=loop)
self.availableClaims = []
# maps invitation nonces to internal ids
self._invites = {
"b1134a647eb818069c089e7694f63e6d": 1,
"2a2eb72eca8b404e8d412c5bf79f2640": 2,
"7513d1397e87cada4214e2a650f603eb": 3,
"710b78be79f29fc81335abaa4ee1c5e8": 4
}
self._attrDef = AttribDef('faber', [
AttribType('student_name', encode=True),
AttribType('ssn', encode=True),
AttribType('degree', encode=True),
AttribType('year', encode=True),
AttribType('status', encode=True)
])
# maps internal ids to attributes
self._attrs = {
1:
self._attrDef.attribs(student_name="Alice Garcia",
ssn="123-45-6789",
degree="Bachelor of Science, Marketing",
year="2015",
status="graduated"),
2:
self._attrDef.attribs(student_name="Carol Atkinson",
ssn="783-41-2695",
degree="Bachelor of Science, Physics",
year="2012",
status="graduated"),
3:
self._attrDef.attribs(student_name="Frank Jeffrey",
ssn="996-54-1211",
degree="Bachelor of Arts, History",
year="2013",
status="dropped"),
4:
self._attrDef.attribs(student_name="Craig Richards",
ssn="151-44-5876",
degree="MBA, Finance",
year="2015",
status="graduated")
}
self._schema = SchemaKey("Transcript", "1.2", self.wallet.defaultId)
def _getOrientDbStore(self):
config = getConfig()
return OrientDbStore(user=config.OrientDB["user"],
password=config.OrientDB["password"],
dbName=self.name,
storageType=pyorient.STORAGE_TYPE_MEMORY)
def conf(tdir):
return getConfig(tdir)
from stp_core.loop.looper import Looper
from plenum.test.cli.helper import newKeyPair, waitAllNodesStarted, \
doByCtx
from sovrin_common.config_util import getConfig
from sovrin_client.test.cli.helper import ensureNodesCreated, getLinkInvitation, \
getPoolTxnData, newCLI, getCliBuilder, P, prompt_is, addAgent, doSendNodeCmd
from sovrin_client.test.agent.conftest import faberIsRunning as runningFaber, \
acmeIsRunning as runningAcme, thriftIsRunning as runningThrift, emptyLooper,\
faberWallet, acmeWallet, thriftWallet, agentIpAddress, \
faberAgentPort, acmeAgentPort, thriftAgentPort, faberAgent, acmeAgent, \
thriftAgent, faberBootstrap, acmeBootstrap
config = getConfig()
@pytest.yield_fixture(scope="session")
def cliTempLogger():
file_name = "sovrin_cli_test.log"
file_path = os.path.join(tempfile.tempdir, file_name)
with open(file_path, 'w') as f:
pass
return file_path
@pytest.yield_fixture(scope="module")
def looper():
with Looper(debug=False) as l:
yield l
