def _dump(): logger = getlogger() cli = ctx['current_cli'] nocli = {"cli": False} wrts = ''.join(cli.cli.output.writes) logger.info('=========================================', extra=nocli) logger.info('| OUTPUT DUMP |', extra=nocli) logger.info('-----------------------------------------', extra=nocli) for w in wrts.splitlines(): logger.info('> ' + w, extra=nocli) logger.info('=========================================', extra=nocli)
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())
from sovrin_client.agent.caching import Caching from sovrin_client.agent.endpoint import ZEndpoint, REndpoint from sovrin_client.agent.walleted import Walleted from sovrin_client.anon_creds.sovrin_issuer import SovrinIssuer from sovrin_client.anon_creds.sovrin_prover import SovrinProver from sovrin_client.anon_creds.sovrin_verifier import SovrinVerifier from sovrin_client.client.client import Client from sovrin_client.client.wallet.wallet import Wallet from sovrin_common.config import agentLoggingLevel from sovrin_common.config_util import getConfig from sovrin_common.identity import Identity from sovrin_common.strict_types import strict_types, decClassMethods from stp_core.network.port_dispenser import genHa from plenum.common.util import randomString logger = getlogger() logger.setLevel(agentLoggingLevel) @decClassMethods(strict_types()) class Agent(Motor, AgentNet): def __init__(self, name: str = None, basedirpath: str = None, client: Client = None, port: int = None, loop=None, config=None, endpointArgs=None): self.endpoint = None
import time from ledger.ledger import Ledger from ledger.merkle_verifier import MerkleVerifier from ledger.util import F from plenum.common.exceptions import RemoteNotFound from plenum.common.startable import LedgerState from plenum.common.types import LedgerStatus, CatchupRep, ConsistencyProof, f, \ CatchupReq, ConsProofRequest from plenum.common.util import getMaxFailures from plenum.common.config_util import getConfig from plenum.common.log import getlogger from plenum.server.has_action_queue import HasActionQueue logger = getlogger() class LedgerManager(HasActionQueue): def __init__(self, owner, ownedByNode: bool=True): self.owner = owner self.ownedByNode = ownedByNode self.config = getConfig() # Needs to schedule actions. The owner of the manager has the # responsibility of calling its `_serviceActions` method periodically. HasActionQueue.__init__(self) # Holds ledgers of different types with their info like the ledger # object, various callbacks, state (can be synced, is already synced, # etc). self.ledgers = {} # type: Dict[int, Dict[str, Any]]
class PortDispenser: """ This class provides a system-wide mechanism to provide a available socket ports for testing. Tests should call getNext to get the next available port. There is no guarantee of sequential port numbers, as other tests running concurrently might grab a port before one process is done getting all the ports it needs. This should pose no problem, as tests shouldn't depend on port numbers. It leverages the filesystem lock mechanism to ensure there are no overlaps. """ maxportretries = 3 logger = log.getlogger() def __init__(self, ip: str, filename: str = None, minPort=6000, maxPort=9999): self.ip = ip self.FILE = filename or os.path.join( tempfile.gettempdir(), 'plenum-portmutex.{}.txt'.format(ip)) self.minPort = minPort self.maxPort = maxPort self.initFile() def initFile(self): if not os.path.exists(self.FILE): with open(self.FILE, "w") as file: file.write(str(self.minPort)) def get(self, count: int = 1, readOnly: bool = False, recurlvl=0): with open(self.FILE, "r+") as file: portalocker.lock(file, portalocker.LOCK_EX) ports = [] while len(ports) < count: file.seek(0) port = int(file.readline()) if readOnly: return port port += 1 if port > self.maxPort: port = self.minPort file.seek(0) file.write(str(port)) try: checkPortAvailable(("", port)) ports.append(port) self.logger.debug("new port dispensed: {}".format(port)) except: if recurlvl < self.maxportretries: self.logger.debug( "port {} unavailable, trying again...".format( port)) else: self.logger.debug( "port {} unavailable, max retries {} " "reached".format(port, self.maxportretries)) raise return ports def getNext(self, count: int = 1): has = [HA(self.ip, port) for port in self.get(count)] if len(has) == 1: return has[0] else: return has
import logging # The following setup of logging needs to happen before everything else from plenum.common.log import getlogger from sovrin.anon_creds.cred_def import CredDef from sovrin.anon_creds.issuer import InMemoryAttrRepo from sovrin.anon_creds.proof_builder import ProofBuilder from sovrin.anon_creds.verifier import Verifier from plenum.common.txn_util import createGenesisTxnFile from ioflo.aid.consoling import Console logging.root.handlers = [] # setupLogging(DISPLAY_LOG_LEVEL, # Console.Wordage.mute) logger = getlogger("anon_creds_demo") from plenum.client.signer import SimpleSigner from plenum.common.looper import Looper from plenum.common.txn import DATA, ORIGIN from plenum.common.txn import TXN_TYPE from plenum.test.helper import genHa, ensureElectionsDone, \ checkNodesConnected, genNodeReg from sovrin.test.helper import genTestClient, submitAndCheck, createNym, \ TestNodeSet, _newWallet, makePendingTxnsRequest from sovrin.common.txn import CRED_DEF, SPONSOR, getTxnOrderedFields from sovrin.test.conftest import genesisTxns from sovrin.common.util import getCredDefTxnData, getConfig import sovrin.anon_creds.issuer as IssuerModule import sovrin.anon_creds.prover as ProverModule
def testAnonCredFlow(genned, looper, tdir, nodeSet, issuerWallet: Wallet, proverWallet: Wallet, verifierWallet, addedIPV): # Don't move the following import outside of this method, otherwise that # client class doesn't gets reloaded and it doesn't get updated with the # correct plugin class/methods and it gives an error. # (for permanent solution bug is created: #130181205) from sovrin.test.helper import genTestClient BYU = IssuerModule.AttribDef('BYU', [ IssuerModule.AttribType("first_name", encode=True), IssuerModule.AttribType("last_name", encode=True), IssuerModule.AttribType("birth_date", encode=True), IssuerModule.AttribType("expire_date", encode=True), IssuerModule.AttribType("undergrad", encode=True), IssuerModule.AttribType("postgrad", encode=True) ]) setupLogging(DISPLAY_LOG_LEVEL, Console.Wordage.mute) logger = getlogger("test_anon_creds") logging.root.addHandler(DemoHandler(partial(out, logger))) logging.root.handlers = [] attributes = BYU.attribs(first_name="John", last_name="Doe", birth_date="1970-01-01", expire_date="2300-01-01", undergrad="True", postgrad="False") attrNames = tuple(attributes.keys()) # 3 Sovrin clients acting as Issuer, Signer and Verifier issuerC, _ = genTestClient(nodeSet, tmpdir=tdir, peerHA=genHa()) proverC, _ = genTestClient(nodeSet, tmpdir=tdir, peerHA=genHa()) verifierC, _ = genTestClient(nodeSet, tmpdir=tdir, peerHA=genHa()) looper.add(issuerC) looper.add(proverC) looper.add(verifierC) looper.run(issuerC.ensureConnectedToNodes(), proverC.ensureConnectedToNodes(), verifierC.ensureConnectedToNodes()) makePendingTxnsRequest(issuerC, issuerWallet) makePendingTxnsRequest(proverC, proverWallet) makePendingTxnsRequest(verifierC, verifierWallet) # Adding signers # issuer.signers[issuerSigner.identifier] = issuerSigner logger.display("Key pair for Issuer created \n" "Public key is {} \n" "Private key is stored on disk\n".format( issuerWallet.defaultId)) # prover.signers[proverSigner.identifier] = proverSigner logger.display("Key pair for Prover created \n" "Public key is {} \n" "Private key is stored on disk\n".format( proverWallet.defaultId)) # verifier.signers[verifierSigner.identifier] = verifierSigner logger.display("Key pair for Verifier created \n" "Public key is {} \n" "Private key is stored on disk\n".format( verifierWallet.defaultId)) # TODO BYU.name is used here instead of issuerSigner.identifier due to # tight coupling in Attribs.encoded() issuerId = BYU.name proverId = proverWallet.defaultId # Issuer's attribute repository attrRepo = IssuerModule.InMemoryAttrRepo() attrRepo.attributes = {proverId: attributes} name1 = "Qualifications" version1 = "1.0" ip = issuerC.peerHA[0] port = issuerC.peerHA[1] interactionId = 'LOGIN-1' # This is the issuer entity issuer = IssuerModule.Issuer(issuerId, attrRepo) # issuer.attributeRepo = attrRepo # Issuer publishes credential definition to Sovrin ledger csk = CredDefSecretKey(*staticPrimes().get("prime1")) cskId = issuerWallet.addCredDefSk(str(csk)) credDef = CredDef(seqNo=None, attrNames=attrNames, name=name1, version=version1, origin=issuerWallet.defaultId, secretKey=cskId) # credDef = issuer.addNewCredDef(attrNames, name1, version1, # p_prime="prime1", q_prime="prime1", ip=ip, # port=port) # issuer.credentialDefinitions = {(name1, version1): credDef} logger.display("Issuer: Creating version {} of credential definition" " for {}".format(version1, name1)) print("Credential definition: ") pprint.pprint(credDef.get()) # Pretty-printing the big object. pending = issuerWallet.addCredDef(credDef) reqs = issuerWallet.preparePending() # op = {TXN_TYPE: CRED_DEF, # DATA: getCredDefTxnData(credDef)} logger.display("Issuer: Writing credential definition to " "Sovrin Ledger...") issuerC.submitReqs(*reqs) def chk(): assert issuerWallet.getCredDef( (name1, version1, issuerWallet.defaultId)).seqNo is not None looper.run(eventually(chk, retryWait=.1, timeout=30)) # submitAndCheck(looper, issuerC, issuerWallet, op) # Prover requests Issuer for credential (out of band) logger.display("Prover: Requested credential from Issuer") # Issuer issues a credential for prover logger.display("Issuer: Creating credential for " "{}".format(proverWallet.defaultId)) encodedAttributes = attributes.encoded() revealedAttrs = ["undergrad"] prover = ProverModule.Prover(proverId) pk = {issuerId: prover.getPk(credDef)} proofBuilder = ProofBuilderModule.ProofBuilder(pk) proofId = proofBuilder.id prover.proofBuilders[proofId] = proofBuilder cred = issuer.createCred(proverId, name1, version1, proofBuilder.U[issuerId]) logger.display("Prover: Received credential from " "{}".format(issuerWallet.defaultId)) # Prover intends to prove certain attributes to a Verifier # Verifier issues a nonce logger.display("Prover: Requesting Nonce from verifier…") logger.display("Verifier: Nonce received from prover" " {}".format(proverId)) verifierId = verifierWallet.defaultId verifier = VerifierModule.Verifier(verifierId) nonce = verifier.generateNonce(interactionId) logger.display("Verifier: Nonce sent.") logger.display("Prover: Nonce received") presentationToken = { issuerId: (cred[0], cred[1], proofBuilder.vprime[issuerId] + cred[2]) } # Prover discovers Issuer's credential definition logger.display("Prover: Preparing proof for attributes: " "{}".format(revealedAttrs)) proofBuilder.setParams(presentationToken, revealedAttrs, nonce) prf = ProofBuilderModule.ProofBuilder.prepareProof( credDefPks=proofBuilder.credDefPks, masterSecret=proofBuilder.masterSecret, creds=presentationToken, encodedAttrs=encodedAttributes, revealedAttrs=revealedAttrs, nonce=nonce) logger.display("Prover: Proof prepared.") logger.display("Prover: Proof submitted") logger.display("Verifier: Proof received.") logger.display("Verifier: Looking up Credential Definition" " on Sovrin Ledger...") # Verifier fetches the credential definition from ledger verifier.credentialDefinitions = {(issuerId, name1, version1): credDef} verified = VerifierModule.Verifier.verifyProof(pk, prf, nonce, attributes.encoded(), revealedAttrs) # Verifier verifies proof logger.display("Verifier: Verifying proof...") logger.display("Verifier: Proof verified.") assert verified logger.display("Prover: Proof accepted.")
import importlib import os from plenum.common.util import getConfig from plenum.common.log import getlogger pluginsLoaded = {} # Dict(baseDir, List[plugin names]) pluginsNotFound = {} # Dict(baseDir, List[plugin names]) logger = getlogger("plugin-loader") def loadPlugins(baseDir): global pluginsLoaded alreadyLoadedPlugins = pluginsLoaded.get(baseDir) i = 0 if alreadyLoadedPlugins: logger.debug("Plugins {} are already loaded from basedir: {}".format( alreadyLoadedPlugins, baseDir)) else: logger.debug( "Plugin loading started to load plugins from basedir: {}".format( baseDir)) config = getConfig() pluginsDirPath = os.path.expanduser( os.path.join(baseDir, config.PluginsDir)) if not os.path.exists(pluginsDirPath):
from importlib.util import module_from_spec, spec_from_file_location import os from plenum.common.config_util import getConfig from plenum.common.log import getlogger pluginsLoaded = {} # Dict(baseDir, List[plugin names]) pluginsNotFound = {} # Dict(baseDir, List[plugin names]) logger = getlogger("plugin-loader") def loadPlugins(baseDir): global pluginsLoaded alreadyLoadedPlugins = pluginsLoaded.get(baseDir) i = 0 if alreadyLoadedPlugins: logger.debug("Plugins {} are already loaded from basedir: {}".format( alreadyLoadedPlugins, baseDir)) else: logger.debug( "Plugin loading started to load plugins from basedir: {}".format( baseDir)) config = getConfig() pluginsDirPath = os.path.expanduser(os.path.join( baseDir, config.PluginsDir)) if not os.path.exists(pluginsDirPath): os.makedirs(pluginsDirPath)