def reputationServerOpen(self, buffer=False, **kwa):
if buffer:
wlog = WireLog(buffify=True, same=True)
result = wlog.reopen()
else:
wlog = None
port = int(self.port.value)
test = True if self.test.value else False
preload = True if self.preload.value else False
if test:
priming.setupTest()
if preload:
dbing.preloadTestDbs()
else:
dbDirPath = self.dbDirPath.value if self.dbDirPath.value else None
dbDirPath = os.path.abspath(os.path.expanduser(dbDirPath)) if dbDirPath else None
priming.setup(dbDirPath)
self.dbDirPath.value = dbing.gDbDirPath
app = falcon.API()
ending.loadEnds(app, store=self.store)
self.valet.value = Valet(port=port,
bufsize=131072,
wlog=wlog,
store=self.store,
app=app,
timeout=0.5)
result = self.valet.value.servant.reopen()
if not result:
console.terse("Error opening server '{0}' at '{1}'\n".format(
self.valet.name,
self.valet.value.servant.ha))
return
console.concise("Opened server '{0} at '{1}'\n".format(
self.valet.name,
self.valet.value.servant.ha))
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
"""
port = int(self.port.value)
dbing.setupDbEnv(self.db.value, self.port.value, mode=self.mode.value)
app = falcon.API(middleware=[routing.CORSMiddleware()])
routing.loadEndPoints(app, store=self.store, mode=self.mode.value)
self.valet.value = Valet(
port=port,
bufsize=131072,
wlog=None,
store=self.store,
app=app,
timeout=0.5,
)
console.terse("IP Address {}\n".format(self.valet.value.servant.ha))
result = self.valet.value.servant.reopen()
if not result:
console.terse("Error opening server '{0}' at '{1}'\n".format(
self.valet.name, self.valet.value.servant.ha))
return
console.concise("Opened server '{0}' at '{1}'\n".format(
self.valet.name,
self.valet.value.servant.ha,
))
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)
test = True if self.test.value else False # use to load test environment
preload = True if self.preload.value else False # load test db if test and True
wlog = None
prime = priming.setup()
#self.dbDirPath.value = dbing.gDbDirPath
#self.keepDirPath.value = keeping.gKeepDirPath
self.valet.value = Valet(
port=port,
bufsize=131072,
wlog=wlog,
store=self.store,
app=app,
timeout=0.5,
)
result = self.valet.value.servant.reopen()
if not result:
console.terse("Error opening server '{0}' at '{1}'\n".format(
self.valet.name, self.valet.value.servant.ha))
return
console.concise("Opened server '{0}' at '{1}'\n".format(
self.valet.name,
self.valet.value.servant.ha,
))
def run_valet():
"""
Use ioflo valet server
"""
console.reinit(verbosity=console.Wordage.profuse)
store = Store(stamp=0.0)
app = falcon.API() # falcon.API instances are callable WSGI apps
sink = StaticSink()
app.add_sink(sink, prefix="/")
server = Valet(store=store, app=app, name='test', port=8080, timeout=0.5)
server.open()
while True:
server.serviceAll()
time.sleep(0.0625)
store.advanceStamp(0.0625)
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
Parameters:
buffer - Flag; If True, creates wire log buffer for Valet
Context:
enter
Example Usage:
do reputation server open at enter
"""
if buffer:
wireLog = WireLog(buffify=True, same=True)
result = wireLog.reopen()
else:
wireLog = None
port = int(self.port.value)
test = True if self.test.value else False
preload = True if self.preload.value else False
if test:
priming.setupTest()
if preload:
dbing.preloadTestDbs()
else:
dbDirPath = self.dbDirPath.value if self.dbDirPath.value else None
dbDirPath = os.path.abspath(os.path.expanduser(dbDirPath)) if dbDirPath else None
priming.setup(dbDirPath)
self.dbDirPath.value = dbing.gDbDirPath
app = falcon.API()
ending.loadEnds(app, store=self.store)
self.valet.value = Valet(port=port,
bufsize=131072,
wlog=wireLog,
store=self.store,
app=app,
timeout=0.5)
result = self.valet.value.servant.reopen()
if not result:
console.terse("Error opening server '{0}' at '{1}'\n".format(
self.valet.name,
self.valet.value.servant.ha))
return
console.concise("Opened server '{0} at '{1}'\n".format(
self.valet.name,
self.valet.value.servant.ha))
def microserviceServerOpen(self, buffer=False, **kwa):
"""
Setup and open a rest server
Ioinit attributes
valet is Valet instance (wsgi server)
port is server port
dbDirPath is directory path for database
keepDirPath is directory path for private key files
test is Flag if True load test endpoints and test database
test is Flag if True and if test is True then preload database for testing
fakeHidKind is Flag IF True then enable "fake" HID kind that does not require validation
Parameters:
buffer is boolean If True then create wire log buffer for Valet
Context: enter
Example:
do bluepea server open at enter
"""
if buffer:
wlog = WireLog(buffify=True, same=True)
result = wlog.reopen()
else:
wlog = None
microserviceconstnclass.fakeHidKind = self.fakeHidKind.value # set global flag
port = int(self.port.value)
'''
test = True if self.test.value else False # use to load test environment
preload = True if self.preload.value else False # load test db if test and True
if test:
priming.setupTest()
if preload:
dbing.preloadTestDbs()
else:
keepDirPath = self.keepDirPath.value if self.keepDirPath.value else None # None is default
keepDirPath = os.path.abspath(os.path.expanduser(keepDirPath)) if keepDirPath else None
dbDirPath = self.dbDirPath.value if self.dbDirPath.value else None # None is default
dbDirPath = os.path.abspath(os.path.expanduser(dbDirPath)) if dbDirPath else None
priming.setup(keepDirPath=keepDirPath, dbDirPath=dbDirPath)
self.dbDirPath.value = dbing.gDbDirPath
self.keepDirPath.value = keeping.gKeepDirPath
'''
app = falcon.API() # falcon.API instances are callable WSGI apps
ending.loadEnds(app, store=self.store)
self.valet.value = Valet(
port=port,
bufsize=131072,
wlog=wlog,
store=None,
app=app,
timeout=0.5,
)
result = self.valet.value.servant.reopen()
if not result:
console.terse("Error opening server '{0}' at '{1}'\n".format(
self.valet.name, self.valet.value.servant.ha))
return
console.concise("Opened server '{0}' at '{1}'\n".format(
self.valet.name,
self.valet.value.servant.ha,
))
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 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()
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()
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()