def setupWitness(name="witness", temp=False, localPort=5621, ):
"""
"""
# setup databases for dependency injection
ks = keeping.Keeper(name=name, temp=temp) # default is to not reopen
ksDoer = keeping.KeeperDoer(keeper=ks) # doer do reopens if not opened and closes
db = basing.Baser(name=name, temp=temp) # default is to not reopen
dbDoer = basing.BaserDoer(baser=db) # doer do reopens if not opened and closes
# setup habitat
wsith = 1
hab = habbing.Habitat(name=name, ks=ks, db=db, temp=temp, transferable=False,
isith=wsith, icount=1, )
habDoer = habbing.HabitatDoer(habitat=hab) # setup doer
verfer = verifying.Verifier(name=name, hab=hab)
mbx = exchanging.Mailboxer()
exc = exchanging.StoreExchanger(hab=hab, mbx=mbx)
# setup doers
regDoer = basing.BaserDoer(baser=verfer.reger)
server = serving.Server(host="", port=localPort)
serverDoer = serving.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server, verifier=verfer, exc=exc)
mbxer = httping.MailboxServer(port=7777, hab=hab, mbx=mbx)
logger.info("\nWitness- %s:\nNamed %s on TCP port %s.\n\n",
hab.pre, hab.name, localPort)
return [ksDoer, dbDoer, habDoer, regDoer, directant, serverDoer, mbxer]
def setupController(name="who", sith=None, count=1, temp=False,
remotePort=5621, localPort=5620):
"""
Setup and return doers list to run controller
"""
# setup habitat
hab = habbing.Habitat(name=name, isith=sith, icount=count, temp=temp)
logger.info("\nDirect Mode controller %s:\nNamed %s on TCP port %s to port %s.\n\n",
hab.pre, hab.name, localPort, remotePort)
# setup doers
ksDoer = keeping.KeeperDoer(keeper=hab.ks) # doer do reopens if not opened and closes
dbDoer = basing.BaserDoer(baser=hab.db) # doer do reopens if not opened and closes
# setup wirelog to create test vectors
path = os.path.dirname(__file__)
path = os.path.join(path, 'logs')
wl = wiring.WireLog(samed=True, filed=True, name=name, prefix='keri',
reopen=True, headDirPath=path)
wireDoer = wiring.WireLogDoer(wl=wl)
client = clienting.Client(host='127.0.0.1', port=remotePort, wl=wl)
clientDoer = doing.ClientDoer(client=client)
director = Director(hab=hab, client=client, tock=0.125)
reactor = Reactor(hab=hab, client=client)
server = serving.Server(host="", port=localPort, wl=wl)
serverDoer = doing.ServerDoer(server=server)
directant = Directant(hab=hab, server=server)
# Reactants created on demand by directant
return [ksDoer, dbDoer, wireDoer, clientDoer, director, reactor, serverDoer, directant]
def adminInterface(controller, hab, adminHttpPort=5623, adminTcpPort=5624):
rotateHandler = agenting.RotateHandler(hab=hab)
issueHandler = agenting.IssueCredentialHandler(hab=hab)
handlers = [rotateHandler, issueHandler]
exchanger = exchanging.Exchanger(hab=hab,
controller=controller,
handlers=handlers)
server = tcpServing.Server(host="", port=adminTcpPort)
tcpServerDoer = tcpServing.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server)
app = falcon.App()
exnServer = httping.AgentExnServer(exc=exchanger, app=app)
httpKelServer = httping.AgentKelServer(hab=hab, app=app)
server = http.Server(port=adminHttpPort, app=exnServer.app)
httpServerDoer = http.ServerDoer(server=server)
doers = [
exnServer, exchanger, tcpServerDoer, directant, httpKelServer,
httpServerDoer
]
return doers
def setupWitness(name="witness", localPort=5620):
wsith = 1
hab = habbing.Habitat(
name=name,
temp=False,
transferable=False,
isith=wsith,
icount=1,
)
verf = verifying.Verifier(name=name, hab=hab)
logger.info("\nWitness- %s:\nNamed %s on TCP port %s.\n\n", hab.pre,
hab.name, localPort)
# setup doers
ksDoer = keeping.KeeperDoer(
keeper=hab.ks) # doer do reopens if not opened and closes
dbDoer = basing.BaserDoer(
baser=hab.db) # doer do reopens if not opened and closes
regDoer = basing.BaserDoer(baser=verf.reger)
server = serving.Server(host="", port=localPort)
serverDoer = doing.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server, verifier=verf)
return [ksDoer, dbDoer, regDoer, directant, serverDoer]
def setupController(secrets, name="who", remotePort=5621, localPort=5620):
"""
Setup and return doers list to run controller
"""
# setup components
db = dbing.Baser(name=name, temp=True, reopen=False)
dbDoer = dbing.BaserDoer(baser=db)
kevers = dict()
hab = Habitat(secrets=secrets, kevers=kevers, db=db)
print("Direct Mode demo of {} as {} on TCP port {} to port {}.\n\n"
"".format(name, hab.pre, localPort, remotePort))
client = clienting.Client(host='127.0.0.1', port=remotePort)
clientDoer = doing.ClientDoer(client=client)
if name == 'bob':
director = BobDirector(hab=hab, client=client, tock=0.125)
elif name == "sam":
director = SamDirector(hab=hab, client=client, tock=0.125)
else:
director = EveDirector(hab=hab, client=client, tock=0.125)
reactor = Reactor(hab=hab, client=client)
server = serving.Server(host="", port=localPort)
serverDoer = doing.ServerDoer(server=server)
directant = Directant(hab=hab, server=server)
# Reactants created on demand
return [dbDoer, clientDoer, director, reactor, serverDoer, directant]
def setupDemoController(secrets,
name="who",
remotePort=5621,
localPort=5620,
indirect=False,
remotePre=""):
"""
Setup and return doers list to run controller
"""
secrecies = []
for secret in secrets: # convert secrets to secrecies
secrecies.append([secret])
# setup habitat
hab = habbing.Habitat(name=name, secrecies=secrecies, temp=True)
logger.info(
"\nDirect Mode demo of %s:\nNamed %s on TCP port %s to port %s.\n\n",
hab.pre, hab.name, localPort, remotePort)
# setup doers
ksDoer = keeping.KeeperDoer(
keeper=hab.ks) # doer do reopens if not opened and closes
dbDoer = basing.BaserDoer(
baser=hab.db) # doer do reopens if not opened and closes
# setup wirelog to create test vectors
path = os.path.dirname(__file__)
path = os.path.join(path, 'logs')
wl = wiring.WireLog(samed=True,
filed=True,
name=name,
prefix='demo',
reopen=True,
headDirPath=path)
wireDoer = wiring.WireLogDoer(wl=wl)
client = clienting.Client(host='127.0.0.1', port=remotePort, wl=wl)
clientDoer = doing.ClientDoer(client=client)
if name == 'bob':
director = BobDirector(hab=hab, client=client, tock=0.125)
elif name == "sam":
director = SamDirector(hab=hab, client=client, tock=0.125)
elif name == 'eve':
director = EveDirector(hab=hab, client=client, tock=0.125)
else:
raise ValueError("Invalid director name={}.".format(name))
reactor = directing.Reactor(hab=hab, client=client, indirect=indirect)
server = serving.Server(host="", port=localPort, wl=wl)
serverDoer = doing.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server)
# Reactants created on demand by directant
return [
ksDoer, dbDoer, wireDoer, clientDoer, director, reactor, serverDoer,
directant
]
def runAgent(controller,
name="agent",
httpPort=5620,
tcp=5621,
adminHttpPort=5623,
adminTcpPort=5624,
expire=0.0):
"""
Setup and run one agent
"""
logger = help.ogler.getLogger()
ks = keeping.Keeper(name=name,
temp=False) # not opened by default, doer opens
ksDoer = keeping.KeeperDoer(
keeper=ks) # doer do reopens if not opened and closes
db = basing.Baser(name=name, temp=False,
reload=True) # not opened by default, doer opens
dbDoer = basing.BaserDoer(
baser=db) # doer do reopens if not opened and closes
# setup habitat
hab = habbing.Habitat(name=name, ks=ks, db=db, temp=False, create=False)
habDoer = habbing.HabitatDoer(habitat=hab) # setup doer
# kvy = eventing.Kevery(db=hab.db, local=False)
# setup doers
server = tcpServing.Server(host="", port=tcp)
tcpServerDoer = tcpServing.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server)
wallet = walleting.Wallet(hab=hab, name=name)
jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache)
issueHandler = handling.IssueHandler(wallet=wallet, typ=jsonSchema)
requestHandler = handling.RequestHandler(wallet=wallet, typ=jsonSchema)
exchanger = exchanging.Exchanger(hab=hab,
handlers=[issueHandler, requestHandler])
app = falcon.App()
exnServer = httping.AgentExnServer(exc=exchanger, app=app)
httpKelServer = httping.AgentKelServer(hab=hab, app=app)
server = http.Server(port=httpPort, app=exnServer.app)
httpServerDoer = http.ServerDoer(server=server)
doers = [
ksDoer, dbDoer, habDoer, exchanger, directant, tcpServerDoer,
exnServer, httpServerDoer, httpKelServer
]
doers.extend(adminInterface(controller, hab, adminHttpPort, adminTcpPort))
try:
tock = 0.03125
doist = doing.Doist(limit=expire, tock=tock, real=True)
doist.do(doers=doers)
except kering.ConfigurationError:
print(f"prefix for {name} does not exist, incept must be run first", )
def test_echo_server_client():
"""
Test EchoServerDoer ClientDoer classes
"""
tock = 0.03125
ticks = 16
limit = ticks * tock
doist = doing.Doist(tock=tock, real=True, limit=limit)
assert doist.tyme == 0.0 # on next cycle
assert doist.tock == tock == 0.03125
assert doist.real == True
assert doist.limit == limit == 0.5
assert doist.doers == []
port = 6120
server = serving.Server(host="", port=port)
client = clienting.Client(tymth=doist.tymen(), host="localhost", port=port)
serdoer = doing.EchoServerDoer(tymth=doist.tymen(), server=server)
assert serdoer.server == server
assert serdoer.tyme == serdoer.server.tyme == doist.tyme
clidoer = doing.ClientDoer(tymth=doist.tymen(), client=client)
assert clidoer.client == client
assert clidoer.tyme == clidoer.client.tyme == doist.tyme
assert serdoer.tock == 0.0 # ASAP
assert clidoer.tock == 0.0 # ASAP
doers = [serdoer, clidoer]
msgTx = b"Hello me maties!"
clidoer.client.tx(msgTx)
doist.do(doers=doers)
assert doist.tyme == limit
assert server.opened == False
assert client.opened == False
assert not client.txbs
msgEx = bytes(client.rxbs) # echoed back message
assert msgEx == msgTx
ca, ix = list(server.ixes.items())[0]
assert bytes(ix.rxbs) == b"" # empty server rxbs becaue echoed
"""End Test """
def test_server_client():
"""
Test ServerDoer ClientDoer classes
"""
tock = 0.03125
ticks = 16
limit = ticks * tock
doist = doing.Doist(tock=tock, real=True, limit=limit)
assert doist.tyme == 0.0 # on next cycle
assert doist.tock == tock == 0.03125
assert doist.real == True
assert doist.limit == limit == 0.5
assert doist.doers == []
port = 6120
server = serving.Server(host="", port=port)
# client needs tymth in order to init its .tymer
client = clienting.Client(tymth=doist.tymen(), host="localhost", port=port)
assert client.tyme == doist.tyme
serdoer = doing.ServerDoer(tymth=doist.tymen(), server=server)
assert serdoer.server == server
assert serdoer.tyme == serdoer.server.tyme == doist.tyme
clidoer = doing.ClientDoer(tymth=doist.tymen(), client=client)
assert clidoer.client == client
assert clidoer.tyme == clidoer.client.tyme == doist.tyme
assert serdoer.tock == 0.0 # ASAP
assert clidoer.tock == 0.0 # ASAP
doers = [serdoer, clidoer]
msgTx = b"Hello me maties!"
clidoer.client.tx(msgTx)
doist.do(doers=doers)
assert doist.tyme == limit
assert server.opened == False
assert client.opened == False
assert not client.txbs
ca, ix = list(server.ixes.items())[0]
msgRx = bytes(ix.rxbs)
assert msgRx == msgTx
"""End Test """
def handle(args):
print(args)
hab = habbing.Habitat(name='kli', temp=False)
tock = 0.03125
host = '127.0.0.1'
port = args.port
klis = koming.Komer(db=hab.db, schema=KLIRecord, subkey='kli.')
klis.put((hab.pre, ), KLIRecord(
host=host,
port=port,
))
# doist = doing.Doist(tock=tock, real=True)
# print("client", host, port)
# client = clienting.Client(host=host, port=port, tymth=doist.tymen())
# clientDoer = clienting.ClientDoer(client=client)
# initDoer = InitDoer(client=client, tymth=doist.tymen())
#
# doist.doers = [clientDoer, initDoer]
# doist.do()
doist = doing.Doist(tock=tock, real=True)
server = serving.Server(host='127.0.0.1', port=5678)
serverDoer = serving.ServerDoer(server=server)
servingDoDoer = Serving(server=server, doers=doist.doers)
doist.extend([serverDoer, servingDoDoer])
daemon = daemonocle.Daemon(
worker=doist.do,
# update to use pidPath serving.getPIDPath()
pid_file='/tmp/klid.pid',
# detach=detach,
)
daemon.do_action('start')
def runController(secrets,
name="who",
role="initiator",
remotePort=5621,
localPort=5620,
limit=0.0):
"""
Setup and run the demo for name
"""
print("Direct Mode demo of {} as {} on TCP port {} to port {}.\n\n"
"".format(name, role, localPort, remotePort))
with dbing.openLogger(name=name) as db:
# setup components
kevers = dict()
hab = Habitat(secrets=secrets, kevers=kevers, db=db)
client = clienting.Client(host='127.0.0.1', port=remotePort)
clientDoer = doing.ClientDoer(client=client)
if role == "initiator":
director = BobDirector(hab=hab, client=client, tock=0.125)
elif role == "other":
director = SamDirector(hab=hab, client=client, tock=0.125)
else:
director = EveDirector(hab=hab, client=client, tock=0.125)
reactor = Reactor(hab=hab, client=client)
server = serving.Server(host="", port=localPort)
serverDoer = doing.ServerDoer(server=server)
directant = Directant(hab=hab, server=server)
# Reactants created on demand
# run components
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock, real=True)
doers = [clientDoer, director, reactor, serverDoer, directant]
doist.do(doers=doers)
def test_direct_mode_bob_eve_demo():
"""
Test direct mode bob and eve
"""
help.ogler.resetLevel(level=logging.DEBUG)
# set of secrets (seeds for private keys)
bobSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
bobSecrecies = []
for secret in bobSecrets: # convert secrets to secrecies
bobSecrecies.append([secret])
# create bob signers
bobSigners = [coring.Signer(qb64=secret) for secret in bobSecrets]
assert [signer.qb64 for signer in bobSigners] == bobSecrets
# bob inception transferable (nxt digest not empty)
bobSerder = eventing.incept(
keys=[bobSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[bobSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
bob = bobSerder.ked["i"]
assert bob == 'EH7Oq9oxCgYa-nnNLvwhp9sFZpALILlRYyB-6n4WDi7w'
# set of secrets (seeds for private keys)
eveSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
eveSecrecies = []
for secret in eveSecrets: # convert secrets to secrecies
eveSecrecies.append([secret])
# create eve signers
eveSigners = [coring.Signer(qb64=secret) for secret in eveSecrets]
assert [signer.qb64 for signer in eveSigners] == eveSecrets
# eve inception transferable (nxt digest not empty)
eveSerder = eventing.incept(
keys=[eveSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[eveSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
eve = eveSerder.ked["i"]
assert eve == 'EpDA1n-WiBA0A8YOqnKrB-wWQYYC49i5zY_qrIZIicQg'
with dbing.openDB(name="eve") as eveDB, keeping.openKS(name="eve") as eveKS, \
dbing.openDB(name="bob") as bobDB, keeping.openKS(name="bob") as bobKS:
limit = 1.0
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
bobPort = 5620 # bob's TCP listening port for server
evePort = 5621 # eve's TCP listneing port for server
bobKevers = dict()
eveKevers = dict()
# setup bob
bobHab = directing.Habitat(name='Bob',
ks=bobKS,
db=bobDB,
kevers=bobKevers,
secrecies=bobSecrecies,
temp=True)
assert bobHab.ks == bobKS
assert bobHab.db == bobDB
assert bobHab.iserder.dig == bobSerder.dig
assert bobHab.pre == bob
bobClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=evePort)
bobClientDoer = doing.ClientDoer(client=bobClient)
bobDirector = demoing.BobDirector(hab=bobHab,
client=bobClient,
tock=0.125)
assert bobDirector.hab == bobHab
assert bobDirector.client == bobClient
assert bobDirector.hab.kvy.kevers == bobKevers
assert bobDirector.hab.kvy.db == bobDB
assert bobDirector.tock == 0.125
bobReactor = directing.Reactor(hab=bobHab, client=bobClient)
assert bobReactor.hab == bobHab
assert bobReactor.client == bobClient
assert bobReactor.hab.kvy.kevers == bobKevers
assert bobReactor.hab.kvy.db == bobDB
assert bobReactor.hab.kvy.ims == bobReactor.client.rxbs
bobServer = serving.Server(host="", port=bobPort)
bobServerDoer = doing.ServerDoer(server=bobServer)
bobDirectant = directing.Directant(hab=bobHab, server=bobServer)
assert bobDirectant.hab == bobHab
assert bobDirectant.server == bobServer
# Bob's Reactants created on demand
# setup eve
eveHab = directing.Habitat(name='Eve',
ks=eveKS,
db=eveDB,
kevers=eveKevers,
secrecies=eveSecrecies,
temp=True)
assert eveHab.ks == eveKS
assert eveHab.db == eveDB
assert eveHab.iserder.dig == eveSerder.dig
assert eveHab.pre == eve
eveClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=bobPort)
eveClientDoer = doing.ClientDoer(client=eveClient)
eveDirector = demoing.EveDirector(hab=eveHab,
client=eveClient,
tock=0.125)
assert eveDirector.hab == eveHab
assert eveDirector.client == eveClient
assert eveDirector.hab.kvy.kevers == eveKevers
assert eveDirector.hab.kvy.db == eveDB
eveReactor = directing.Reactor(hab=eveHab, client=eveClient)
assert eveReactor.hab == eveHab
assert eveReactor.client == eveClient
assert eveReactor.hab.kvy.kevers == eveKevers
assert eveReactor.hab.kvy.db == eveDB
assert eveReactor.hab.kvy.ims == eveReactor.client.rxbs
eveServer = serving.Server(host="", port=evePort)
eveServerDoer = doing.ServerDoer(server=eveServer)
eveDirectant = directing.Directant(hab=eveHab, server=eveServer)
assert eveDirectant.hab == eveHab
assert eveDirectant.server == eveServer
# Eve's Reactants created on demand
doers = [
bobClientDoer, bobDirector, bobReactor, bobServerDoer,
bobDirectant, eveClientDoer, eveDirector, eveReactor,
eveServerDoer, eveDirectant
]
doist.do(doers=doers)
assert doist.tyme == limit
assert bobClient.opened == False
assert bobServer.opened == False
assert eveClient.opened == False
assert eveServer.opened == False
assert bobHab.pre in bobHab.kevers
assert eveHab.pre in eveHab.kevers
assert not bobClient.txbs
assert bobHab.pre in eveHab.kevers
# verify final event states
assert not os.path.exists(eveDB.path)
assert not os.path.exists(bobDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def setupController(secrets, witnessPort=5631, localPort=5629, indirect=False):
"""
Setup and return doers list to run controller
"""
secrecies = []
for secret in secrets: # convert secrets to secrecies
secrecies.append([secret])
# setup habitat
hab = habbing.Habitat(name="han", secrecies=secrecies, temp=True)
logger.info(
"\nDirect Mode demo of %s:\nNamed %s listening on TCP port %s, witness on TCP Port %s.\n\n",
hab.pre, hab.name, localPort, witnessPort)
wallet = walleting.Wallet(hab=hab, name="han")
# setup doers
ksDoer = keeping.KeeperDoer(
keeper=hab.ks) # doer do reopens if not opened and closes
dbDoer = basing.BaserDoer(
baser=hab.db) # doer do reopens if not opened and closes
pdbDoer = basing.BaserDoer(
baser=wallet.db) # doer do reopens if not opened and closes
path = os.path.dirname(__file__)
path = os.path.join(path, 'logs')
wl = wiring.WireLog(samed=True,
filed=True,
name="han",
prefix='demo',
reopen=True,
headDirPath=path)
wireDoer = wiring.WireLogDoer(wl=wl)
jsonSchema = scheming.JSONSchema(resolver=scheming.jsonSchemaCache)
issueHandler = handling.IssueHandler(wallet=wallet, typ=jsonSchema)
requestHandler = handling.RequestHandler(wallet=wallet, typ=jsonSchema)
witnessClient = clienting.Client(host='127.0.0.1', port=witnessPort, wl=wl)
witnessClientDoer = clienting.ClientDoer(client=witnessClient)
excDoer = exchanging.Exchanger(hab=hab,
handlers=[issueHandler, requestHandler])
director = HanDirector(hab=hab,
client=witnessClient,
exchanger=excDoer,
tock=0.125,
wallet=wallet)
reactor = directing.Reactor(hab=hab,
client=witnessClient,
indirect=indirect)
server = serving.Server(host="", port=localPort)
serverDoer = serving.ServerDoer(server=server)
directant = directing.Directant(hab=hab, server=server, exchanger=excDoer)
return [
ksDoer, dbDoer, pdbDoer, excDoer, wireDoer, witnessClientDoer,
director, reactor, serverDoer, directant
]
def test_directing_basic():
"""
Test directing
"""
help.ogler.resetLevel(level=logging.DEBUG)
# set of secrets (seeds for private keys)
bobSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
bobSecrecies = []
for secret in bobSecrets: # convert secrets to secrecies
bobSecrecies.append([secret])
# create bob signers
bobSigners = [coring.Signer(qb64=secret) for secret in bobSecrets]
assert [signer.qb64 for signer in bobSigners] == bobSecrets
# bob inception transferable (nxt digest not empty)
bobSerder = eventing.incept(
keys=[bobSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[bobSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
bob = bobSerder.ked["i"]
assert bob == 'EQf1hzB6s5saaQPdDAsEzSMEFoQx_WLsq93bjPu5wuqA'
# set of secrets (seeds for private keys)
eveSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
eveSecrecies = []
for secret in eveSecrets: # convert secrets to secrecies
eveSecrecies.append([secret])
# create eve signers
eveSigners = [coring.Signer(qb64=secret) for secret in eveSecrets]
assert [signer.qb64 for signer in eveSigners] == eveSecrets
# eve inception transferable (nxt digest not empty)
eveSerder = eventing.incept(
keys=[eveSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[eveSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
eve = eveSerder.ked["i"]
assert eve == 'ED9EB3sA5u2vCPOEmX3d7bEyHiSh7Xi8fjew2KMl3FQM'
with dbing.openDB(name="eve") as eveDB, keeping.openKS(name="eve") as eveKS, \
dbing.openDB(name="bob") as bobDB, keeping.openKS(name="bob") as bobKS:
limit = 0.125
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
bobPort = 5620 # bob's TCP listening port for server
evePort = 5621 # eve's TCP listneing port for server
bobKevers = dict()
eveKevers = dict()
# setup bob
bobHab = directing.Habitat(ks=bobKS,
db=bobDB,
kevers=bobKevers,
secrecies=bobSecrecies,
temp=True)
assert bobHab.ks == bobKS
assert bobHab.db == bobDB
assert bobHab.iserder.dig == bobSerder.dig
assert bobHab.pre == bob
bobClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=evePort)
bobClientDoer = doing.ClientDoer(tymth=doist.tymen(), client=bobClient)
bobDirector = directing.Director(hab=bobHab, client=bobClient)
assert bobDirector.hab == bobHab
assert bobDirector.client == bobClient
assert id(bobDirector.hab.kvy.kevers) == id(bobKevers)
assert bobDirector.hab.kvy.db == bobDB
bobReactor = directing.Reactor(hab=bobHab, client=bobClient)
assert bobReactor.hab == bobHab
assert bobReactor.client == bobClient
assert id(bobReactor.hab.kvy.kevers) == id(bobKevers)
assert bobReactor.hab.kvy.db == bobDB
assert id(bobReactor.kevery.ims) == id(bobReactor.client.rxbs)
assert id(bobReactor.client.rxbs) == id(bobDirector.client.rxbs)
bobServer = serving.Server(host="", port=bobPort)
bobServerDoer = doing.ServerDoer(server=bobServer)
bobDirectant = directing.Directant(hab=bobHab, server=bobServer)
assert bobDirectant.hab == bobHab
assert bobDirectant.server == bobServer
# Bob's Reactants created on demand
# setup eve
eveHab = directing.Habitat(ks=eveKS,
db=eveDB,
kevers=eveKevers,
secrecies=eveSecrecies,
temp=True)
assert eveHab.ks == eveKS
assert eveHab.db == eveDB
assert eveHab.iserder.dig == eveSerder.dig
assert eveHab.pre == eve
eveClient = clienting.Client(tymth=doist.tymen(),
host='127.0.0.1',
port=bobPort)
eveClientDoer = doing.ClientDoer(tymth=doist.tymen(), client=eveClient)
eveDirector = directing.Director(hab=eveHab, client=eveClient)
assert eveDirector.hab == eveHab
assert eveDirector.client == eveClient
assert id(eveDirector.hab.kvy.kevers) == id(eveKevers)
assert eveDirector.hab.kvy.db == eveDB
eveReactor = directing.Reactor(hab=eveHab, client=eveClient)
assert eveReactor.hab == eveHab
assert eveReactor.client == eveClient
assert id(eveReactor.hab.kvy.kevers) == id(eveKevers)
assert eveReactor.hab.kvy.db == eveDB
assert id(eveReactor.kevery.ims) == id(eveReactor.client.rxbs)
assert id(eveReactor.client.rxbs) == id(eveDirector.client.rxbs)
eveServer = serving.Server(host="", port=evePort)
eveServerDoer = doing.ServerDoer(server=eveServer)
eveDirectant = directing.Directant(hab=eveHab, server=eveServer)
assert eveDirectant.hab == eveHab
assert eveDirectant.server == eveServer
# Eve's Reactants created on demand
bobMsgTx = b"Hi Eve I am Bob"
bobDirector.client.tx(bobMsgTx)
eveMsgTx = b"Hi Bob its me Eve"
eveDirector.client.tx(eveMsgTx)
doers = [
bobClientDoer, bobDirector, bobReactor, bobServerDoer,
bobDirectant, eveClientDoer, eveDirector, eveReactor,
eveServerDoer, eveDirectant
]
doist.do(doers=doers)
assert doist.tyme == limit
assert bobClient.opened == False
assert bobServer.opened == False
assert eveClient.opened == False
assert eveServer.opened == False
assert not bobClient.txbs
ca, ix = list(eveServer.ixes.items())[0]
eveMsgRx = bytes(ix.rxbs) # ColdStart Error fluhes buffer
assert eveMsgRx == b''
# assert eveMsgRx == bobMsgTx
assert not eveClient.txbs
ca, ix = list(bobServer.ixes.items())[0]
bobMsgRx = bytes(ix.rxbs) # ColdStart Error fluhes buffer
assert bobMsgRx == b''
# assert bobMsgRx == eveMsgTx
assert not os.path.exists(eveDB.path)
assert not os.path.exists(bobDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def test_indirect_mode_sam_cam_wit_demo():
""" Test indirect mode, bob and eve with witness """
help.ogler.resetLevel(level=logging.DEBUG)
# set of secrets (seeds for private keys)
camSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
camSecrecies = []
for secret in camSecrets: # convert secrets to secrecies
camSecrecies.append([secret])
# create cam signers
camSigners = [coring.Signer(qb64=secret) for secret in camSecrets]
assert [signer.qb64 for signer in camSigners] == camSecrets
# set of secrets (seeds for private keys)
samSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
samSecrecies = []
for secret in samSecrets: # convert secrets to secrecies
samSecrecies.append([secret])
# create sam signers
samSigners = [coring.Signer(qb64=secret) for secret in samSecrets]
assert [signer.qb64 for signer in samSigners] == samSecrets
with basing.openDB(name="cam") as camDB, keeping.openKS(name="cam") as camKS, \
basing.openDB(name="sam") as samDB, keeping.openKS(name="sam") as samKS, \
basing.openDB(name="wit") as witDB, keeping.openKS(name="wit") as witKS:
samPort = 5620 # sam's TCP listening port for server
witPort = 5621 # wit' TCP listneing port for server
# setup the witness
witHab = habbing.Habitat(name='Wit',
ks=witKS,
db=witDB,
isith=1,
icount=1,
temp=True,
transferable=False)
wit = witHab.pre
assert witHab.ks == witKS
assert witHab.db == witDB
witServer = serving.Server(host="", port=witPort)
witServerDoer = serving.ServerDoer(server=witServer)
witDirectant = directing.Directant(hab=witHab, server=witServer)
witDoers = [witServerDoer, witDirectant]
# setup cam
# cam inception transferable (nxt digest not empty)
camSerder = eventing.incept(
keys=[camSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[camSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
cam = camSerder.ked["i"]
assert cam == 'ED9EB3sA5u2vCPOEmX3d7bEyHiSh7Xi8fjew2KMl3FQM'
# sam inception transferable (nxt digest not empty)
samSerder = eventing.incept(
keys=[samSigners[0].verfer.qb64],
wits=[wit],
nxt=coring.Nexter(keys=[samSigners[1].verfer.qb64]).qb64,
code=coring.MtrDex.Blake3_256)
sam = samSerder.ked["i"]
assert sam == 'EhnaYUqhHoo8kZaXJuTDCZ-h5ZDx3st4NemgqSITWp48'
samHab = habbing.Habitat(name='Sam',
ks=samKS,
db=samDB,
wits=[wit],
secrecies=samSecrecies,
temp=True)
assert samHab.ks == samKS
assert samHab.db == samDB
assert samHab.iserder.dig == samSerder.dig
assert samHab.pre == sam
samClient = clienting.Client(host='127.0.0.1', port=witPort)
samClientDoer = clienting.ClientDoer(client=samClient)
samDirector = demoing.SamDirector(hab=samHab,
client=samClient,
tock=0.125)
assert samDirector.hab == samHab
assert samDirector.client == samClient
assert id(samDirector.hab.kvy.kevers) == id(samHab.kevers)
assert samDirector.hab.kvy.db == samDB
assert samDirector.tock == 0.125
samReactor = directing.Reactor(hab=samHab, client=samClient)
assert samReactor.hab == samHab
assert samReactor.client == samClient
assert id(samReactor.hab.kvy.kevers) == id(samHab.kevers)
assert samReactor.hab.kvy.db == samDB
assert samReactor.hab.psr.ims == samReactor.client.rxbs
samServer = serving.Server(host="", port=samPort)
samServerDoer = serving.ServerDoer(server=samServer)
samDirectant = directing.Directant(hab=samHab, server=samServer)
assert samDirectant.hab == samHab
assert samDirectant.server == samServer
# Sam's Reactants created on demand
samDoers = [
samClientDoer, samDirector, samReactor, samServerDoer, samDirectant
]
# setup cam
camHab = habbing.Habitat(name='Cam',
ks=camKS,
db=camDB,
secrecies=camSecrecies,
temp=True)
assert camHab.ks == camKS
assert camHab.db == camDB
assert camHab.iserder.dig == camSerder.dig
assert camHab.pre == cam
camClient = clienting.Client(host='127.0.0.1', port=witPort)
camClientDoer = clienting.ClientDoer(client=camClient)
camDirector = demoing.CamDirector(hab=camHab,
remotePre=sam,
client=camClient,
tock=0.125)
assert camDirector.hab == camHab
assert camDirector.client == camClient
assert id(camDirector.hab.kvy.kevers) == id(camHab.kevers)
assert camDirector.hab.kvy.db == camDB
assert camDirector.tock == 0.125
camReactor = directing.Reactor(hab=camHab,
client=camClient,
indirect=True)
assert camReactor.hab == camHab
assert camReactor.client == camClient
assert id(camReactor.hab.kvy.kevers) == id(camHab.kevers)
assert camReactor.hab.kvy.db == camDB
assert camReactor.hab.psr.ims == camReactor.client.rxbs
camDoers = [camClientDoer, camDirector, camReactor]
# Manually stage SamDoers and wit doers and then camDoers
tock = 0.03125
doist = doing.Doist(doers=samDoers + witDoers, tock=tock)
# manually prep doers
doist.done = False
doist.enter() # injects doist.tymth() dependency to all doers
assert len(doist.deeds) == len(samDoers + witDoers)
while doist.tyme < doist.tock * 16:
doist.recur() # iterate 16 times
time.sleep(doist.tock)
assert len(doist.deeds) == len(samDoers + witDoers)
assert not doist.done
assert samHab.pre in samHab.kevers
# now start up cam doers
doist.extend(camDoers)
assert len(doist.deeds) == len(samDoers + witDoers + camDoers)
while doist.tyme < doist.tock * 32:
doist.recur() # iterate 16 times
time.sleep(doist.tock)
assert len(doist.deeds) == len(samDoers + witDoers + camDoers) - 1
# camDirector completes
assert camDirector.done
assert not doist.done
assert camHab.pre in camHab.kevers
assert samHab.pre in camHab.kevers
# verify final event states
doist.exit()
assert samClient.opened is False
assert samServer.opened is False
assert camClient.opened is False
assert not os.path.exists(camDB.path)
assert not os.path.exists(samDB.path)
help.ogler.resetLevel(level=help.ogler.level)
"""End Test"""
def test_direct_mode_sam():
"""
Test direct mode demo
"""
# set of secrets (seeds for private keys)
bobSecrets = [
'ArwXoACJgOleVZ2PY7kXn7rA0II0mHYDhc6WrBH8fDAc',
'A6zz7M08-HQSFq92sJ8KJOT2cZ47x7pXFQLPB0pckB3Q',
'AcwFTk-wgk3ZT2buPRIbK-zxgPx-TKbaegQvPEivN90Y',
'Alntkt3u6dDgiQxTATr01dy8M72uuaZEf9eTdM-70Gk8',
'A1-QxDkso9-MR1A8rZz_Naw6fgaAtayda8hrbkRVVu1E',
'AKuYMe09COczwf2nIoD5AE119n7GLFOVFlNLxZcKuswc',
'AxFfJTcSuEE11FINfXMqWttkZGnUZ8KaREhrnyAXTsjw',
'ALq-w1UKkdrppwZzGTtz4PWYEeWm0-sDHzOv5sq96xJY'
]
# create bob signers
bobSigners = [coring.Signer(qb64=secret) for secret in bobSecrets]
assert [signer.qb64 for signer in bobSigners] == bobSecrets
# bob inception transferable (nxt digest not empty)
bobSerder = eventing.incept(
keys=[bobSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[bobSigners[1].verfer.qb64]).qb64,
code=coring.CryOneDex.Blake3_256)
bob = bobSerder.ked['pre']
assert bob == 'ETT9n-TCGn8XfkGkcNeNmZgdZSwHPLyDsojFXotBXdSo'
# set of secrets (seeds for private keys)
eveSecrets = [
'AgjD4nRlycmM5cPcAkfOATAp8wVldRsnc9f1tiwctXlw',
'AKUotEE0eAheKdDJh9QvNmSEmO_bjIav8V_GmctGpuCQ',
'AK-nVhMMJciMPvmF5VZE_9H-nhrgng9aJWf7_UHPtRNM',
'AT2cx-P5YUjIw_SLCHQ0pqoBWGk9s4N1brD-4pD_ANbs',
'Ap5waegfnuP6ezC18w7jQiPyQwYYsp9Yv9rYMlKAYL8k',
'Aqlc_FWWrxpxCo7R12uIz_Y2pHUH2prHx1kjghPa8jT8',
'AagumsL8FeGES7tYcnr_5oN6qcwJzZfLKxoniKUpG4qc',
'ADW3o9m3udwEf0aoOdZLLJdf1aylokP0lwwI_M2J9h0s'
]
# create eve signers
eveSigners = [coring.Signer(qb64=secret) for secret in eveSecrets]
assert [signer.qb64 for signer in eveSigners] == eveSecrets
# eve inception transferable (nxt digest not empty)
eveSerder = eventing.incept(
keys=[eveSigners[0].verfer.qb64],
nxt=coring.Nexter(keys=[eveSigners[1].verfer.qb64]).qb64,
code=coring.CryOneDex.Blake3_256)
eve = eveSerder.ked['pre']
assert eve == 'EwBwUb2eZcA5GDcN7g-87wpreM0nNkLqzkwviBHTcV1A'
with dbing.openLogger(name="eve") as eveDB, \
dbing.openLogger(name="bob") as bobDB:
bobPort = 5620 # bob's TCP listening port for server
evePort = 5621 # eve's TCP listneing port for server
bobKevers = dict()
eveKevers = dict()
# setup bob
bobHab = directing.Habitat(secrets=bobSecrets,
kevers=bobKevers,
db=bobDB)
assert bobHab.db == bobDB
assert ([signer.verfer.qb64 for signer in bobHab.signers
] == [signer.verfer.qb64 for signer in bobSigners])
assert bobHab.inception.dig == bobSerder.dig
assert bobHab.pre == bob
bobClient = clienting.Client(host='127.0.0.1', port=evePort)
bobClientDoer = doing.ClientDoer(client=bobClient)
bobDirector = directing.SamDirector(hab=bobHab,
client=bobClient,
tock=0.125)
assert bobDirector.hab == bobHab
assert bobDirector.client == bobClient
assert bobDirector.kevery.kevers == bobKevers
assert bobDirector.kevery.logger == bobDB
assert bobDirector.tock == 0.125
bobReactor = directing.Reactor(hab=bobHab, client=bobClient)
assert bobReactor.hab == bobHab
assert bobReactor.client == bobClient
assert bobReactor.kevery.kevers == bobKevers
assert bobReactor.kevery.logger == bobDB
assert bobReactor.kevery.ims == bobReactor.client.rxbs
bobServer = serving.Server(host="", port=bobPort)
bobServerDoer = doing.ServerDoer(server=bobServer)
bobDirectant = directing.Directant(hab=bobHab, server=bobServer)
assert bobDirectant.hab == bobHab
assert bobDirectant.server == bobServer
# Bob's Reactants created on demand
# setup eve
eveHab = directing.Habitat(secrets=eveSecrets,
kevers=eveKevers,
db=eveDB)
assert eveHab.db == eveDB
assert ([signer.verfer.qb64 for signer in eveHab.signers
] == [signer.verfer.qb64 for signer in eveSigners])
assert eveHab.inception.dig == eveSerder.dig
assert eveHab.pre == eve
eveClient = clienting.Client(host='127.0.0.1', port=bobPort)
eveClientDoer = doing.ClientDoer(client=eveClient)
eveDirector = directing.EveDirector(hab=eveHab,
client=eveClient,
tock=0.125)
assert eveDirector.hab == eveHab
assert eveDirector.client == eveClient
assert eveDirector.kevery.kevers == eveKevers
assert eveDirector.kevery.logger == eveDB
eveReactor = directing.Reactor(hab=eveHab, client=eveClient)
assert eveReactor.hab == eveHab
assert eveReactor.client == eveClient
assert eveReactor.kevery.kevers == eveKevers
assert eveReactor.kevery.logger == eveDB
assert eveReactor.kevery.ims == eveReactor.client.rxbs
eveServer = serving.Server(host="", port=evePort)
eveServerDoer = doing.ServerDoer(server=eveServer)
eveDirectant = directing.Directant(hab=eveHab, server=eveServer)
assert eveDirectant.hab == eveHab
assert eveDirectant.server == eveServer
# Eve's Reactants created on demand
limit = 1.0
tock = 0.03125
doist = doing.Doist(limit=limit, tock=tock)
#eveMsgTx = b"Hi Bob its me Eve"
#eveDirector.client.tx(eveMsgTx)
doers = [
bobClientDoer, bobDirector, bobReactor, bobServerDoer,
bobDirectant, eveClientDoer, eveDirector, eveReactor,
eveServerDoer, eveDirectant
]
doist.do(doers=doers)
assert doist.tyme == limit
assert bobClient.opened == False
assert bobServer.opened == False
assert eveClient.opened == False
assert eveServer.opened == False
assert bobHab.pre in bobHab.kevers
assert eveHab.pre in eveHab.kevers
assert not bobClient.txes
assert bobHab.pre in eveHab.kevers
# verify final bob event state
# verify final val event state
assert not os.path.exists(eveDB.path)
assert not os.path.exists(bobDB.path)
"""End Test"""
