def main(port, version, verbose, path):
if version:
click.echo(__version__)
return
projectDirpath = os.path.dirname(
os.path.dirname(os.path.abspath(os.path.expanduser(__file__))))
floScriptpath = os.path.join(projectDirpath, "didery/flo/main.flo")
click.echo("MAIN")
""" Main entry point for ioserve CLI"""
verbose = VERBIAGE_NAMES.index(verbose)
ioflo.app.run.run(name="skedder",
period=0.125,
real=True,
retro=True,
filepath=floScriptpath,
behaviors=['didery.core'],
mode='',
username='',
password='',
verbose=verbose,
consolepath='',
statistics=False,
preloads=[('.main.server.port', odict(value=port)),
('.main.server.db', odict(value=path))])
def eventsSetup(config, did):
if did is None:
raise ValueError("did required. Use --did")
h.validateDid(did)
preloads = [('.main.events.servers', odict(value=config["servers"])),
('.main.events.did', odict(value=did))]
return preloads
def testShare(self):
"""
Test Share Class
"""
console.terse("{0}\n".format(self.testShare.__doc__))
share = storing.Share()
self.assertEqual(share.name, '')
self.assertEqual(share.store, None)
self.assertEqual(share.stamp, None)
self.assertIsInstance(share.data, storing.Data)
self.assertEqual(share.data.__dict__, odict())
self.assertEqual(share.value, None)
self.assertEqual(share.truth, None)
self.assertEqual(share.unit, None)
self.assertEqual(share.owner, None)
self.assertEqual(share.deck, storing.Deck([]))
self.assertEqual(share.marks, odict([]))
share = storing.Share()
share.data.error = None
self.assertEqual(share.data.error, None)
self.assertEqual(share['error'], None)
haul = odict([('error', None),
('panSpeed', 50),
('tiltSpeed', 75)])
share.update(haul)
self.assertEqual(share.data.panSpeed, haul['panSpeed'])
self.assertEqual(share.data.tiltSpeed, haul['tiltSpeed'])
# order preserving
self.assertEqual(share.keys(), ["error", "panSpeed", "tiltSpeed"])
self.assertEqual(share.values(), [None, 50, 75])
self.assertEqual(share.items(), [("error", None),
("panSpeed", 50),
("tiltSpeed", 75)])
stuff = share.sift(haul.keys())
self.assertEqual(haul, stuff)
show = share.data._show()
self.assertEqual(show, 'Data: error=None panSpeed=50 tiltSpeed=75\n')
haul = odict([('panSpeed', 0),
('tiltSpeed', 0)])
share = storing.Share().update([('error', None)], haul)
self.assertEqual(share.data.error, None)
show = share.data._show()
self.assertEqual(show, 'Data: error=None panSpeed=0 tiltSpeed=0\n')
show = share.show() # need to make this more useful
self.assertEqual(show, 'Name Value None\nerror = None panSpeed = 0 tiltSpeed = 0\n')
def testShare(self):
"""
Test Share Class
"""
console.terse("{0}\n".format(self.testShare.__doc__))
share = storing.Share()
self.assertEqual(share.name, '')
self.assertEqual(share.store, None)
self.assertEqual(share.stamp, None)
self.assertIsInstance(share.data, storing.Data)
self.assertEqual(share.data.__dict__, odict())
self.assertEqual(share.value, None)
self.assertEqual(share.truth, None)
self.assertEqual(share.unit, None)
self.assertEqual(share.owner, None)
self.assertEqual(share.deck, storing.Deck([]))
self.assertEqual(share.marks, odict([]))
share = storing.Share()
share.data.error = None
self.assertEqual(share.data.error, None)
self.assertEqual(share['error'], None)
haul = odict([('error', None),
('panSpeed', 50),
('tiltSpeed', 75)])
share.update(haul)
self.assertEqual(share.data.panSpeed, haul['panSpeed'])
self.assertEqual(share.data.tiltSpeed, haul['tiltSpeed'])
# order preserving
self.assertEqual(share.keys(), ["error", "panSpeed", "tiltSpeed"])
self.assertEqual(share.values(), [None, 50, 75])
self.assertEqual(share.items(), [("error", None),
("panSpeed", 50),
("tiltSpeed", 75)])
stuff = share.sift(haul.keys())
self.assertEqual(haul, stuff)
show = share.data._show()
self.assertEqual(show, 'Data: error=None panSpeed=50 tiltSpeed=75\n')
haul = odict([('panSpeed', 0),
('tiltSpeed', 0)])
share = storing.Share().update([('error', None)], haul)
self.assertEqual(share.data.error, None)
show = share.data._show()
self.assertEqual(show, 'Data: error=None panSpeed=0 tiltSpeed=0\n')
show = share.show() # need to make this more useful
self.assertEqual(show, 'Name Value None\nerror = None panSpeed = 0 tiltSpeed = 0\n')
def uploadSetup(config, data, key_paths):
if data is None:
raise ValueError("Data file required. Use --data=path/to/file")
data = h.parseDataFile(data, "otp")
keys = getSigningKeys(key_paths)
sk = keys[0]
preloads = [('.main.upload.servers', odict(value=config["servers"])),
('.main.upload.data', odict(value=data)),
('.main.upload.sk', odict(value=sk))]
return preloads
def removeSetup(config, did, key_paths):
if did is None:
raise ValueError("did required. Use --did")
h.validateDid(did)
keys = getSigningKeys(key_paths)
sk = keys[0]
preloads = [('.main.remove.servers', odict(value=config["servers"])),
('.main.remove.did', odict(value=did)),
('.main.remove.sk', odict(value=sk))]
return preloads
def echoGet(action=None):
"""
Echo back request data
"""
query = dict(bottle.request.query.items())
body = bottle.request.json
raw = bottle.request.body.read()
form = odict(bottle.request.forms)
data = odict(verb=bottle.request.method,
url=bottle.request.url,
action=action,
query=query,
form=form,
content=body)
return data
def threadAlpha(stack, delay=0.125):
"""
return generator function threader in closure to run stack
"""
addJoinRemote(stack, "beta", 7532)
addJoinRemote(stack, "gamma", 7533)
timer = ioflo.aid.timing.StoreTimer(store=stack.store, duration=1.5)
while not timer.expired:
stack.serviceAll()
yield
stack.store.advanceStamp(delay)
msg = odict([("subject", "Introduction"),
("content", "Hello from alpha")])
messageAll(stack, msg)
timer.extend(extension=1.5)
while not timer.expired:
stack.serviceAll()
yield
stack.store.advanceStamp(delay)
printAll(stack)
closeStack(stack)
return
def bar(skin, req=None, rep=None):
"""
Generator function with "skin" parameter for skin wrapper to
attach attributes
"""
skin._status = 400
skin._headers = odict(example="Hi")
yield b""
yield b""
yield b"Hello There"
return b"Goodbye"
def inceptSetup(config, data, path, key_paths):
if data is None:
if key_paths:
click.echo(
"\nWARN: Key file will not be used unless a data file is provided with --data.\n"
)
history, sk = historyInit(path)
data = history
else:
data = h.parseDataFile(data, "history")
keys = getSigningKeys(key_paths)
sk = keys[0]
preloads = [('.main.incept.servers', odict(value=config["servers"])),
('.main.incept.data', odict(value=data)),
('.main.incept.sk', odict(value=sk))]
return preloads
def rotateSetup(config, data, path, key_paths):
if data is None:
raise ValueError("Data file required. Use --data=path/to/file")
data = h.parseDataFile(data, "history")
keys = getSigningKeys(key_paths, 2)
if click.confirm("Generate a new pre-rotated key pair?"):
pvk, psk = keyery(path)
data["signers"].append(pvk)
data["signer"] = int(data["signer"]) + 1
preloads = [('.main.rotate.servers', odict(value=config["servers"])),
('.main.rotate.data', odict(value=data)),
('.main.rotate.did', odict(value=data["id"])),
('.main.rotate.sk', odict(value=keys[0])),
('.main.rotate.psk', odict(value=keys[1]))]
return preloads
def bar(skin, req=None, rep=None):
"""
Generator function with "skin" parameter for skin wrapper to
attach attributes
"""
skin._status = 400
skin._headers = odict(example="Hi")
yield b""
yield b""
yield b"Hello There"
return b"Goodbye"
def main():
args = parseArgs(version=__version__)
projectDirpath = os.path.dirname(
os.path.dirname(os.path.abspath(os.path.expanduser(__file__))))
floScriptpath = os.path.join(projectDirpath, "didery/flo/main.flo")
ioflo.app.run.run(name="skedder",
period=100,
real=True,
retro=True,
filepath=floScriptpath,
behaviors=['didery.core'],
mode='',
username='',
password='',
verbose=args.verbose,
consolepath='',
statistics=False,
preloads=[('.main.server.port', odict(value=args.port)),
('.main.server.db', odict(value=args.path))])
def roadStackMessageAll(self, **kwa):
"""
Send message to all remotes
Ioinit attributes:
stack is a RoadStack instance
message is message to send with fields subject and content
Context: enter
Example:
do road stack message all at enter
"""
if self.stack.value:
stack = self.stack.value
msg = odict([("subject", self.message.data.subject),
("content", self.message.data.content)])
for remote in stack.remotes.values():
stack.transmit(msg, remote.uid)
async def threadGamma(stack, delay=0.125):
"""
return generator function threader in closure to run stack
"""
timer = ioflo.aid.timing.StoreTimer(store=stack.store, duration=1.5)
while not timer.expired:
stack.serviceAll()
await yielder()
stack.store.advanceStamp(delay)
msg = odict([("subject", "Introduction"),
("content", "Hello from gamma")])
messageAll(stack, msg)
timer.extend(extension=1.5)
while not timer.expired:
stack.serviceAll()
await yielder()
stack.store.advanceStamp(delay)
printAll(stack)
closeStack(stack)
return
def test_get_backend():
"""
"""
print("Testing Falcon Example Backend Call")
store = Store(stamp=0.0) # create store
priming.setupTest()
valet = Valet(
port=8101,
bufsize=131072,
store=store,
app=exapp,
)
result = valet.open()
assert result
assert valet.servant.ha == ('0.0.0.0', 8101)
assert valet.servant.eha == ('127.0.0.1', 8101)
path = "http://{}:{}{}".format('localhost', valet.servant.eha[1],
"/example/backend")
headers = odict([('Accept', 'application/json'), ('Content-Length', 0)])
patron = Patron(
bufsize=131072,
store=store,
method='GET',
path=path,
headers=headers,
reconnectable=True,
)
assert patron.connector.reopen()
assert patron.connector.accepted == False
assert patron.connector.connected == False
assert patron.connector.cutoff == False
patron.transmit()
timer = StoreTimer(store, duration=1.0)
while (patron.requests or patron.connector.txes or not patron.responses
or not valet.idle()):
valet.serviceAll()
time.sleep(0.05)
patron.serviceAll()
time.sleep(0.05)
store.advanceStamp(0.1)
assert patron.connector.accepted == True
assert patron.connector.connected == True
assert patron.connector.cutoff == False
assert len(valet.servant.ixes) == 1
assert len(valet.reqs) == 1
assert len(valet.reps) == 1
requestant = valet.reqs.values()[0]
assert requestant.method == patron.requester.method
assert requestant.url == patron.requester.path
assert requestant.headers == {
'accept': 'application/json',
'accept-encoding': 'identity',
'content-length': '0',
'host': 'localhost:8101'
}
assert len(patron.responses) == 1
rep = patron.responses.popleft()
assert rep['status'] == 200
assert rep['reason'] == 'OK'
assert rep['body'] == bytearray(
b'{\n "approved": true,\n "body": "\\nHello World\\n\\n"\n}')
assert rep['data'] == odict([('approved', True),
('body', '\nHello World\n\n')])
responder = valet.reps.values()[0]
assert responder.status.startswith(str(rep['status']))
assert responder.headers == rep['headers']
# test for error by sending query arg path
#request = odict([('method', 'GET'),
#('path', '/example/backend'),
#('qargs', odict(path='/unknown')),
#('fragment', u''),
#('headers', odict([('Accept', 'application/json'),
#('Content-Length', 0)])),
#])
#patron.requests.append(request)
headers = odict([('Accept', 'application/json'), ('Content-Length', 0)])
patron.request(method='GET',
path='/example/backend',
qargs=odict(path='/unknown'),
headers=headers)
timer = StoreTimer(store, duration=1.0)
while (patron.requests or patron.connector.txes or not patron.responses
or not valet.idle()):
valet.serviceAll()
time.sleep(0.05)
patron.serviceAll()
time.sleep(0.05)
store.advanceStamp(0.1)
assert len(patron.responses) == 1
rep = patron.responses.popleft()
assert rep['status'] == 404
assert rep['reason'] == 'Not Found'
assert rep['body'] == bytearray(b'404 Not Found\nBackend Validation'
b' Error\nError backend validation.'
b' unknown\n')
assert not rep['data']
valet.close()
patron.close()
print("Done Test")
def testData(self):
"""
Test Data Class
"""
console.terse("{0}\n".format(self.testData.__doc__))
data = storing.Data()
show = data._show()
self.assertEqual(show, 'Data: \n')
self.assertEqual(repr(data), 'Data([])')
data.x = 1
data.y = 2
data.a = 3
# order preserving
self.assertEqual(data.__dict__.keys(), ["x", "y", "a"])
self.assertEqual(data.__dict__.values(), [1, 2, 3])
self.assertEqual(data.__dict__.items(), [("x", 1),
("y", 2),
("a", 3)])
show = data._show()
self.assertEqual(show, 'Data: x=1 y=2 a=3\n')
self.assertEqual(repr(data), "Data([('x', 1), ('y', 2), ('a', 3)])")
stuff = data._sift()
self.assertEqual(stuff, odict([("x", 1),
("y", 2),
("a", 3)]))
self.assertEqual(stuff.keys(), data.__dict__.keys())
stuff = data._sift(("y", "x"))
self.assertEqual(stuff,odict([("y", 2),
("x", 1)]) )
self.assertEqual(stuff.keys(), ["y", "x"])
stuff = data._sift([])
self.assertEqual(stuff,odict() )
self.assertEqual(stuff.keys(), [])
with self.assertRaises(AttributeError) as ex:
data._b = 4
self.assertEqual(repr(data), "Data([('x', 1), ('y', 2), ('a', 3)])")
data._change([("z", 4), ("b", 5)])
self.assertEqual(data.__dict__.keys(), ["x", "y", "a", "z", "b"])
self.assertEqual(data.__dict__.values(), [1, 2, 3, 4, 5])
self.assertEqual(data.__dict__.items(), [("x", 1),
("y", 2),
("a", 3),
("z", 4),
("b", 5)])
items = [("x", 1),
("y", 2),
("a", 3),
("z", 4),
("b", 5)]
stuff = odict(items)
data = storing.Data(stuff)
self.assertEqual(repr(data),
"Data([('x', 1), ('y', 2), ('a', 3), ('z', 4), ('b', 5)])")
data = storing.Data(items)
self.assertEqual(repr(data),
"Data([('x', 1), ('y', 2), ('a', 3), ('z', 4), ('b', 5)])")
data = storing.Data(error=None)
self.assertEqual(data.error, None)
haul = odict([('error', None),
('panSpeed', 50),
('tiltSpeed', 75)])
data._change(haul)
self.assertEqual(data.panSpeed, haul['panSpeed'])
self.assertEqual(data.tiltSpeed, haul['tiltSpeed'])
# order preserving
self.assertEqual(data.__dict__.keys(), ["error", "panSpeed", "tiltSpeed"])
self.assertEqual(data.__dict__.values(), [None, 50, 75])
self.assertEqual(data.__dict__.items(), [("error", None),
("panSpeed", 50),
("tiltSpeed", 75)])
stuff = data._sift(haul.keys())
self.assertEqual(haul, stuff)
show = data._show()
self.assertEqual(show, 'Data: error=None panSpeed=50 tiltSpeed=75\n')
haul = odict([('panSpeed', 0),
('tiltSpeed', 0)])
data = storing.Data([('error', None)], haul)
self.assertEqual(data.error, None)
show = data._show()
self.assertEqual(show, 'Data: error=None panSpeed=0 tiltSpeed=0\n')
console = getConsole()
"""
Usage pattern
frame server
do ioserve server open at enter
do ioserve server service
do ioserve server close at exit
"""
@doify('IoserveServerOpen', ioinits=odict(valet="",
port=odict(inode="", ival=8080),
test=""))
def ioserveServerOpen(self, buffer=False, **kwa):
"""
Setup and open a rest server
Ioinit attributes
valet is Valet instance (wsgi server)
mock is Flag if True load mock service endpoints
test if Flag if True load test endpoints
Parameters:
buffer is boolean If True then create wire log buffer for Valet
Context: enter
console = getConsole()
"""
Usage pattern
frame server
do didery server open at enter
do didery server service
do didery server close at exit
"""
@doify('DideryServerOpen',
ioinits=odict(
valet="",
test="",
port=odict(ival=8080),
db=odict(ival=""),
mode=odict(ival=""),
))
def dideryServerOpen(self):
"""
Setup and open a rest server
Ioinit attributes
valet is Valet instance (wsgi server)
port is server port
Context: enter
Example:
do didery server open at enter
console.terse("Data:\t{}\n".format(formatted_data))
for url, result in results.items():
console.verbose("{}\n".format(result))
else:
console.terse("Consensus Failed.\n\n")
for url, result in results.items():
console.concise("{}\n".format(result))
@doify('Incept',
ioinits=odict(servers="",
data="",
sk="",
test="",
complete=odict(value=False),
verbosity="",
start=""))
def incept(self):
if not self.start.value:
self.complete.value = True
return
console = getConsole("didery.py", verbosity=self.verbosity.value)
outputSetupInfo(console, self.servers.value, data=self.data.value)
result = hist.postHistory(self.data.value, self.sk.value,
self.servers.value)
except ImportError:
import json
# ================================================== #
# CONSTANTS & GLOBALS #
# ================================================== #
console = getConsole()
# ================================================== #
# FUNCTIONS #
# ================================================== #
@doify('ReputationServerOpen', ioinits=odict(valet="",
port=odict(ival=8080),
dbDirPath="",
test="",
preload=""))
def reputationServerOpen(self, buffer=False, **kwa):
"""
Sets up and opens a rest server.
Ioinit Attributes:
valet - Valet instance (wsgi server)
port - Server port number
dbDirPath - Directory path for the database
test - Flag; If True, uses a test configuration if any is
available
preload - Flag; If True (and test is True), preloads the
database for testing
def main(incept, upload, rotate, update, retrieve, download, delete, remove,
events, v, mute, data, did, save, keys, config):
if mute:
verbose = 0
else:
v = 1 if v == 0 else v
verbose = v if v <= 4 else 4
preloads = [
('.main.incept.verbosity', odict(value=verbose)),
('.main.upload.verbosity', odict(value=verbose)),
('.main.rotate.verbosity', odict(value=verbose)),
('.main.update.verbosity', odict(value=verbose)),
('.main.retrieve.verbosity', odict(value=verbose)),
('.main.download.verbosity', odict(value=verbose)),
('.main.delete.verbosity', odict(value=verbose)),
('.main.remove.verbosity', odict(value=verbose)),
('.main.events.verbosity', odict(value=verbose)),
('.main.incept.start', odict(value=True if incept else False)),
('.main.upload.start', odict(value=True if upload else False)),
('.main.rotate.start', odict(value=True if rotate else False)),
('.main.update.start', odict(value=True if update else False)),
('.main.retrieve.start', odict(value=True if retrieve else False)),
('.main.download.start', odict(value=True if download else False)),
('.main.delete.start', odict(value=True if delete else False)),
('.main.remove.start', odict(value=True if remove else False)),
('.main.events.start', odict(value=True if events else False))
]
options = [
incept, upload, rotate, update, retrieve, download, delete, remove,
events
]
count = options.count(True)
if count > 1:
click.echo(
"Cannot combine --incept --upload, --rotate, --update, --retrieve, --download, --delete, --remove, or --events."
)
return
if count == 0:
click.echo("No options given. For help use --help. Exiting Didery.py")
return
try:
configData = h.parseConfigFile(config)
except ValidationError as err:
click.echo("Error parsing the config file: {}.".format(err))
return
try:
if incept:
preloads.extend(inceptSetup(configData, data, save, keys))
if upload:
preloads.extend(uploadSetup(configData, data, keys))
if rotate:
preloads.extend(rotateSetup(configData, data, save, keys))
if update:
preloads.extend(updateSetup(configData, data, keys))
if retrieve:
preloads.extend(retrieveSetup(configData, did))
if download:
preloads.extend(downloadSetup(configData, did))
if delete:
preloads.extend(deleteSetup(configData, did, keys))
if remove:
preloads.extend(removeSetup(configData, did, keys))
if events:
preloads.extend(eventsSetup(configData, did))
except (ValidationError, ValueError) as ex:
click.echo("Error setting up didery.py: {}.".format(ex))
return
projectDirpath = os.path.dirname(
os.path.dirname(os.path.abspath(os.path.expanduser(__file__))))
floScriptpath = os.path.join(projectDirpath, "diderypy/flo/main.flo")
""" Main entry point for ioserve CLI"""
ioflo.app.run.run(name="didery.py",
period=0.125,
real=True,
retro=True,
filepath=floScriptpath,
behaviors=['diderypy.core'],
mode='',
username='',
password='',
verbose=0,
consolepath='',
statistics=False,
preloads=preloads)
"""
Usage pattern
frame stacker
do road stack open at enter
do road stack service
do road stack close at exit
"""
@doify('RoadStackOpen',
ioinits=odict(stack="",
conf=odict(inode="",
ival=odict([("name", "server"),
("host", "0.0.0.0"),
("port", 7531)]))))
def roadStackOpen(self, **kwa):
"""
Setup and open a road stack
Ioinit attributes
stack holds RoadStack instance created here
conf is configuration data of stack with fields name, host, port
Context: enter
Example:
do road stack open at enter
"""
def testBasic(self):
"""
Test Valet Patron and Bottle
"""
console.terse("{0}\n".format(self.testBasic.__doc__))
store = Store(stamp=0.0)
app = bottle.default_app() # create bottle app
@app.get('/echo')
@app.get('/echo/<action>')
@app.post('/echo')
@app.post('/echo/<action>')
def echoGet(action=None):
"""
Echo back request data
"""
query = dict(bottle.request.query.items())
body = bottle.request.json
raw = bottle.request.body.read()
form = odict(bottle.request.forms)
data = odict(verb=bottle.request.method,
url=bottle.request.url,
action=action,
query=query,
form=form,
content=body)
return data
console.terse("{0}\n".format("Building Valet ...\n"))
wireLogAlpha = WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
alpha = Valet(port = 6101,
bufsize=131072,
wlog=wireLogAlpha,
store=store,
app=app)
self.assertIs(alpha.servant.reopen(), True)
self.assertEqual(alpha.servant.ha, ('0.0.0.0', 6101))
self.assertEqual(alpha.servant.eha, ('127.0.0.1', 6101))
console.terse("{0}\n".format("Building Patron ...\n"))
wireLogBeta = WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = Patron(bufsize=131072,
wlog=wireLogBeta,
store=store,
path=path,
reconnectable=True)
self.assertIs(beta.connector.reopen(), True)
self.assertIs(beta.connector.accepted, False)
self.assertIs(beta.connector.connected, False)
self.assertIs(beta.connector.cutoff, False)
request = odict([('method', u'GET'),
('path', u'/echo?name=fame'),
('qargs', odict()),
('fragment', u''),
('headers', odict([('Accept', 'application/json'),
('Content-Length', 0)])),
])
beta.requests.append(request)
timer = StoreTimer(store, duration=1.0)
while (beta.requests or beta.connector.txes or not beta.responses or
not alpha.idle()):
alpha.serviceAll()
time.sleep(0.05)
beta.serviceAll()
time.sleep(0.05)
store.advanceStamp(0.1)
self.assertIs(beta.connector.accepted, True)
self.assertIs(beta.connector.connected, True)
self.assertIs(beta.connector.cutoff, False)
self.assertEqual(len(alpha.servant.ixes), 1)
self.assertEqual(len(alpha.reqs), 1)
self.assertEqual(len(alpha.reps), 1)
requestant = alpha.reqs.values()[0]
self.assertEqual(requestant.method, request['method'])
self.assertEqual(requestant.url, request['path'])
self.assertEqual(requestant.headers, {'accept': 'application/json',
'accept-encoding': 'identity',
'content-length': '0',
'host': 'localhost:6101'})
self.assertEqual(len(beta.responses), 1)
response = beta.responses.popleft()
self.assertEqual(response['status'], 200)
self.assertEqual(response['reason'], 'OK')
self.assertEqual(response['body'],bytearray(b''))
self.assertEqual(response['data'],{'action': None,
'content': None,
'form': {},
'query': {'name': 'fame'},
'url': 'http://localhost:6101/echo?name=fame',
'verb': 'GET'},)
responder = alpha.reps.values()[0]
self.assertTrue(responder.status.startswith, str(response['status']))
self.assertEqual(responder.headers, response['headers'])
alpha.servant.closeAll()
beta.connector.close()
wireLogAlpha.close()
wireLogBeta.close()
alpha = createStack('alpha', 7531)
beta = createStack('beta', 7532)
gamma = createStack('gamma', 7533)
addJoinRemote(alpha, "beta", 7532)
addJoinRemote(alpha, "gamma", 7533)
addJoinRemote(beta, "gamma", 7533)
alphaThread = gevent.spawn(serviceStack, alpha)
betaThread = gevent.spawn(serviceStack, beta)
gammaThread = gevent.spawn(serviceStack, gamma)
gevent.sleep(1.5)
print("Queing messages\n")
msg = odict([("subject", "Introduction"), ("content", "Hello from alpha")])
messageAll(alpha, msg)
msg = odict([("subject", "Introduction"), ("content", "Hello from beta")])
messageAll(beta, msg)
msg = odict([("subject", "Introduction"), ("content", "Hello from gamma")])
messageAll(gamma, msg)
gevent.sleep(1.5)
printAll(alpha)
printAll(beta)
printAll(gamma)
gevent.joinall([alphaThread, betaThread, gammaThread])
def backendRequest(
method=u'GET',
scheme=u'', #default if not in path
host=u'localhost', # default if not in path
port=None, # default if not in path
path=u'/',
qargs=None,
data=None,
store=None,
timeout=2.0,
buffer=False,
):
"""
Perform Async ReST request to Backend Server
Parameters:
Usage: (Inside a generator function)
response = yield from backendRequest()
response is the response if valid else None
before response is completed the yield from yields up an empty string ''
once completed then response has a value
path can be full url with host port etc path takes precedence over others
"""
store = store if store is not None else Store(stamp=0.0)
if buffer:
wlog = WireLog(buffify=buffify, same=True)
wlog.reopen()
else:
wlog = None
headers = odict([('Accept', 'application/json'), ('Connection', 'close')])
client = Patron(
bufsize=131072,
wlog=wlog,
store=store,
scheme=scheme,
hostname=host,
port=port,
method=method,
path=path,
qargs=qargs,
headers=headers,
data=data,
reconnectable=False,
)
console.concise("Making Backend Request {0} {1} ...\n".format(
method, path))
client.transmit()
# assumes store clock is advanced elsewhere
timer = timing.StoreTimer(store=store, duration=timeout)
while ((client.requests or client.connector.txes or not client.responses)
and not timer.expired):
try:
client.serviceAll()
except Exception as ex:
console.terse(
"Error: Servicing backend client. '{0}'\n".format(ex))
raise ex
yield b'' # this is eventually yielded by wsgi app while waiting
response = None # in case timed out
if client.responses:
response = client.responses.popleft()
client.close()
if wlog:
wlog.close()
return response
def testTestStream(self):
"""
Test Valet WSGI service request response stream sse
"""
console.terse("{0}\n".format(self.testTestStream.__doc__))
store = Store(stamp=0.0)
app = bottle.default_app() # create bottle app
ending.loadTest(app, store)
console.terse("{0}\n".format("Building Valet ...\n"))
wireLogAlpha = WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
alpha = Valet(port = 6101,
bufsize=131072,
wlog=wireLogAlpha,
store=store,
app=app)
self.assertIs(alpha.servant.reopen(), True)
self.assertEqual(alpha.servant.ha, ('0.0.0.0', 6101))
self.assertEqual(alpha.servant.eha, ('127.0.0.1', 6101))
console.terse("{0}\n".format("Building Patron ...\n"))
wireLogBeta = WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = Patron(bufsize=131072,
wlog=wireLogBeta,
store=store,
path=path,
reconnectable=True)
self.assertIs(beta.connector.reopen(), True)
self.assertIs(beta.connector.accepted, False)
self.assertIs(beta.connector.connected, False)
self.assertIs(beta.connector.cutoff, False)
request = odict([('method', u'GET'),
('path', u'/test/stream'),
('qargs', odict()),
('fragment', u''),
('headers', odict([('Accept', 'application/json'),
('Content-Length', 0)])),
('body', None),
])
beta.requests.append(request)
timer = StoreTimer(store, duration=1.0)
while (not timer.expired):
alpha.serviceAll()
time.sleep(0.05)
beta.serviceAll()
time.sleep(0.05)
store.advanceStamp(0.1)
self.assertIs(beta.connector.accepted, True)
self.assertIs(beta.connector.connected, True)
self.assertIs(beta.connector.cutoff, False)
self.assertEqual(len(alpha.servant.ixes), 1)
self.assertEqual(len(alpha.reqs), 1)
self.assertEqual(len(alpha.reps), 1)
requestant = alpha.reqs.values()[0]
self.assertEqual(requestant.method, request['method'])
self.assertEqual(requestant.url, request['path'])
self.assertEqual(requestant.headers, {'accept': 'application/json',
'accept-encoding': 'identity',
'content-length': '0',
'host': 'localhost:6101'})
#timed out while stream still open so no responses in .responses
self.assertIs(beta.waited, True)
self.assertIs(beta.respondent.ended, False)
self.assertEqual(len(beta.responses), 0)
self.assertIn('content-type', beta.respondent.headers)
self.assertEqual(beta.respondent.headers['content-type'], 'text/event-stream')
self.assertIn('transfer-encoding', beta.respondent.headers)
self.assertEqual(beta.respondent.headers['transfer-encoding'], 'chunked')
self.assertTrue(len(beta.events) >= 3)
self.assertEqual(beta.respondent.retry, 1000)
self.assertTrue(int(beta.respondent.leid) >= 2)
event = beta.events.popleft()
self.assertEqual(event, {'id': '0', 'name': '', 'data': 'START'})
event = beta.events.popleft()
self.assertEqual(event, {'id': '1', 'name': '', 'data': '1'})
event = beta.events.popleft()
self.assertEqual(event, {'id': '2', 'name': '', 'data': '2'})
beta.events.clear()
#keep going until ended
timer.restart(duration=1.5)
while (not timer.expired):
alpha.serviceAll()
time.sleep(0.05)
beta.serviceAll()
time.sleep(0.05)
store.advanceStamp(0.1)
self.assertTrue(len(beta.events) >= 3)
self.assertEqual(beta.respondent.leid, '9')
self.assertEqual(beta.events[-2], {'id': '9', 'name': '', 'data': '9'})
self.assertEqual(beta.events[-1], {'id': '9', 'name': '', 'data': 'END'})
beta.events.clear()
alpha.servant.closeAll()
beta.connector.close()
wireLogAlpha.close()
wireLogBeta.close()
from ioflo.aid.sixing import *
from Resource import resource
from Resource import priming
console = getConsole()
# This file defines behaviors run by the main.flo script which control the server
@doify('ValetServerOpen',
ioinits=odict(
valet="",
port=odict(ival=8000),
dbDirPath="",
keepDirPath="",
test="",
preload="",
fakeHidKind=odict(ival=False),
))
def valetServerOpen(self, buffer=False, **kwa):
if buffer:
wlog = WireLog(buffify=True, same=True)
result = wlog.reopen()
else:
wlog = None
port = int(self.port.value)
app = falcon.API()
resource.loadResource(app, store=self.store)
console = getConsole()
"""
Usage pattern
frame server
do leopy server open at enter
do leopy server service
do leopy server close at exit
"""
@doify('LeopyServerOpen',
ioinits=odict(
valet="",
test="",
port=odict(ival=8080),
))
def leopyServerOpen(self):
"""
Setup and open a rest server
Ioinit attributes
valet is Valet instance (wsgi server)
port is server port
Context: enter
Example:
do leopy server open at enter
"""
def testData(self):
"""
Test Data Class
"""
console.terse("{0}\n".format(self.testData.__doc__))
data = storing.Data()
show = data._show()
self.assertEqual(show, 'Data: \n')
self.assertEqual(repr(data), 'Data([])')
data.x = 1
data.y = 2
data.a = 3
# order preserving
self.assertEqual(data.__dict__.keys(), ["x", "y", "a"])
self.assertEqual(data.__dict__.values(), [1, 2, 3])
self.assertEqual(data.__dict__.items(), [("x", 1),
("y", 2),
("a", 3)])
show = data._show()
self.assertEqual(show, 'Data: x=1 y=2 a=3\n')
self.assertEqual(repr(data), "Data([('x', 1), ('y', 2), ('a', 3)])")
stuff = data._sift()
self.assertEqual(stuff, odict([("x", 1),
("y", 2),
("a", 3)]))
self.assertEqual(stuff.keys(), data.__dict__.keys())
stuff = data._sift(("y", "x"))
self.assertEqual(stuff,odict([("y", 2),
("x", 1)]) )
self.assertEqual(stuff.keys(), ["y", "x"])
stuff = data._sift([])
self.assertEqual(stuff,odict() )
self.assertEqual(stuff.keys(), [])
with self.assertRaises(AttributeError) as ex:
data._b = 4
self.assertEqual(repr(data), "Data([('x', 1), ('y', 2), ('a', 3)])")
data._change([("z", 4), ("b", 5)])
self.assertEqual(data.__dict__.keys(), ["x", "y", "a", "z", "b"])
self.assertEqual(data.__dict__.values(), [1, 2, 3, 4, 5])
self.assertEqual(data.__dict__.items(), [("x", 1),
("y", 2),
("a", 3),
("z", 4),
("b", 5)])
items = [("x", 1),
("y", 2),
("a", 3),
("z", 4),
("b", 5)]
stuff = odict(items)
data = storing.Data(stuff)
self.assertEqual(repr(data),
"Data([('x', 1), ('y', 2), ('a', 3), ('z', 4), ('b', 5)])")
data = storing.Data(items)
self.assertEqual(repr(data),
"Data([('x', 1), ('y', 2), ('a', 3), ('z', 4), ('b', 5)])")
data = storing.Data(error=None)
self.assertEqual(data.error, None)
haul = odict([('error', None),
('panSpeed', 50),
('tiltSpeed', 75)])
data._change(haul)
self.assertEqual(data.panSpeed, haul['panSpeed'])
self.assertEqual(data.tiltSpeed, haul['tiltSpeed'])
# order preserving
self.assertEqual(data.__dict__.keys(), ["error", "panSpeed", "tiltSpeed"])
self.assertEqual(data.__dict__.values(), [None, 50, 75])
self.assertEqual(data.__dict__.items(), [("error", None),
("panSpeed", 50),
("tiltSpeed", 75)])
stuff = data._sift(haul.keys())
self.assertEqual(haul, stuff)
show = data._show()
self.assertEqual(show, 'Data: error=None panSpeed=50 tiltSpeed=75\n')
haul = odict([('panSpeed', 0),
('tiltSpeed', 0)])
data = storing.Data([('error', None)], haul)
self.assertEqual(data.error, None)
show = data._show()
self.assertEqual(show, 'Data: error=None panSpeed=0 tiltSpeed=0\n')
def testLoadTestEnds(self):
"""
Test behavior
"""
console.terse("{0}\n".format(self.testLoadTestEnds.__doc__))
store = Store(stamp=0.0)
app = bottle.default_app() # create bottle app
ending.loadTest(app, store)
console.terse("{0}\n".format("Building Valet ...\n"))
wireLogAlpha = WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
alpha = Valet(port = 6101,
bufsize=131072,
wlog=wireLogAlpha,
store=store,
app=app)
self.assertIs(alpha.servant.reopen(), True)
self.assertEqual(alpha.servant.ha, ('0.0.0.0', 6101))
self.assertEqual(alpha.servant.eha, ('127.0.0.1', 6101))
console.terse("{0}\n".format("Building Patron ...\n"))
wireLogBeta = WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = Patron(bufsize=131072,
wlog=wireLogBeta,
store=store,
path=path,
reconnectable=True)
self.assertIs(beta.connector.reopen(), True)
self.assertIs(beta.connector.accepted, False)
self.assertIs(beta.connector.connected, False)
self.assertIs(beta.connector.cutoff, False)
# get echo
request = odict([('method', u'GET'),
('path', u'/test/echo?name=fame'),
('qargs', odict()),
('fragment', u''),
('headers', odict([('Accept', 'application/json'),
('Content-Length', 0)])),
])
beta.requests.append(request)
timer = StoreTimer(store, duration=1.0)
while (beta.requests or beta.connector.txes or not beta.responses or
not alpha.idle()):
alpha.serviceAll()
time.sleep(0.05)
beta.serviceAll()
time.sleep(0.05)
store.advanceStamp(0.1)
self.assertIs(beta.connector.accepted, True)
self.assertIs(beta.connector.connected, True)
self.assertIs(beta.connector.cutoff, False)
self.assertEqual(len(alpha.servant.ixes), 1)
self.assertEqual(len(alpha.reqs), 1)
self.assertEqual(len(alpha.reps), 1)
requestant = alpha.reqs.values()[0]
self.assertEqual(requestant.method, request['method'])
self.assertEqual(requestant.url, request['path'])
self.assertEqual(requestant.headers, {'accept': 'application/json',
'accept-encoding': 'identity',
'content-length': '0',
'host': 'localhost:6101'})
self.assertEqual(len(beta.responses), 1)
response = beta.responses.popleft()
self.assertEqual(response['status'], 200)
self.assertEqual(response['reason'], 'OK')
self.assertEqual(response['body'],bytearray(b''))
self.assertEqual(response['data'],{'action': None,
'body': '',
'data': None,
'form': odict([]),
'headers': {'Accept': 'application/json',
'Accept-Encoding': 'identity',
'Content-Length': '0',
'Content-Type': '',
'Host': 'localhost:6101'},
'query': odict([('name', 'fame')]),
'url': 'http://localhost:6101/test/echo?name=fame',
'verb': 'GET'},)
responder = alpha.reps.values()[0]
self.assertTrue(responder.status.startswith, str(response['status']))
self.assertEqual(responder.headers, response['headers'])
# get routes
request = odict([('method', u'GET'),
('path', u'/test/route'),
('qargs', odict()),
('fragment', u''),
('headers', odict([('Accept', 'application/json'),
('Content-Length', 0)])),
])
beta.requests.append(request)
timer = StoreTimer(store, duration=1.0)
while (beta.requests or beta.connector.txes or not beta.responses or
not alpha.idle()):
alpha.serviceAll()
time.sleep(0.05)
beta.serviceAll()
time.sleep(0.05)
store.advanceStamp(0.1)
self.assertIs(beta.connector.accepted, True)
self.assertIs(beta.connector.connected, True)
self.assertIs(beta.connector.cutoff, False)
self.assertEqual(len(alpha.servant.ixes), 1)
self.assertEqual(len(alpha.reqs), 1)
self.assertEqual(len(alpha.reps), 1)
requestant = alpha.reqs.values()[0]
self.assertEqual(requestant.method, request['method'])
self.assertEqual(requestant.url, request['path'])
self.assertEqual(requestant.headers, {'accept': 'application/json',
'accept-encoding': 'identity',
'content-length': '0',
'host': 'localhost:6101'})
self.assertEqual(len(beta.responses), 1)
response = beta.responses.popleft()
self.assertEqual(response['status'], 200)
self.assertEqual(response['reason'], 'OK')
self.assertEqual(response['body'], bytearray(
b'Web app file is located at /Data/Code/public/ioserve/ios'
b'erve/end\n/echo/<action> POST\n/echo POST\n/echo/<actio'
b'n> GET\n/echo GET\n/ GET\n/test GET\n/test/route GET\n/te'
b'st/echo POST\n/test/echo/<action> POST\n/test/echo GET'
b'\n/test/echo/<action> GET\n/test/auth POST\n/test/auth/'
b'<token> POST\n/test/auth GET\n/test/auth/<token> GET\n/'
b'test/stream GET'))
self.assertEqual(response['data'],{
'action': None,
'body': '',
'data': None,
'form': odict([]),
'headers': {'Accept': 'application/json',
'Accept-Encoding': 'identity',
'Content-Length': '0',
'Content-Type': '',
'Host': 'localhost:6101'},
'query': odict([('name', 'fame')]),
'url': 'http://localhost:6101/test/echo?name=fame',
'verb': 'GET'},)
responder = alpha.reps.values()[0]
self.assertTrue(responder.status.startswith, str(response['status']))
self.assertEqual(responder.headers, response['headers'])
alpha.servant.closeAll()
beta.connector.close()
wireLogAlpha.close()
wireLogBeta.close()
