def action(self):
self.presence_req.value = deque()
self.availables.value = set()
self.alloweds.value = odict()
self.aliveds.value = odict()
self.reapeds.value = odict()
def paginate(self, headsize):
'''
Create packeted segments from .packed using headsize
'''
if self.kind == raeting.packKinds.json:
extrasize = 4096 #need better estimate
else:
extrasize = 2048
hotelsize = headsize + extrasize
secsize = raeting.UXD_MAX_PACKET_SIZE - hotelsize
seccount = (self.size // secsize) + (1 if self.size % secsize else 0)
for i in range(seccount):
if i == seccount - 1: #last section
section = self.packed[i * secsize:]
else:
section = self.packed[i * secsize: (i+1) * secsize]
data = odict(self.data)
data['number'] = i
data['count'] = seccount
data['section'] = section
page = TxPage( stack=self.stack, data=odict(page=data), kind=self.kind)
page.pack()
self.pages.append(page)
def action(self):
self.presence_req.value = deque()
self.availables.value = set()
self.alloweds.value = odict()
self.aliveds.value = odict()
self.reapeds.value = odict()
class SaltRaetRoadStackAllowed(ioflo.base.deeding.Deed):
'''
Updates status with .allowed of zeroth remote estate (master)
FloScript:
do salt raet road stack allowed
go next if allowed in .raet.udp.stack.status
'''
Ioinits = odict(inode=".raet.udp.stack.",
stack='stack',
status=odict(ipath='status',
ival=odict(
joined=False,
allowed=False,
idle=False,
)))
def action(self, **kwa):
'''
Update .status share
'''
stack = self.stack.value
allowed = False
if stack and isinstance(stack, RoadStack):
if stack.remotes:
allowed = stack.remotes.values()[0].allowed
self.status.update(allowed=allowed)
class ParserRaet(deeding.ParamDeed): # pylint: disable=W0232
'''
ParserRaet parses a packed RAET packet from pack and fills in data
inherited attributes
.name is actor name string
.store is data store ref
.ioinits is dict of io init data for initio
._parametric is flag for initio to not create attributes
'''
Ioinits = odict(
data=odict(ipath='data', ival=odict(), iown=True),
inlog=odict(ipath='inlog', ival=odict(), iown=True),
)
def action(self, data, inlog, **kwa):
""" Parse packet from raw packed"""
if data.value:
data.value = raeting.defaultData(data.value)
rest = raeting.parsePacket(data.value)
data.stampNow()
inlog.value[(data.value['meta']['sh'],
data.value['meta']['sp'])] = data.value['body'].get(
'data', {})
return None
class ReceiverRaet(deeding.ParamDeed): # pylint: disable=W0232
'''
ReceiverRaet pulls packet from rxes deque and puts into new data
and assigns meta data source ha using received ha
inherited attributes
.name is actor name string
.store is data store ref
.ioinits is dict of io init data for initio
._parametric is flag for initio to not create attributes
'''
Ioinits = odict(
data='data',
rxes=odict(ipath='.raet.media.rxes', ival=deque()),
)
def action(self, data, rxes, **kwa):
'''
Handle recived packet
'''
if rxes.value:
rx, sa, da = rxes.value.popleft()
data.value = raeting.defaultData()
data.value['pack'] = rx
data.value['meta']['sh'], data.value['meta']['sp'] = sa
data.value['meta']['dh'], data.value['meta']['dp'] = da
return None
class SaltRaetRoadStackJoined(ioflo.base.deeding.Deed):
'''
Updates status with .joined of zeroth remote estate (master)
FloScript:
do salt raet road stack joined
go next if joined in .salt.road.manor.status
'''
Ioinits = odict(
inode=".salt.road.manor.",
stack='stack',
status=odict(ipath='status', ival=odict(joined=False,
allowed=False,
alived=False,
rejected=False,
idle=False, )))
def action(self, **kwa):
'''
Update .status share
'''
stack = self.stack.value
joined = False
if stack and isinstance(stack, RoadStack):
if stack.remotes:
for remote in stack.remotes.values():
joined = any([remote.joined for remote in stack.remotes.values()])
self.status.update(joined=joined)
def __init__(self,
name='',
version=raeting.VERSION,
store=None,
device=None,
did=None,
ha=("", raeting.RAET_PORT),
rxMsgs = None,
txMsgs = None,
udpRxes = None,
udpTxes = None,
):
'''
Setup StackUdp instance
'''
if not name:
name = "stack{0}".format(StackUdp.Count)
StackUdp.Count += 1
self.name = name
self.version = version
self.store = store or storing.Store(stamp=0.0)
self.devices = odict() # remote devices attached to this stack by did
self.dids = odict() # reverse lookup did by device.name
# local device for this stack
self.device = device or devicing.LocalDevice(stack=self, did=did, ha=ha)
self.transactions = odict() #transactions
self.rxMsgs = rxMsgs if rxMsgs is not None else deque() # messages received
self.txMsgs = txMsgs if txMsgs is not None else deque() # messages to transmit
#(msg, ddid) ddid=0 is broadcast
self.udpRxes = udpRxes if udpRxes is not None else deque() # udp packets received
self.udpTxes = udpTxes if udpTxes is not None else deque() # udp packet to transmit
self.serverUdp = aiding.SocketUdpNb(ha=self.device.ha)
self.serverUdp.reopen() # open socket
self.device.ha = self.serverUdp.ha # update device host address after open
class SaltRaetRoadStackRejected(ioflo.base.deeding.Deed):
'''
Updates status with rejected of .acceptance of zeroth remote estate (master)
FloScript:
do salt raet road stack rejected
go next if rejected in .salt.road.manor.status
'''
Ioinits = odict(
inode=".salt.road.manor.",
stack='stack',
status=odict(ipath='status', ival=odict(joined=False,
allowed=False,
alived=False,
rejected=False,
idle=False, )))
def action(self, **kwa):
'''
Update .status share
'''
stack = self.stack.value
rejected = False
if stack and isinstance(stack, RoadStack):
if stack.remotes:
for remote in stack.remotes.values():
rejected = all([remote.acceptance == raeting.acceptances.rejected
for remote in stack.remotes.values()])
else: # no remotes so assume rejected
rejected = True
self.status.update(rejected=rejected)
def action(self, **kwa):
'''
Manage the presence of any remotes
availables is set of names of alive remotes which are also allowed
changeds is is share with two fields:
plus is set of names of newly available remotes
minus is set of names of newly unavailable remotes
alloweds is dict of allowed remotes keyed by name
aliveds is dict of alived remotes keyed by name
reapeds is dict of reaped remotes keyed by name
'''
stack = self.stack.value
if stack and isinstance(stack, RoadStack):
stack.manage(cascade=True)
# make copies
self.availables.value = set(self.stack.value.availables)
self.changeds.update(plus=set(self.stack.value.changeds['plus']))
self.changeds.update(minus=set(self.stack.value.changeds['minus']))
self.alloweds.value = odict(self.stack.value.alloweds)
self.aliveds.value = odict(self.stack.value.aliveds)
self.reapeds.value = odict(self.stack.value.reapeds)
console.concise(" Manage {0}.\nAvailables: {1}\nChangeds:\nPlus: {2}\n"
"Minus: {3}\nAlloweds: {4}\nAliveds: {5}\nReapeds: {6}\n".format(
stack.name,
self.availables.value,
self.changeds.data.plus,
self.changeds.data.minus,
self.alloweds.value,
self.aliveds.value,
self.reapeds.value))
def manage(self, cascade=False, immediate=False):
'''
Manage remote estates. Time based processing of remote status such as
presence (keep alive) etc.
cascade induces the alive transactions to run join, allow, alive until
failure or alive success
immediate indicates to run first attempt immediately and not wait for timer
availables = dict of remotes that are both alive and allowed
'''
alloweds = odict()
aliveds = odict()
for remote in self.remotes.values(): # should not start anything
remote.manage(cascade=cascade, immediate=immediate)
if remote.allowed:
alloweds[remote.name] = remote
if remote.alived:
aliveds[remote.name] = remote
old = set(self.aliveds.keys())
current = set(aliveds.keys())
plus = current.difference(old)
minus = old.difference(current)
self.availables = current
self.changeds = odict(plus=plus, minus=minus)
self.alloweds = alloweds
self.aliveds = aliveds
class ComposerRaet(deeding.ParamDeed): # pylint: disable=W0232
'''
ComposerRaet creates packet data as nested dicts from fields in
share parms meta, head, neck, body, tail
inherited attributes
.name is actor name string
.store is data store ref
.ioinits is dict of io init data for initio
._parametric is flag for initio to not create attributes
'''
Ioinits = odict(data=odict(ipath='data', ival=odict(), iown='True'),
meta='meta',
head='head',
neck='neck',
body='body',
tail='tail')
def action(self, data, meta, head, neck, body, tail, **kwa):
'''
Build packet data from data section shares
'''
dat = raeting.defaultData()
dat['meta'].update(raeting.META_DEFAULTS)
dat['meta'].update(meta.items())
dat['head'].update(raeting.HEAD_DEFAULTS)
dat['head'].update(head.items())
dat['neck'].update(neck.items())
dat['body'].update(data=odict(body.items()))
dat['tail'].update(tail.items())
data.value = dat
return None
def testSegmentedMsgpack(self):
'''
Test segmented message transactions
'''
console.terse("{0}\n".format(self.testSegmentedJson.__doc__))
stuff = []
for i in range(300):
stuff.append(str(i).rjust(10, " "))
stuff = "".join(stuff)
others = []
mains = []
others.append(
odict(house="Snake eyes", queue="near stuff", stuff=stuff))
mains.append(odict(house="Craps", queue="far stuff", stuff=stuff))
bloat = []
for i in range(300):
bloat.append(str(i).rjust(100, " "))
bloat = "".join(bloat)
others.append(odict(house="Other", queue="big stuff", bloat=bloat))
mains.append(odict(house="Main", queue="gig stuff", bloat=bloat))
self.bidirectional(bk=raeting.bodyKinds.msgpack,
mains=mains,
others=others)
def manage(self, cascade=False, immediate=False):
'''
Manage remote estates. Time based processing of remote status such as
presence (keep alive) etc.
cascade induces the alive transactions to run join, allow, alive until
failure or alive success
immediate indicates to run first attempt immediately and not wait for timer
availables = dict of remotes that are both alive and allowed
'''
alloweds = odict()
aliveds = odict()
reapeds = odict()
for remote in self.remotes.values(): # should not start anything
remote.manage(cascade=cascade, immediate=immediate)
if remote.allowed:
alloweds[remote.name] = remote
if remote.alived:
aliveds[remote.name] = remote
if remote.reaped:
reapeds[remote.name] = remote
old = set(self.aliveds.keys())
current = set(aliveds.keys())
plus = current.difference(old)
minus = old.difference(current)
self.availables = current
self.changeds = odict(plus=plus, minus=minus)
self.alloweds = alloweds
self.aliveds = aliveds
self.reapeds = reapeds
def testSegmentedMsgpackBurst(self):
'''
Test segmented message transactions with burst count limiting
'''
console.terse("{0}\n".format(self.testSegmentedMsgpackBurst.__doc__))
stuff = []
for i in range(300):
stuff.append(str(i).rjust(10, " "))
stuff = "".join(stuff)
others = []
mains = []
others.append(odict(house="Snake eyes", queue="near stuff", stuff=stuff))
mains.append(odict(house="Craps", queue="far stuff", stuff=stuff))
bloat = []
for i in range(300):
bloat.append(str(i).rjust(100, " "))
bloat = "".join(bloat)
others.append(odict(house="Other", queue="big stuff", bloat=bloat))
mains.append(odict(house="Main", queue="gig stuff", bloat=bloat))
stacking.RoadStack.BurstSize = 16
self.assertEqual(stacking.RoadStack.BurstSize, 16)
self.bidirectional(bk=raeting.BodyKind.msgpack.value, mains=mains, others=others, duration=20.0)
stacking.RoadStack.BurstSize = 0
self.assertEqual(stacking.RoadStack.BurstSize, 0)
def testMessageSectionedMsgpack(self):
'''
Sectioned messages with msgpack packing
'''
console.terse("{0}\n".format(self.testMessageSectionedMsgpack.__doc__))
self.bootstrap(kind=raeting.packKinds.pack)
#big packets
stuff = []
for i in range(10000):
stuff.append(str(i).rjust(10, " "))
stuff = "".join(stuff)
src = ['mayor', self.main.local.name, None]
dst = ['citizen', self.other.local.name, None]
route = odict([('src', src), ('dst', dst)])
mains = []
mains.append(odict([('route', route), ('content', stuff)]))
src = ['citizen', self.other.local.name, None]
dst = ['mayor', self.main.local.name, None]
route = odict([('src', src), ('dst', dst)])
others = []
others.append(odict([('route', route), ('content', stuff)]))
self.message(mains=mains, others=others, duration=2.0)
def testMessageSectionedMsgpack(self):
'''
Sectioned messages with msgpack packing
'''
console.terse("{0}\n".format(self.testMessageSectionedMsgpack.__doc__))
self.bootstrap(kind=raeting.packKinds.pack)
#big packets
stuff = []
for i in range(10000):
stuff.append(str(i).rjust(10, " "))
stuff = "".join(stuff)
src = ['mayor', self.main.local.name, None]
dst = ['citizen', self.other.local.name, None]
route = odict([('src', src), ('dst', dst)])
mains = []
mains.append(odict([('route', route), ('content', stuff)]))
src = ['citizen', self.other.local.name, None]
dst = ['mayor', self.main.local.name, None]
route = odict([('src', src), ('dst', dst)])
others = []
others.append(odict([('route', route), ('content', stuff)]))
self.message(mains=mains, others=others, duration=2.0)
class SaltRaetRoadCleanup(deeding.Deed):
'''
Cleanup stray road keep directories
FloScript:
do salt raet road cleanup at enter
'''
Ioinits = odict(
inode="raet.road.stack.",
local=odict(
ipath='local',
ival=odict(basedirpath='/tmp/raet/keep')
)
)
def action(self):
'''
Should only run once to cleanup stale lane uxd files.
'''
basedirpath = os.path.abspath(os.path.expanduser(self.local.data.basedirpath))
console.concise("Cleaning up road files in {0}\n".format(basedirpath))
if os.path.exists(basedirpath):
shutil.rmtree(basedirpath)
class PresenterTestCleanup(ioflo.base.deeding.Deed):
'''
Clean up after a test
'''
Ioinits = {
'presence_req': '.salt.presence.event_req',
'alloweds': {
'ipath': '.salt.var.presence.alloweds',
'ival': odict()
},
'aliveds': {
'ipath': '.salt.var.presence.aliveds',
'ival': odict()
},
'reapeds': {
'ipath': '.salt.var.presence.reapeds',
'ival': odict()
},
'availables': {
'ipath': '.salt.var.presence.availables',
'ival': set()
}
}
def action(self):
self.presence_req.value = deque()
self.availables.value = set()
self.alloweds.value = odict()
self.aliveds.value = odict()
self.reapeds.value = odict()
class RaetLaneStackYardAdd(deeding.Deed):
'''
Adds yard to lane stack.
Where lane is the lane name and name is the yard name in the parameters
FloScript:
do raet lane stack yard add to lane "ash" name "lord" at enter
'''
Ioinits = odict(
inode=".raet.lane.stack.",
stack='stack',
local=odict(ipath='local',
ival=odict(sockdirpath="/tmp/raet/test/lane/")))
def action(self, lane="lane", name=None, **kwa):
'''
Adds new yard to stack on lane with name
'''
stack = self.stack.value
sockdirpath = self.local.data.sockdirpath
if stack and isinstance(stack, LaneStack):
yard = yarding.RemoteYard(stack=stack,
lanename=lane,
name=name,
dirpath=sockdirpath)
stack.addRemote(yard)
self.local.value = yard
def action(self):
self.presence_req.value = deque()
self.availables.value = set()
self.alloweds.value = odict()
self.aliveds.value = odict()
self.reapeds.value = odict()
# Create event stack
name = 'event' + nacling.uuid(size=18)
lanename = self.lane_stack.value.local.lanename
sock_dir = self.lane_stack.value.local.dirpath
ryn = 'manor'
console.terse(
"Create stack: name = {0}, lanename = {1}, sock_dir = {2}\n".
format(name, lanename, sock_dir))
stack = LaneStack(name=name, lanename=lanename, sockdirpath=sock_dir)
stack.addRemote(
RemoteYard(stack=stack,
lanename=lanename,
name=ryn,
dirpath=sock_dir))
self.event_stack.value = stack
route = {
'dst': (None, ryn, 'presence_req'),
'src': (None, stack.local.name, None)
}
msg = {'route': route}
stack.transmit(msg, stack.nameRemotes[ryn].uid)
serviceLanes([stack, self.lane_stack.value])
def action(self, **kwa):
'''
Manage the presence of any remotes
availables is set of names of alive remotes which are also allowed
changeds is is share with two fields:
plus is set of names of newly available remotes
minus is set of names of newly unavailable remotes
alloweds is dict of allowed remotes keyed by name
aliveds is dict of alived remotes keyed by name
reapeds is dict of reaped remotes keyed by name
'''
stack = self.stack.value
if stack and isinstance(stack, RoadStack):
stack.manage(cascade=True)
# make copies
self.availables.value = set(self.stack.value.availables)
self.changeds.update(plus=set(self.stack.value.changeds['plus']))
self.changeds.update(minus=set(self.stack.value.changeds['minus']))
self.alloweds.value = odict(self.stack.value.alloweds)
self.aliveds.value = odict(self.stack.value.aliveds)
self.reapeds.value = odict(self.stack.value.reapeds)
console.concise(" Manage {0}.\nAvailables: {1}\nChangeds:\nPlus: {2}\n"
"Minus: {3}\nAlloweds: {4}\nAliveds: {5}\nReapeds: {6}\n".format(
stack.name,
self.availables.value,
self.changeds.data.plus,
self.changeds.data.minus,
self.alloweds.value,
self.aliveds.value,
self.reapeds.value))
class RaetRoadStackAllowed(deeding.Deed): # pylint: disable=W0232
'''
Updates status field in share with .allowed of zeroth remote estate (main)
FloScript:
do raet road stack allowed
go next if allowed in .raet.road.stack.status
'''
Ioinits = odict(inode=".raet.road.stack.",
stack='stack',
status=odict(ipath='status',
ival=odict(
joined=False,
allowed=False,
idle=False,
)))
def action(self, **kwa):
'''
Update .status share
'''
stack = self.stack.value
allowed = False
if stack and isinstance(stack, RoadStack):
if stack.remotes:
allowed = stack.remotes.values()[0].allowed
self.status.update(allowed=allowed)
class RaetRoadStackIdled(deeding.Deed): # pylint: disable=W0232
'''
Updates idle status field in shate to true if there are no outstanding
transactions in the associated stack
FloScript:
do raet road stack idled
go next if idled in .raet.road.stack.status
'''
Ioinits = odict(inode=".raet.road.stack.",
stack='stack',
status=odict(ipath='status',
ival=odict(
joined=False,
allowed=False,
idle=False,
)))
def action(self, **kwa):
'''
Update .status share
'''
stack = self.stack.value
idled = False
if stack and isinstance(stack, RoadStack):
if not stack.transactions:
idled = True
self.status.update(idled=idled)
class RaetLaneStackYardAdd(deeding.Deed): # pylint: disable=W0232
'''
Adds yard to lane stack.
Where lane is the lane name and name is the yard name in the parameters
FloScript:
do raet lane stack yard add to lane "ash" name "lord" at enter
'''
Ioinits = odict(
inode=".raet.lane.stack.",
stack='stack',
local='yard',
yard=odict(ipath='local', ival=odict(name=None, lane="maple")),
)
def action(self, lane="lane", name=None, **kwa):
'''
Adds new yard to stack on lane with yid
'''
stack = self.stack.value
if stack and isinstance(stack, LaneStack):
yard = yarding.RemoteYard(stack=stack, lanename=lane, name=name)
stack.addRemote(yard)
self.local.value = yard
class RaetRoadStack(deeding.Deed):
'''
Initialize and run raet road stack
FloScript:
do raet road stack
'''
Ioinits = odict(
inode="raet.road.stack.",
stack='stack',
txmsgs=odict(ipath='txmsgs', ival=deque()),
rxmsgs=odict(ipath='rxmsgs', ival=deque()),
local=odict(ipath='local', ival=odict( name='master',
basedirpath='/tmp/raet/keep',
main=False,
mutable=True,
auto=raeting.autoModes.once,
uid=None,
host='0.0.0.0',
port=raeting.RAET_PORT,
sigkey=None,
prikey=None)),)
def postinitio(self):
'''
Setup stack instance
'''
sigkey = self.local.data.sigkey
prikey = self.local.data.prikey
name = self.local.data.name
basedirpath = os.path.abspath(os.path.expanduser(self.local.data.basedirpath))
auto = self.local.data.auto
main = self.local.data.main
mutable = self.local.data.mutable
ha = (self.local.data.host, self.local.data.port)
uid = self.local.data.uid
txMsgs = self.txmsgs.value
rxMsgs = self.rxmsgs.value
self.stack.value = RoadStack(store=self.store,
main=main,
mutable=mutable,
name=name,
uid=uid,
ha=ha,
sigkey=sigkey,
prikey=prikey,
auto=auto,
basedirpath=basedirpath,
txMsgs=txMsgs,
rxMsgs=rxMsgs, )
def action(self, **kwa):
'''
Service all the deques for the stack
'''
self.stack.value.serviceAll()
def testAutoAccept(self):
'''
Basic send auto accept message
'''
console.terse("{0}\n".format(self.testAutoAccept.__doc__))
self.assertTrue(self.main.accept)
# Don't add remote yard to main so only way to get message from other is
# if auto acccept works
self.other.addRemote(
yarding.RemoteYard(stack=self.other, ha=self.main.local.ha))
self.assertEqual(self.main.name, 'main')
self.assertEqual(self.main.local.name, 'main')
self.assertEqual(self.main.local.ha,
os.path.join(self.baseDirpath, 'cherry.main.uxd'))
self.assertEqual(len(self.main.remotes), 0)
self.assertEqual(self.other.name, 'other')
self.assertEqual(self.other.local.name, 'other')
self.assertEqual(self.other.local.ha,
os.path.join(self.baseDirpath, 'cherry.other.uxd'))
self.assertEqual(len(self.other.remotes), 1)
remote = self.other.remotes.values()[0]
self.assertEqual(remote.ha,
os.path.join(self.baseDirpath, 'cherry.main.uxd'))
self.assertEqual(remote.name, 'main')
self.assertTrue(remote.uid in self.other.remotes)
self.assertTrue(remote.name in self.other.uids)
self.assertIs(self.other.remotes[self.other.uids[remote.name]], remote)
stacking.LaneStack.Pk = raeting.packKinds.pack
others = []
others.append(
odict(what="This is a message to the lord. Let me be",
extra="Go away."))
self.message(mains=[], others=others)
self.assertEqual(len(self.main.remotes), 1)
remote = self.main.remotes.values()[0]
self.assertEqual(remote.ha,
os.path.join(self.baseDirpath, 'cherry.other.uxd'))
self.assertEqual(remote.name, 'other')
self.assertTrue(remote.uid in self.main.remotes)
self.assertTrue(remote.name in self.main.uids)
self.assertIs(self.main.remotes[self.main.uids[remote.name]], remote)
self.main.rxMsgs = deque()
self.other.rxMsgs = deque()
mains = []
mains.append(
odict(what="This is a message to the serf. Get to Work",
extra="Fix the fence."))
self.message(mains=mains, others=[])
def testBasicRaetMsgpack(self):
'''
Basic pack parse with header json and body msgpack
'''
console.terse("{0}\n".format(self.testBasicRaetMsgpack.__doc__))
hk = raeting.headKinds.raet
bk = raeting.bodyKinds.msgpack
data = odict(hk=hk, bk=bk)
body = odict(msg='Hello Raet World', extra='Goodby Big Moon')
packet0 = packeting.TxPacket(
embody=body,
data=data,
)
self.assertDictEqual(packet0.body.data, body)
packet0.pack()
self.assertEqual(
packet0.packed,
'ri RAET\npl 0048\nhl 1c\nbk 3\n\n\x82\xa3msg\xb0Hello Raet World\xa5extra\xafGoodby Big Moon'
)
packet1 = packeting.RxPacket(packed=packet0.packed)
packet1.parse()
self.assertDictEqual(
packet1.data, {
'sh': '',
'sp': 7530,
'dh': '127.0.0.1',
'dp': 7530,
'ri': 'RAET',
'vn': 0,
'pk': 0,
'pl': 72,
'hk': 0,
'hl': 28,
'se': 0,
'de': 0,
'cf': False,
'bf': False,
'si': 0,
'ti': 0,
'tk': 0,
'dt': 0,
'oi': 0,
'wf': False,
'sn': 0,
'sc': 1,
'ml': 0,
'sf': False,
'af': False,
'bk': 3,
'ck': 0,
'fk': 0,
'fl': 0,
'fg': '00'
})
self.assertDictEqual(packet1.body.data, body)
def testBasicJson(self):
'''
Basic pack parse with header json and body json
'''
console.terse("{0}\n".format(self.testBasicJson.__doc__))
hk = raeting.headKinds.json
bk = raeting.bodyKinds.json
data = odict(hk=hk, bk=bk)
body = odict(msg='Hello Raet World', extra='Goodby Big Moon')
packet0 = packeting.TxPacket(
embody=body,
data=data,
)
self.assertDictEqual(packet0.body.data, body)
packet0.pack()
self.assertEqual(
packet0.packed,
'{"ri":"RAET","pl":"000006c","hl":"38","hk":1,"bk":1}\r\n\r\n{"msg":"Hello Raet World","extra":"Goodby Big Moon"}'
)
packet1 = packeting.RxPacket(packed=packet0.packed)
packet1.parse()
self.assertDictEqual(
packet1.data, {
'sh': '',
'sp': 7530,
'dh': '127.0.0.1',
'dp': 7530,
'ri': 'RAET',
'vn': 0,
'pk': 0,
'pl': 108,
'hk': 1,
'hl': 56,
'se': 0,
'de': 0,
'cf': False,
'bf': False,
'si': 0,
'ti': 0,
'tk': 0,
'dt': 0,
'oi': 0,
'wf': False,
'sn': 0,
'sc': 1,
'ml': 0,
'sf': False,
'af': False,
'bk': 1,
'ck': 0,
'fk': 0,
'fl': 0,
'fg': '00'
})
self.assertDictEqual(packet1.body.data, body)
def __init__(self,
store=None,
version=raeting.VERSION,
main=None,
puid=None,
local=None, #passed up from subclass
name='',
uid=None,
server=None,
ha=None,
bufcnt=2,
rxMsgs=None,
txMsgs=None,
rxes=None,
txes=None,
stats=None,
):
'''
Setup Stack instance
'''
self.store = store or storing.Store(stamp=0.0)
self.version = version
self.main = main
if getattr(self, 'puid', None) is None:
self.puid = puid if puid is not None else self.Uid
self.local = local or lotting.Lot(stack=self,
name=name,
uid=uid,
ha=ha,)
self.local.stack = self
self.remotes = self.uidRemotes = odict() # remotes indexed by uid
self.nameRemotes = odict() # remotes indexed by name
self.bufcnt = bufcnt
if not server:
server = self.serverFromLocal()
self.server = server
if self.server:
if not self.server.reopen(): # open socket
raise raeting.StackError("Stack '{0}': Failed opening server at"
" '{1}'\n".format(self.name, self.server.ha))
self.ha = self.server.ha # update local host address after open
console.verbose("Stack '{0}': Opened server at '{1}'\n".format(self.name,
self.ha))
self.rxMsgs = rxMsgs if rxMsgs is not None else deque() # messages received
self.txMsgs = txMsgs if txMsgs is not None else deque() # messages to transmit
self.rxes = rxes if rxes is not None else deque() # udp packets received
self.txes = txes if txes is not None else deque() # udp packet to transmit
self.stats = stats if stats is not None else odict() # udp statistics
self.statTimer = aiding.StoreTimer(self.store)
def __init__(self,
name='',
main=None,
mutable=None,
keep=None,
dirpath='',
basedirpath='',
local=None,
eid=None, #local estate eid, none means generate it
ha=("", raeting.RAET_PORT),
bufcnt=2,
auto=None,
period=None,
offset=None,
interim=None,
role=None,
**kwa
):
'''
Setup StackUdp instance
'''
keep = keep or keeping.RoadKeep(dirpath=dirpath,
basedirpath=basedirpath,
stackname=name,
auto=auto)
local = local or estating.LocalEstate(stack=self,
name=name,
eid=eid,
main=main,
mutable=mutable,
ha=ha,
role=role)
local.stack = self
if local.main is None and main is not None:
local.main = True if main else False
if local.mutable is None and mutable is not None:
local.mutable = True if mutable else False
self.period = period if period is not None else self.Period
self.offset = offset if offset is not None else self.Offset
self.interim = interim if interim is not None else self.Interim
super(RoadStack, self).__init__(name=name,
main=main,
keep=keep,
dirpath=dirpath,
basedirpath=basedirpath,
local=local,
bufcnt=bufcnt,
**kwa)
self.alloweds = odict() # allowed remotes keyed by name
self.aliveds = odict() # alived remotes keyed by name
self.reapeds = odict() # reaped remotes keyed by name
self.availables = set() # set of available remote names
class PresenterTestSetup(ioflo.base.deeding.Deed):
'''
Setup shares for presence tests
'''
Ioinits = {
'presence_req': '.salt.presence.event_req',
'lane_stack': '.salt.lane.manor.stack',
'event_stack': '.salt.test.lane.stack',
'alloweds': {
'ipath': '.salt.var.presence.alloweds',
'ival': odict()
},
'aliveds': {
'ipath': '.salt.var.presence.aliveds',
'ival': odict()
},
'reapeds': {
'ipath': '.salt.var.presence.reapeds',
'ival': odict()
},
'availables': {
'ipath': '.salt.var.presence.availables',
'ival': set()
}
}
def action(self):
self.presence_req.value = deque()
self.availables.value = set()
self.alloweds.value = odict()
self.aliveds.value = odict()
self.reapeds.value = odict()
# Create event stack
name = 'event' + nacling.uuid(size=18)
lanename = self.lane_stack.value.local.lanename
sock_dir = self.lane_stack.value.local.dirpath
ryn = 'manor'
console.terse(
"Create stack: name = {0}, lanename = {1}, sock_dir = {2}\n".
format(name, lanename, sock_dir))
stack = LaneStack(name=name, lanename=lanename, sockdirpath=sock_dir)
stack.addRemote(
RemoteYard(stack=stack,
lanename=lanename,
name=ryn,
dirpath=sock_dir))
self.event_stack.value = stack
route = {
'dst': (None, ryn, 'presence_req'),
'src': (None, stack.local.name, None)
}
msg = {'route': route}
stack.transmit(msg, stack.nameRemotes[ryn].uid)
serviceLanes([stack, self.lane_stack.value])
class ServerRaet(deeding.ParamDeed): # pylint: disable=W0232
'''
ServerRaet transmits and recieves udp packets from txes and rxes deques
using sh, sp fields in sa server address (server host, server port) to receive on.
Server is nonblocking socket connection
inherited attributes
.name is actor name string
.store is data store ref
.ioinits is dict of io init data for initio
._parametric is flag for initio to not create attributes
'''
Ioinits = odict(
txes=odict(ipath='txes', ival=deque(), iown=True),
rxes=odict(ipath='rxes', ival=deque(), iown=True),
connection=odict(ipath='connection', ival=None, iown=True),
address=odict(ipath='address', ival=odict(host='', port=7530,
ha=None)),
txlog=odict(ipath='txlog', ival=odict(), iown=True),
rxlog=odict(ipath='rxlog', ival=odict(), iown=True),
)
def postinitio(self, connection, address, **kwa):
'''
Set up server to transmit and recive on address
'''
connection.value = aiding.SocketUdpNb(host=address.data.host,
port=address.data.port)
connection.value.reopen() # create socket connection
host, port = connection.value.ha
address.update(host=host, port=port, ha=(host, port))
return None
def action(self, txes, rxes, connection, address, txlog, rxlog, **kwa):
'''
Receive any udp packets on server socket and put in rxes
Send any packets in txes
'''
server = connection.value
txl = txlog.value
rxl = rxlog.value
if server:
rxds = rxes.value
while True:
rx, ra = server.receive() # if no data the tuple is ('',None)
if not rx: # no received data so break
break
rxds.append((rx, ra, address.data.ha))
rxl[ra] = rx
txds = txes.value
while txds:
tx, ta = txds.popleft()
server.send(tx, ta)
txl[ta] = tx
return None
def testMinionStatsUnknownRemote(self):
"""
Test Minion Stats request with unknown remote (B1)
"""
console.terse("{0}\n".format(
self.testMinionStatsUnknownRemote.__doc__))
# Bootstrap
self.addEnterDeed("TestOptsSetupMinion")
self.addEnterDeed("SaltRaetManorLaneSetup")
self.addEnterDeed("SaltRaetRoadStackSetup")
self.addEnterDeed("StatsMinionTestSetup")
act = self.addRecurDeed("SaltRaetStatsEventerMinion")
self.resolve() # resolve House, Framer, Frame, Acts, Actors
self.frame.enter()
# Prepare
# add a test stat key-value
roadStack = self.store.fetch('.salt.road.manor.stack')
laneStack = self.store.fetch('.salt.lane.manor.stack')
roadStack.value.stats = odict({'test_road_stats_event': 111})
laneStack.value.stats = odict({'test_lane_stats_event': 222})
# ensure stats are equal to expected
self.assertDictEqual(roadStack.value.stats,
{'test_road_stats_event': 111})
self.assertDictEqual(laneStack.value.stats,
{'test_lane_stats_event': 222})
# add stats request
testStack = self.store.fetch('.salt.test.road.stack').value
statsReq = self.store.fetch('.salt.stats.event_req').value
tag = tagify('road', 'stats')
minionName = roadStack.value.local.name
# unknown remote (src) name in stats request
unknownName = 'unknownName'
statsReq.append({
'route': {
'dst': (minionName, None, 'stats_req'),
'src': (unknownName, None, None)
},
'tag': tag
})
# Test
self.frame.recur() # run in frame
# Check
self.assertEqual(len(testStack.rxMsgs), 0)
testStack.serviceAll()
self.assertEqual(len(testStack.rxMsgs), 0)
# Close active stacks servers
act.actor.lane_stack.value.server.close()
act.actor.road_stack.value.server.close()
testStack = self.store.fetch('.salt.test.road.stack')
if testStack:
testStack.value.server.close()
def testMinionLaneStats(self):
"""
Test Minion Road Stats request (A2)
"""
console.terse("{0}\n".format(self.testMinionLaneStats.__doc__))
# Bootstrap
self.addEnterDeed("TestOptsSetupMinion")
self.addEnterDeed("SaltRaetManorLaneSetup")
self.addEnterDeed("SaltRaetRoadStackSetup")
self.addEnterDeed("StatsMinionTestSetup")
act = self.addRecurDeed("SaltRaetStatsEventerMinion")
self.resolve() # resolve House, Framer, Frame, Acts, Actors
self.frame.enter()
# Prepare
# add a test stat key-value
roadStack = self.store.fetch('.salt.road.manor.stack')
laneStack = self.store.fetch('.salt.lane.manor.stack')
roadStack.value.stats = odict()
laneStack.value.stats = odict({'test_stats_event': 111})
# ensure stats are equal to expected
self.assertDictEqual(roadStack.value.stats, {})
self.assertDictEqual(laneStack.value.stats, {'test_stats_event': 111})
# add stats request
testStack = self.store.fetch('.salt.test.road.stack').value
statsReq = self.store.fetch('.salt.stats.event_req').value
tag = tagify('lane', 'stats')
minionName = roadStack.value.local.name
masterName = testStack.local.name
# lane stats request
statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
'src': (masterName, None, None)},
'tag': tag})
# Test
self.frame.recur() # run in frame
# Check
self.assertEqual(len(testStack.rxMsgs), 0)
testStack.serviceAll()
self.assertEqual(len(testStack.rxMsgs), 1)
msg, sender = testStack.rxMsgs.popleft()
self.assertDictEqual(msg, {u'route': {u'src': [ns2u(minionName), u'manor', None],
u'dst': [ns2u(masterName), None, u'event_fire']},
u'tag': ns2u(tag),
u'data': {u'test_stats_event': 111}})
# Close active stacks servers
act.actor.lane_stack.value.server.close()
act.actor.road_stack.value.server.close()
testStack = self.store.fetch('.salt.test.road.stack')
if testStack:
testStack.value.server.close()
def __init__(self,
name='',
main=None,
keep=None,
dirpath=None,
local=None,
eid=None,
ha=("", raeting.RAET_PORT),
bufcnt=2,
safe=None,
auto=None,
**kwa
):
'''
Setup StackUdp instance
'''
if not name:
name = "roadstack{0}".format(RoadStack.Count)
RoadStack.Count += 1
if not keep:
keep = keeping.RoadKeep(dirpath=dirpath, stackname=name)
if not safe:
safe = keeping.SafeKeep(dirpath=dirpath,
stackname=name,
auto=auto)
else:
if auto is not None:
safe.auto = True if auto else False
self.safe = safe
if not local:
self.remotes = odict()
local = estating.LocalEstate(stack=self,
eid=eid,
main=main,
ha=ha)
else:
if main is not None:
local.main = True if main else False
server = aiding.SocketUdpNb(ha=local.ha,
bufsize=raeting.UDP_MAX_PACKET_SIZE * bufcnt)
super(RoadStack, self).__init__(name=name,
keep=keep,
dirpath=dirpath,
local=local,
server=server,
**kwa)
self.transactions = odict() #transactions
self.dumpLocal() # save local data
self.dumpRemotes() # save remote data
def loadLocalRoleData(self):
'''
Load and return the role data
'''
keydata = self.saltRaetKey.read_local()
if not keydata:
keydata = odict([('sign', None), ('priv', None)])
data = odict([('sighex', keydata['sign']),
('prihex', keydata['priv'])])
return data
def loadLocalRoleData(self):
'''
Load and return the role data
'''
keydata = self.saltRaetKey.read_local()
if not keydata:
keydata = odict([('sign', None), ('priv', None)])
data = odict([('sighex', keydata['sign']),
('prihex', keydata['priv'])])
return data
def __init__(self,
name='',
main=False,
version=raeting.VERSION,
store=None,
estate=None,
eid=None,
ha=("", raeting.RAET_PORT),
rxMsgs=None,
txMsgs=None,
udpRxes=None,
udpTxes=None,
road=None,
safe=None,
auto=None,
dirpath=None,
):
'''
Setup StackUdp instance
'''
if not name:
name = "stackUdp{0}".format(StackUdp.Count)
StackUdp.Count += 1
self.name = name
self.version = version
self.store = store or storing.Store(stamp=0.0)
self.estates = odict() # remote estates attached to this stack by eid
self.eids = odict() # reverse lookup eid by estate.name
self.transactions = odict() #transactions
self.rxMsgs = rxMsgs if rxMsgs is not None else deque() # messages received
self.txMsgs = txMsgs if txMsgs is not None else deque() # messages to transmit
self.udpRxes = udpRxes if udpRxes is not None else deque() # udp packets received
self.udpTxes = udpTxes if udpTxes is not None else deque() # udp packet to transmit
self.road = road or keeping.RoadKeep(dirpath=dirpath,
stackname=self.name)
self.safe = safe or keeping.SafeKeep(dirpath=dirpath,
stackname=self.name,
auto=auto)
kept = self.loadLocal() # local estate from saved data
# local estate for this stack
self.estate = kept or estate or estating.LocalEstate(stack=self,
eid=eid,
main=main,
ha=ha)
self.estate.stack = self
self.serverUdp = aiding.SocketUdpNb(ha=self.estate.ha, bufsize=raeting.MAX_MESSAGE_SIZE)
self.serverUdp.reopen() # open socket
self.estate.ha = self.serverUdp.ha # update estate host address after open
self.dumpLocal() # save local estate data
kepts = self.loadAllRemote() # remote estates from saved data
for kept in kepts:
self.addRemoteEstate(kept)
self.dumpAllRemote() # save remote estate data
def testMinionStatsWrongMissingTag(self):
"""
Test Minion Stats requests with unknown and missing tag (A3, A4)
"""
console.terse("{0}\n".format(self.testMinionStatsWrongMissingTag.__doc__))
# Bootstrap
self.addEnterDeed("TestOptsSetupMinion")
self.addEnterDeed("SaltRaetManorLaneSetup")
self.addEnterDeed("SaltRaetRoadStackSetup")
self.addEnterDeed("StatsMinionTestSetup")
act = self.addRecurDeed("SaltRaetStatsEventerMinion")
self.resolve() # resolve House, Framer, Frame, Acts, Actors
self.frame.enter()
# Prepare
# add a test stat key-value
roadStack = self.store.fetch('.salt.road.manor.stack')
laneStack = self.store.fetch('.salt.lane.manor.stack')
roadStack.value.stats = odict({'test_road_stats_event': 111})
laneStack.value.stats = odict({'test_lane_stats_event': 222})
# ensure stats are equal to expected
self.assertDictEqual(roadStack.value.stats, {'test_road_stats_event': 111})
self.assertDictEqual(laneStack.value.stats, {'test_lane_stats_event': 222})
# add stats request
testStack = self.store.fetch('.salt.test.road.stack').value
statsReq = self.store.fetch('.salt.stats.event_req').value
tag = 'salt/unknown/tag'
self.assertNotEqual(tag, tagify('lane', 'stats'))
self.assertNotEqual(tag, tagify('road', 'stats'))
minionName = roadStack.value.local.name
masterName = testStack.local.name
# unknown tag in stats request
statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
'src': (masterName, None, None)},
'tag': tag})
# no tag in stats request
statsReq.append({'route': {'dst': (minionName, None, 'stats_req'),
'src': (masterName, None, None)}})
# Test
self.frame.recur() # run in frame
# Check
self.assertEqual(len(testStack.rxMsgs), 0)
testStack.serviceAll()
self.assertEqual(len(testStack.rxMsgs), 0)
# Close active stacks servers
act.actor.lane_stack.value.server.close()
act.actor.road_stack.value.server.close()
testStack = self.store.fetch('.salt.test.road.stack')
if testStack:
testStack.value.server.close()
class SaltRaetRoadStackManager(ioflo.base.deeding.Deed):
'''
Runs the manage method of RoadStack
FloScript:
do salt raet road stack manager
'''
Ioinits = odict(
inode=".raet.udp.stack.",
stack='stack',
alloweds={
'ipath': '.salt.var.presence.alloweds',
'ival': odict()
},
aliveds={
'ipath': '.salt.var.presence.aliveds',
'ival': odict()
},
availables={
'ipath': '.salt.var.presence.availables',
'ival': set()
},
changeds={
'ipath': '.salt.var.presence.changeds',
'ival': odict(plus=set(), minus=set())
},
)
def action(self, **kwa):
'''
Manage the presence of any remotes
availables is set of names of alive remotes which are also allowed
changeds is is share with two fields:
plus is set of names of newly available remotes
minus is set of names of newly unavailable remotes
alloweds is dict of allowed remotes keyed by name
aliveds is dict of alived remotes keyed by name
'''
stack = self.stack.value
if stack and isinstance(stack, RoadStack):
stack.manage(cascade=True)
# make copies
self.availables.value = set(self.stack.value.availables)
self.changeds.update(plus=set(self.stack.value.changeds['plus']))
self.changeds.update(minus=set(self.stack.value.changeds['minus']))
self.alloweds.value = odict(self.stack.value.alloweds)
self.aliveds.value = odict(self.stack.value.aliveds)
console.concise(
" Manage {0}.\nAvailables: {1}\nChangeds:\nPlus: {2}\n"
"Minus: {3}\nAlloweds: {4}\nAliveds{5}\n".format(
stack.name, self.availables.value, self.changeds.data.plus,
self.changeds.data.minus, self.alloweds.value,
self.aliveds.value))
def __init__(self,
name='',
main=None,
keep=None,
dirpath=None,
local=None,
eid=None, #local estate eid
ha=("", raeting.RAET_PORT),
bufcnt=2,
safe=None,
auto=None,
period=None,
offset=None,
**kwa
):
'''
Setup StackUdp instance
'''
self.eid = self.Eid # eid of next estate to add to road
if not name:
name = "roadstack{0}".format(RoadStack.Count)
RoadStack.Count += 1
if not keep:
keep = keeping.RoadKeep(dirpath=dirpath, stackname=name)
if not safe:
safe = keeping.SafeKeep(dirpath=dirpath,
stackname=name,
auto=auto)
self.safe = safe
if not local:
self.remotes = odict()
local = estating.LocalEstate(stack=self,
name=name,
eid=eid,
main=main,
ha=ha)
else:
if main is not None:
local.main = True if main else False
self.period = period if period is not None else self.Period
self.offset = offset if offset is not None else self.Offset
super(RoadStack, self).__init__(name=name,
keep=keep,
dirpath=dirpath,
local=local,
bufcnt=bufcnt,
**kwa)
self.transactions = odict() #transactions
def __init__(self,
name='',
main=None,
version=raeting.VERSION,
store=None,
keep=None,
local=None,
bufcnt=2,
server=None,
rxMsgs=None,
txMsgs=None,
rxes=None,
txes=None,
stats=None,
):
'''
Setup Stack instance
'''
if not name:
name = "{0}{1}".format(self.__class__.__name__.lower(), Stack.Count)
Stack.Count += 1
self.version = version
self.store = store or storing.Store(stamp=0.0)
self.local = local or lotting.LocalLot(stack=self,
name=name,
main=main,)
self.local.stack = self
if self.local.main is None and main is not None:
self.local.main = True if main else False
self.remotes = self.uidRemotes = odict() # remotes indexed by uid
self.nameRemotes = odict() # remotes indexed by name
self.haRemotes = odict() # remotes indexed by ha host address
self.bufcnt = bufcnt
if not server:
server = self.serverFromLocal()
self.server = server
if self.server:
if not self.server.reopen(): # open socket
raise raeting.StackError("Stack '{0}': Failed opening server at"
" '{1}'\n".format(self.name, self.server.ha))
if self.local:
self.local.ha = self.server.ha # update local host address after open
console.verbose("Stack '{0}': Opened server at '{1}'\n".format(self.name, self.local.ha))
self.rxMsgs = rxMsgs if rxMsgs is not None else deque() # messages received
self.txMsgs = txMsgs if txMsgs is not None else deque() # messages to transmit
self.rxes = rxes if rxes is not None else deque() # udp packets received
self.txes = txes if txes is not None else deque() # udp packet to transmit
self.stats = stats if stats is not None else odict() # udp statistics
self.statTimer = aiding.StoreTimer(self.store)
def testBasicJson(self):
'''
Basic pack parse with header json and body json
'''
console.terse("{0}\n".format(self.testBasicJson.__doc__))
hk = raeting.HeadKind.json.value
bk = raeting.BodyKind.json.value
data = odict(hk=hk, bk=bk)
#body = odict(msg='Hello Raet World', extra='Goodby Big Moon')
body = odict([('msg', 'Hello Raet World'), ('extra', 'Goodby Big Moon')])
packet0 = packeting.TxPacket(embody=body, data=data, )
self.assertDictEqual(packet0.body.data, body)
packet0.pack()
self.assertEqual(packet0.packed,
b'{"ri":"RAET","pl":"0000076","hl":"42","fg":"00","hk":1,"bk":1}\r\n\r\n{"msg":"Hello Raet World","extra":"Goodby Big Moon"}')
packet1 = packeting.RxPacket(packed=packet0.packed)
packet1.parse()
self.assertDictEqual(packet1.data, {'sh': '',
'sp': 7530,
'dh': '127.0.0.1',
'dp': 7530,
'ri':'RAET',
'vn': 0,
'pk': 0,
'pl': 118,
'hk': 1,
'hl': 66,
'se': 0,
'de': 0,
'cf': False,
'bf': False,
'nf': False,
'df': False,
'vf': False,
'si': 0,
'ti': 0,
'tk': 0,
'dt': 0,
'oi': 0,
'wf': False,
'sn': 0,
'sc': 1,
'ml': 0,
'sf': False,
'af': False,
'bk': 1,
'ck': 0,
'fk': 0,
'fl': 0,
'fg': '00'})
self.assertDictEqual(packet1.body.data, body)
def testAutoAccept(self):
'''
Basic send auto accept message
'''
console.terse("{0}\n".format(self.testAutoAccept.__doc__))
self.assertTrue(self.main.accept)
# Don't add remote yard to main so only way to get message from other is
# if auto acccept works
self.other.addRemote(yarding.RemoteYard(stack=self.other, ha=self.main.local.ha))
self.assertEqual(self.main.name, 'main')
self.assertEqual(self.main.local.name, 'main')
self.assertEqual(self.main.local.ha, os.path.join(self.baseDirpath, 'cherry.main.uxd'))
self.assertEqual(len(self.main.remotes), 0)
self.assertEqual(self.other.name, 'other')
self.assertEqual(self.other.local.name, 'other')
self.assertEqual(self.other.local.ha, os.path.join(self.baseDirpath, 'cherry.other.uxd'))
self.assertEqual(len(self.other.remotes), 1)
remote = self.other.remotes.values()[0]
self.assertEqual(remote.ha, os.path.join(self.baseDirpath, 'cherry.main.uxd'))
self.assertEqual(remote.name, 'main')
self.assertTrue(remote.uid in self.other.remotes)
self.assertTrue(remote.name in self.other.nameRemotes)
self.assertTrue(remote.ha in self.other.haRemotes)
self.assertIs(self.other.nameRemotes[remote.name], remote)
self.assertIs(self.other.haRemotes[remote.ha], remote)
stacking.LaneStack.Pk = raeting.packKinds.pack
others = []
others.append(odict(what="This is a message to the lord. Let me be", extra="Go away."))
self.message(mains=[], others=others)
self.assertEqual(len(self.main.remotes), 1)
remote = self.main.remotes.values()[0]
self.assertEqual(remote.ha, os.path.join(self.baseDirpath, 'cherry.other.uxd'))
self.assertEqual(remote.name, 'other')
self.assertTrue(remote.uid in self.main.remotes)
self.assertTrue(remote.name in self.main.nameRemotes)
self.assertTrue(remote.ha in self.main.haRemotes)
self.assertIs(self.main.nameRemotes[remote.name], remote)
self.assertIs(self.main.haRemotes[remote.ha], remote)
self.main.rxMsgs = deque()
self.other.rxMsgs = deque()
mains = []
mains.append(odict(what="This is a message to the serf. Get to Work", extra="Fix the fence."))
self.message(mains=mains, others=[])
def testBasicRaetMsgpack(self):
'''
Basic pack parse with header json and body msgpack
'''
console.terse("{0}\n".format(self.testBasicRaetMsgpack.__doc__))
hk = raeting.HeadKind.raet.value
bk = raeting.BodyKind.msgpack.value
data = odict(hk=hk, bk=bk)
#body = odict(msg='Hello Raet World', extra='Goodby Big Moon')
body = odict([('msg', 'Hello Raet World'), ('extra', 'Goodby Big Moon')])
packet0 = packeting.TxPacket(embody=body, data=data, )
self.assertDictEqual(packet0.body.data, body)
packet0.pack()
self.assertEqual(packet0.packed,
b'ri RAET\npl 004e\nhl 22\nfg 00\nbk 3\n\n\x82\xa3msg\xb0Hello Raet World\xa5extra\xafGoodby Big Moon')
packet1 = packeting.RxPacket(packed=packet0.packed)
packet1.parse()
self.assertDictEqual(packet1.data, {'sh': '',
'sp': 7530,
'dh': '127.0.0.1',
'dp': 7530,
'ri':'RAET',
'vn': 0,
'pk': 0,
'pl': 78,
'hk': 0,
'hl': 34,
'se': 0,
'de': 0,
'cf': False,
'bf': False,
'nf': False,
'df': False,
'vf': False,
'si': 0,
'ti': 0,
'tk': 0,
'dt': 0,
'oi': 0,
'wf': False,
'sn': 0,
'sc': 1,
'ml': 0,
'sf': False,
'af': False,
'bk': 3,
'ck': 0,
'fk': 0,
'fl': 0,
'fg': '00'})
self.assertDictEqual(packet1.body.data, body)
def testBasicMsgpack(self):
'''
Basic pack parse with header json and body msgpack
'''
console.terse("{0}\n".format(self.testBasicMsgpack.__doc__))
hk = raeting.headKinds.json
bk = raeting.bodyKinds.msgpack
data = odict(hk=hk, bk=bk)
body = odict(msg='Hello Raet World', extra='Goodby Big Moon')
packet0 = packeting.TxPacket(embody=body, data=data, )
self.assertDictEqual(packet0.body.data, body)
packet0.pack()
self.assertEqual(packet0.packed,
'{"ri":"RAET","pl":"0000064","hl":"38","hk":1,"bk":3}\r\n\r\n\x82\xa3msg\xb0Hello Raet World\xa5extra\xafGoodby Big Moon')
packet1 = packeting.RxPacket(packed=packet0.packed)
packet1.parse()
self.assertDictEqual(packet1.data, {'sh': '',
'sp': 7530,
'dh': '127.0.0.1',
'dp': 7530,
'ri':'RAET',
'vn': 0,
'pk': 0,
'pl': 100,
'hk': 1,
'hl': 56,
'se': 0,
'de': 0,
'cf': False,
'bf': False,
'nf': False,
'df': False,
'vf': False,
'si': 0,
'ti': 0,
'tk': 0,
'dt': 0,
'oi': 0,
'wf': False,
'sn': 0,
'sc': 1,
'ml': 0,
'sf': False,
'af': False,
'bk': 3,
'ck': 0,
'fk': 0,
'fl': 0,
'fg': '00'})
self.assertDictEqual(packet1.body.data, body)
def testBasicRaetJson(self):
'''
Basic pack parse with header raet and body json
'''
console.terse("{0}\n".format(self.testBasicRaetJson.__doc__))
hk = raeting.headKinds.raet
bk = raeting.bodyKinds.json
data = odict(hk=hk, bk=bk)
body = odict(msg='Hello Raet World', extra='Goodby Big Moon')
packet0 = packeting.TxPacket(embody=body, data=data, )
self.assertDictEqual(packet0.body.data, body)
packet0.pack()
self.assertEqual(packet0.packed,
'ri RAET\npl 0050\nhl 1c\nbk 1\n\n{"msg":"Hello Raet World","extra":"Goodby Big Moon"}')
packet1 = packeting.RxPacket(packed=packet0.packed)
packet1.parse()
self.assertDictEqual(packet1.data, {'sh': '',
'sp': 7530,
'dh': '127.0.0.1',
'dp': 7530,
'ri':'RAET',
'vn': 0,
'pk': 0,
'pl': 80,
'hk': 0,
'hl': 28,
'se': 0,
'de': 0,
'cf': False,
'bf': False,
'nf': False,
'df': False,
'vf': False,
'si': 0,
'ti': 0,
'tk': 0,
'dt': 0,
'oi': 0,
'wf': False,
'sn': 0,
'sc': 1,
'ml': 0,
'sf': False,
'af': False,
'bk': 1,
'ck': 0,
'fk': 0,
'fl': 0,
'fg': '00'})
self.assertDictEqual(packet1.body.data, body)
def testBasic(self):
"""
Test Basic
"""
console.terse("{0}\n".format(self.testBasic.__doc__))
console.terse("{0}\n".format("Connecting ...\n"))
hc = HTTPConnection('127.0.0.1', port=8080, timeout=1.0,)
hc.connect()
console.terse("{0}\n".format("Get '/echo?name=fame' ...\n"))
headers = odict([('Accept', 'application/json')])
hc.request(method='GET', path='/echo?name=fame', body=None, headers=headers )
response = hc.getresponse()
console.terse(str(response.fileno()) + "\n") # must call this before read
console.terse(str(response.getheaders()) + "\n")
console.terse(str(response.msg) + "\n")
console.terse(str(response.version) + "\n")
console.terse(str(response.status) + "\n")
console.terse(response.reason + "\n")
console.terse(str(response.read()) + "\n")
console.terse("{0}\n".format("Post ...\n"))
headers = odict([('Accept', 'application/json'), ('Content-Type', 'application/json')])
body = odict([('name', 'Peter'), ('occupation', 'Engineer')])
body = ns2b(json.dumps(body, separators=(',', ':'), encoding='utf-8'))
hc.request(method='POST', path='/demo', body=body, headers=headers )
response = hc.getresponse()
console.terse(str(response.fileno()) + "\n") # must call this before read
console.terse(str(response.getheaders()) + "\n")
console.terse(str(response.msg) + "\n")
console.terse(str(response.version) + "\n")
console.terse(str(response.status) + "\n")
console.terse(response.reason+ "\n")
console.terse(str(response.read()) + "\n")
#console.terse("{0}\n".format("SSE stream ...\n"))
#body = b''
#headers = odict([('Accept', 'application/json'), ('Content-Type', 'application/json')])
#hc.request(method='GET', path='/stream', body=body, headers=headers )
#response = hc.getresponse()
#console.terse(str(response.fileno()) + "\n") # must call this before read
#console.terse(str(response.getheaders()) + "\n")
#console.terse(str(response.msg) + "\n")
#console.terse(str(response.version) + "\n")
#console.terse(str(response.status) + "\n")
#console.terse(response.reason+ "\n")
#console.terse(str(response.read()) + "\n")
hc.close()
def testMessageMsgpack(self):
'''
Basic messaging with msgpack packing
'''
console.terse("{0}\n".format(self.testMessageMsgpack.__doc__))
self.bootstrap(kind=raeting.packKinds.pack)
mains = []
mains.append(odict(what="This is a message to the serf. Get to Work", extra="Fix the fence."))
others = []
others.append(odict(what="This is a message to the lord. Let me be", extra="Go away."))
self.message(mains=mains, others=others)
def test(hk=raeting.headKinds.raet):
"""
Test packeting.
"""
data = odict(hk=hk, bk=raeting.bodyKinds.json)
body = odict(msg="Hello Raet World", extra="what is this")
packet0 = packeting.TxPacket(embody=body, data=data)
print packet0.body.data
packet0.pack()
print packet0.packed
packet1 = packeting.RxPacket(packed=packet0.packed)
packet1.parse()
print packet1.data
print packet1.body.data
def __init__(self,
name='',
main=False,
keep=None,
dirpath='',
local=None,
lanename='lane',
yid=None,
yardname='',
sockdirpath='',
ha='',
bufcnt=10,
accept=None,
**kwa
):
'''
Setup StackUxd instance
'''
if not name:
name = "lanestack{0}".format(LaneStack.Count)
LaneStack.Count += 1
if not keep:
keep = keeping.LaneKeep(dirpath=dirpath, stackname=name)
if not local:
self.remotes = odict()
local = yarding.LocalYard( stack=self,
yid=yid,
name=yardname,
main=main,
ha=ha,
dirpath=sockdirpath,
lanename=lanename)
server = aiding.SocketUxdNb(ha=local.ha,
bufsize=raeting.UXD_MAX_PACKET_SIZE * bufcnt)
super(LaneStack, self).__init__(name=name,
keep=keep,
dirpath=dirpath,
local=local,
server=server,
**kwa)
self.books = odict()
self.accept = self.Accept if accept is None else accept #accept uxd msg if not in lane
def dumpRemote(self, remote):
'''
Dump remote estate
'''
data = odict([
('name', remote.name),
('uid', remote.uid),
('fuid', remote.fuid),
('ha', remote.ha),
('iha', remote.iha),
('natted', remote.natted),
('fqdn', remote.fqdn),
('dyned', remote.dyned),
('sid', remote.sid),
('main', remote.main),
('kind', remote.kind),
('joined', remote.joined),
('role', remote.role),
])
if self.verifyRemoteData(data, remoteFields=self.RemoteDumpFields):
self.dumpRemoteData(data, remote.name)
if remote.pubber.keyhex and remote.verfer.keyhex:
# kludge to persist the keys since no way to write
self.saltRaetKey.status(remote.role,
remote.pubber.keyhex,
remote.verfer.keyhex)
def stale(self, packet):
'''
Initiate stale transaction in order to nack a stale correspondent packet
but only for preexisting remotes
'''
if packet.data['pk'] in [PcktKind.nack,
PcktKind.unjoined,
PcktKind.unallowed,
PcktKind.renew,
PcktKind.refuse,
PcktKind.reject,]:
return # ignore stale nacks
create = False
uid = packet.data['de']
remote = self.retrieveRemote(uid=uid)
if not remote:
emsg = "Stack '{0}'. Unknown remote id '{1}', fail to nack stale\n".format(
self.name, uid)
console.terse(emsg)
self.incStat('invalid_remote_eid')
return
data = odict(hk=self.Hk, bk=self.Bk)
staler = transacting.Staler(stack=self,
remote=remote,
kind=packet.data['tk'],
sid=packet.data['si'],
tid=packet.data['ti'],
txData=data,
rxPacket=packet)
staler.nack()
def dumpRemotes(self):
'''
Dump all remotes data to files
'''
datadict = odict()
for remote in self.remotes.values():
self.dumpRemote(remote)
def message(self, body, uid=None):
'''
Sends message body to yard name and manages paging of long messages
'''
if uid is None:
if not self.remotes:
emsg = "No yard to send to\n"
console.terse(emsg)
self.incStat("invalid_destination")
return
uid = self.remotes.values()[0].name
if uid not in self.remotes:
emsg = "Invalid destination yard '{0}'\n".format(uid)
console.terse(emsg)
self.incStat("invalid_destination")
return
remote = self.remotes[uid]
data = odict(pk=self.Pk,
sn=self.local.name,
dn=remote.name,
si=remote.sid,
bi=remote.nextBid())
book = paging.TxBook(data=data, body=body)
try:
book.pack()
except raeting.PageError as ex:
console.terse(str(ex) + '\n')
self.incStat("packing_error")
return
for page in book.pages:
self.txes.append((page.packed, remote.ha))
def __init__(self,
local=None, #passed up from subclass
name='',
puid=None,
uid=None,
lanename='lane',
sockdirpath='',
ha='',
bufcnt=10,
accept=None,
**kwa
):
'''
Setup LaneStack instance
'''
if getattr(self, 'puid', None) is None:
self.puid = puid if puid is not None else self.Uid
local = local or yarding.Yard(stack=self,
name=name,
uid=uid,
ha=ha,
dirpath=sockdirpath,
lanename=lanename)
super(LaneStack, self).__init__(puid=puid,
local=local,
bufcnt=bufcnt,
**kwa)
self.haRemotes = odict() # remotes indexed by ha host address
self.accept = self.Accept if accept is None else accept #accept uxd msg if not in lane
def parse(self):
'''
Parses body. Assumes already unpacked.
Results in updated .data
'''
bk = self.packet.data['bk']
if bk not in raeting.BODY_KIND_NAMES:
self.packet.data['bk']= raeting.bodyKinds.unknown
emsg = "Unrecognizable packet body."
raise raeting.PacketError(emsg)
self.data = odict()
if bk == raeting.bodyKinds.json:
if self.packed:
kit = json.loads(self.packed, object_pairs_hook=odict)
if not isinstance(kit, Mapping):
emsg = "Packet body not a mapping."
raise raeting.PacketError(emsg)
self.data = kit
elif bk == raeting.bodyKinds.msgpack:
if self.packed:
if not msgpack:
emsg = "Msgpack not installed."
raise raeting.PacketError(emsg)
kit = msgpack.loads(self.packed, object_pairs_hook=odict)
if not isinstance(kit, Mapping):
emsg = "Packet body not a mapping."
raise raeting.PacketError(emsg)
self.data = kit
elif bk == raeting.bodyKinds.raw:
self.data = self.packed # return as string
elif bk == raeting.bodyKinds.nada:
pass
def stale(self, packet):
'''
Initiate stale transaction in order to nack a stale correspondent packet
'''
if packet.data['pk'] in [raeting.pcktKinds.nack,
raeting.pcktKinds.unjoined,
raeting.pcktKinds.unallowed,
raeting.pcktKinds.renew,
raeting.pcktKinds.refuse,
raeting.pcktKinds.reject,]:
return # ignore stale nacks
duid = packet.data['se']
ha = (packet.data['sh'], packet.data['sp'])
remote = self.retrieveRemote(duid=duid, ha=ha)
if not remote:
emsg = "Invalid remote destination estate id '{0}'\n".format(duid)
console.terse(emsg)
self.incStat('invalid_remote_eid')
return
data = odict(hk=self.Hk, bk=self.Bk)
staler = transacting.Staler(stack=self,
remote=remote,
kind=packet.data['tk'],
sid=packet.data['si'],
tid=packet.data['ti'],
txData=data,
rxPacket=packet)
staler.nack()
