def testWireLog(self):
"""
Test Class WireLog
"""
console.terse("{0}\n".format(self.testWireLog.__doc__))
userDirpath = os.path.join('~', '.ioflo', 'test')
userDirpath = os.path.abspath(os.path.expanduser(userDirpath))
if not os.path.exists(userDirpath):
os.makedirs(userDirpath)
tempDirpath = tempfile.mkdtemp(prefix="test",
suffix="log",
dir=userDirpath)
logDirpath = os.path.join(tempDirpath, 'log')
if not os.path.exists(logDirpath):
os.makedirs(logDirpath)
wire = wiring.WireLog(path=logDirpath)
prefix = 'localhost'
midfix = '5000'
result = wire.reopen(prefix=prefix, midfix=midfix)
self.assertIsNotNone(wire.rxLog)
self.assertIsNotNone(wire.txLog)
self.assertFalse(wire.rxLog.closed)
self.assertFalse(wire.txLog.closed)
self.assertTrue(wire.rxLog.name.endswith('_rx.txt'))
self.assertTrue(wire.txLog.name.endswith('_tx.txt'))
self.assertTrue("{0}_{1}_".format(prefix, midfix) in wire.rxLog.name)
self.assertTrue("{0}_{1}_".format(prefix, midfix) in wire.txLog.name)
ha = ('127.0.0.1', 5000)
data = b"Test data Tx"
wire.writeTx(ha, data)
wire.txLog.seek(0)
result = wire.txLog.readline()
result += wire.txLog.readline()
self.assertEqual(
result, ns2b("TX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
data = b"Test data Rx"
wire.writeRx(ha, data)
wire.rxLog.seek(0)
result = wire.rxLog.readline()
result += wire.rxLog.readline()
self.assertEqual(
result, ns2b("RX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
wire.close()
wire = wiring.WireLog(path=logDirpath, same=True)
prefix = 'localhost'
midfix = '5000'
result = wire.reopen(prefix=prefix, midfix=midfix)
self.assertIsNotNone(wire.rxLog)
self.assertIsNotNone(wire.txLog)
self.assertFalse(wire.rxLog.closed)
self.assertFalse(wire.txLog.closed)
self.assertIs(wire.rxLog, wire.txLog)
self.assertEqual(wire.rxLog.name, wire.txLog.name)
self.assertTrue(wire.rxLog.name.endswith('.txt'))
self.assertTrue(wire.txLog.name.endswith('.txt'))
self.assertTrue("{0}_{1}_".format(prefix, midfix) in wire.rxLog.name)
self.assertTrue("{0}_{1}_".format(prefix, midfix) in wire.txLog.name)
ha = ('127.0.0.1', 5000)
data = b"Test data Tx"
wire.writeTx(ha, data)
wire.txLog.seek(0)
result = wire.txLog.readline()
result += wire.txLog.readline()
self.assertEqual(
result, ns2b("TX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
spot = wire.txLog.tell()
data = b"Test data Rx"
wire.writeRx(ha, data)
wire.rxLog.seek(spot)
result = wire.rxLog.readline()
result += wire.rxLog.readline()
self.assertEqual(
result, ns2b("RX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
wire.close()
shutil.rmtree(tempDirpath)
def testSocketUxdNb(self):
"""
Test Class SocketUxdNb
"""
console.terse("{0}\n".format(self.testSocketUxdNb.__doc__))
console.reinit(verbosity=console.Wordage.profuse)
userDirpath = os.path.join('~', '.ioflo', 'test')
userDirpath = os.path.abspath(os.path.expanduser(userDirpath))
if not os.path.exists(userDirpath):
os.makedirs(userDirpath)
tempDirpath = tempfile.mkdtemp(prefix="test", suffix="uxd", dir=userDirpath)
sockDirpath = os.path.join(tempDirpath, 'uxd')
if not os.path.exists(sockDirpath):
os.makedirs(sockDirpath)
logDirpath = os.path.join(tempDirpath, 'log')
if not os.path.exists(logDirpath):
os.makedirs(logDirpath)
wireLog = wiring.WireLog(path=logDirpath)
result = wireLog.reopen(prefix='alpha', midfix='uxd')
ha = os.path.join(sockDirpath, 'alpha.uxd')
alpha = uxding.SocketUxdNb(ha=ha, umask=0x077, wlog=wireLog)
self.assertIs(alpha.opened, False)
result = alpha.reopen()
self.assertIs(result, True)
self.assertIs(alpha.opened, True)
self.assertEqual(alpha.ha, ha)
ha = os.path.join(sockDirpath, 'beta.uxd')
beta = uxding.SocketUxdNb(ha=ha, umask=0x077)
result = beta.reopen()
self.assertIs(result, True)
self.assertEqual(beta.ha, ha)
ha = os.path.join(sockDirpath, 'gamma.uxd')
gamma = uxding.SocketUxdNb(ha=ha, umask=0x077)
result = gamma.reopen()
self.assertIs(result, True)
self.assertEqual(gamma.ha, ha)
txMsg = b"Alpha sends to Beta"
alpha.send(txMsg, beta.ha)
rxMsg, sa = beta.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, alpha.ha)
txMsg = b"Alpha sends to Gamma"
alpha.send(txMsg, gamma.ha)
rxMsg, sa = gamma.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, alpha.ha)
txMsg = b"Alpha sends to Alpha"
alpha.send(txMsg, alpha.ha)
rxMsg, sa = alpha.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, alpha.ha)
txMsg = b"Beta sends to Alpha"
beta.send(txMsg, alpha.ha)
rxMsg, sa = alpha.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, beta.ha)
txMsg = b"Beta sends to Gamma"
beta.send(txMsg, gamma.ha)
rxMsg, sa = gamma.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, beta.ha)
txMsg = b"Beta sends to Beta"
beta.send(txMsg, beta.ha)
rxMsg, sa = beta.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, beta.ha)
txMsg = b"Gamma sends to Alpha"
gamma.send(txMsg, alpha.ha)
rxMsg, sa = alpha.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, gamma.ha)
txMsg = b"Gamma sends to Beta"
gamma.send(txMsg, beta.ha)
rxMsg, sa = beta.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, gamma.ha)
txMsg = b"Gamma sends to Gamma"
gamma.send(txMsg, gamma.ha)
rxMsg, sa = gamma.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, gamma.ha)
pairs = [(alpha, beta), (alpha, gamma), (alpha, alpha),
(beta, alpha), (beta, gamma), (beta, beta),
(gamma, alpha), (gamma, beta), (gamma, gamma),]
names = [('alpha', 'beta'), ('alpha', 'gamma'), ('alpha', 'alpha'),
('beta', 'alpha'), ('beta', 'gamma'), ('beta', 'beta'),
('gamma', 'alpha'), ('gamma', 'beta'), ('gamma', 'gamma'),]
for i, pair in enumerate(pairs):
txer, rxer = pair
txName, rxName = names[i]
txMsg = ns2b("{0} sends to {1} again".format(txName.capitalize(), rxName.capitalize()))
txer.send(txMsg, rxer.ha)
rxMsg, sa = rxer.receive()
self.assertEqual(txMsg, rxMsg)
self.assertEqual(sa, txer.ha)
rxMsg, sa = alpha.receive()
self.assertIs(b'', rxMsg)
self.assertIs(None, sa)
rxMsg, sa = beta.receive()
self.assertIs(b'', rxMsg)
self.assertIs(None, sa)
rxMsg, sa = gamma.receive()
self.assertIs(b'', rxMsg)
self.assertIs(None, sa)
alpha.close()
beta.close()
gamma.close()
self.assertIs(alpha.opened, False)
wireLog.close()
shutil.rmtree(tempDirpath)
console.reinit(verbosity=console.Wordage.concise)
def testSocketUdpNb(self):
"""
Test Class SocketUdpNb
"""
console.terse("{0}\n".format(self.testSocketUdpNb.__doc__))
console.reinit(verbosity=console.Wordage.profuse)
userDirpath = os.path.join('~', '.ioflo', 'test')
userDirpath = os.path.abspath(os.path.expanduser(userDirpath))
if not os.path.exists(userDirpath):
os.makedirs(userDirpath)
tempDirpath = tempfile.mkdtemp(prefix="test",
suffix="log",
dir=userDirpath)
logDirpath = os.path.join(tempDirpath, 'log')
if not os.path.exists(logDirpath):
os.makedirs(logDirpath)
wireLog = wiring.WireLog(path=logDirpath)
result = wireLog.reopen(prefix='alpha', midfix='6101')
alpha = udping.SocketUdpNb(port=6101, wlog=wireLog)
self.assertIs(alpha.opened, False)
self.assertIs(alpha.reopen(), True)
self.assertIs(alpha.opened, True)
beta = udping.SocketUdpNb(port=6102)
self.assertIs(beta.opened, False)
self.assertIs(beta.reopen(), True)
self.assertIs(beta.opened, True)
console.terse("Sending alpha to beta\n")
msgOut = b"alpha sends to beta"
alpha.send(msgOut, beta.ha)
time.sleep(0.05)
msgIn, src = beta.receive()
self.assertEqual(msgOut, msgIn)
self.assertEqual(src[1], alpha.ha[1])
console.terse("Sending alpha to alpha\n")
msgOut = b"alpha sends to alpha"
alpha.send(msgOut, alpha.ha)
time.sleep(0.05)
msgIn, src = alpha.receive()
self.assertEqual(msgOut, msgIn)
self.assertEqual(src[1], alpha.ha[1])
console.terse("Sending beta to alpha\n")
msgOut = b"beta sends to alpha"
beta.send(msgOut, alpha.ha)
time.sleep(0.05)
msgIn, src = alpha.receive()
self.assertEqual(msgOut, msgIn)
self.assertEqual(src[1], beta.ha[1])
time.sleep(0.05)
console.terse("Sending beta to beta\n")
msgOut = b"beta sends to beta"
beta.send(msgOut, beta.ha)
time.sleep(0.05)
time.sleep(0.05)
msgIn, src = beta.receive()
self.assertEqual(msgOut, msgIn)
self.assertEqual(src[1], beta.ha[1])
alpha.close()
beta.close()
self.assertIs(alpha.opened, False)
wireLog.close()
shutil.rmtree(tempDirpath)
console.reinit(verbosity=console.Wordage.concise)
def testWireLogBuffify(self):
"""
Test Class WireLog
"""
console.terse("{0}\n".format(self.testWireLogBuffify.__doc__))
wire = wiring.WireLog(buffify=True)
prefix = 'localhost'
midfix = '5000'
result = wire.reopen(prefix=prefix, midfix=midfix)
self.assertIsNotNone(wire.rxLog)
self.assertIsNotNone(wire.txLog)
self.assertFalse(wire.rxLog.closed)
self.assertFalse(wire.txLog.closed)
ha = ('127.0.0.1', 5000)
data = b"Test data Tx"
wire.writeTx(ha, data)
wire.txLog.seek(0)
result = wire.txLog.readline()
result += wire.txLog.readline()
self.assertEqual(
result, ns2b("TX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
data = b"Test data Rx"
wire.writeRx(ha, data)
wire.rxLog.seek(0)
result = wire.rxLog.readline()
result += wire.rxLog.readline()
self.assertEqual(
result, ns2b("RX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
wire.close()
wire = wiring.WireLog(buffify=True, same=True)
prefix = 'localhost'
midfix = '5000'
result = wire.reopen(prefix=prefix, midfix=midfix)
self.assertIsNotNone(wire.rxLog)
self.assertIsNotNone(wire.txLog)
self.assertFalse(wire.rxLog.closed)
self.assertFalse(wire.txLog.closed)
self.assertIs(wire.rxLog, wire.txLog)
ha = ('127.0.0.1', 5000)
data = b"Test data Tx"
wire.writeTx(ha, data)
wire.txLog.seek(0)
result = wire.txLog.readline()
result += wire.txLog.readline()
self.assertEqual(
result, ns2b("TX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
spot = wire.txLog.tell()
data = b"Test data Rx"
wire.writeRx(ha, data)
wire.rxLog.seek(spot)
result = wire.rxLog.readline()
result += wire.rxLog.readline()
self.assertEqual(
result, ns2b("RX {0}\n{1}\n".format(ha,
data.decode('ISO-8859-1'))))
wire.close()
def testValetServiceBottleSecure(self):
"""
Test Valet WSGI service secure TLS request response
"""
console.terse("{0}\n".format(
self.testValetServiceBottleSecure.__doc__))
try:
import bottle
except ImportError as ex:
console.terse("Bottle not available.\n")
return
store = storing.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 = wiring.WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
#serverKeypath = '/etc/pki/tls/certs/server_key.pem' # local server private key
#serverCertpath = '/etc/pki/tls/certs/server_cert.pem' # local server public cert
#clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
serverKeypath = self.certdirpath + '/server_key.pem' # local server private key
serverCertpath = self.certdirpath + '/server_cert.pem' # local server public cert
clientCafilepath = self.certdirpath + '/client.pem' # remote client public cert
alpha = serving.Valet(
port=6101,
bufsize=131072,
wlog=wireLogAlpha,
store=store,
app=app,
scheme='https',
keypath=serverKeypath,
certpath=serverCertpath,
cafilepath=clientCafilepath,
)
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 = wiring.WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
#clientKeypath = '/etc/pki/tls/certs/client_key.pem' # local client private key
#clientCertpath = '/etc/pki/tls/certs/client_cert.pem' # local client public cert
#serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
clientKeypath = self.certdirpath + '/client_key.pem' # local client private key
clientCertpath = self.certdirpath + '/client_cert.pem' # local client public cert
serverCafilepath = self.certdirpath + '/server.pem' # remote server public cert
path = "https://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = clienting.Patron(bufsize=131072,
wlog=wireLogBeta,
store=store,
path=path,
reconnectable=True,
scheme='https',
certedhost=serverCertCommonName,
keypath=clientKeypath,
certpath=clientCertpath,
cafilepath=serverCafilepath)
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': 'https://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 testValetServiceBasicSecure(self):
"""
Test Valet WSGI service with secure TLS request response
"""
console.terse("{0}\n".format(self.testValetServiceBasicSecure.__doc__))
store = storing.Store(stamp=0.0)
def wsgiApp(environ, start_response):
start_response('200 OK', [('Content-type', 'text/plain'),
('Content-length', '12')])
return [b"Hello World!"]
console.terse("{0}\n".format("Building Valet ...\n"))
wireLogAlpha = wiring.WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
serverCertCommonName = 'localhost' # match hostname uses servers's cert commonname
#serverKeypath = '/etc/pki/tls/certs/server_key.pem' # local server private key
#serverCertpath = '/etc/pki/tls/certs/server_cert.pem' # local server public cert
#clientCafilepath = '/etc/pki/tls/certs/client.pem' # remote client public cert
serverKeypath = self.certdirpath + '/server_key.pem' # local server private key
serverCertpath = self.certdirpath + '/server_cert.pem' # local server public cert
clientCafilepath = self.certdirpath + '/client.pem' # remote client public cert
alpha = serving.Valet(
port=6101,
bufsize=131072,
wlog=wireLogAlpha,
store=store,
app=wsgiApp,
scheme='https',
keypath=serverKeypath,
certpath=serverCertpath,
cafilepath=clientCafilepath,
)
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 = wiring.WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
#clientKeypath = '/etc/pki/tls/certs/client_key.pem' # local client private key
#clientCertpath = '/etc/pki/tls/certs/client_cert.pem' # local client public cert
#serverCafilepath = '/etc/pki/tls/certs/server.pem' # remote server public cert
clientKeypath = self.certdirpath + '/client_key.pem' # local client private key
clientCertpath = self.certdirpath + '/client_cert.pem' # local client public cert
serverCafilepath = self.certdirpath + '/server.pem' # remote server public cert
path = "https://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = clienting.Patron(bufsize=131072,
wlog=wireLogBeta,
store=store,
path=path,
reconnectable=True,
scheme='https',
certedhost=serverCertCommonName,
keypath=clientKeypath,
certpath=clientCertpath,
cafilepath=serverCafilepath)
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)
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)
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['body'], bytearray(b'Hello World!'))
self.assertEqual(response['status'], 200)
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 testPorterServiceEcho(self):
"""
Test Porter service request response of echo non blocking
"""
console.terse("{0}\n".format(self.testPorterServiceEcho.__doc__))
store = storing.Store(stamp=0.0)
console.terse("{0}\n".format("Building Valet ...\n"))
wireLogAlpha = wiring.WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
alpha = serving.Porter(port=6101,
bufsize=131072,
wlog=wireLogAlpha,
store=store)
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 = wiring.WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = clienting.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)
while (beta.requests or beta.connector.txes or not beta.responses
or not alpha.servant.ixes or not alpha.idle()):
alpha.serviceAll()
time.sleep(0.05)
beta.serviceAll()
time.sleep(0.05)
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.stewards), 1)
requestant = alpha.stewards.values()[0].requestant
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['data'], {
'body': '',
'data': None,
'fragment': '',
'headers': {
'accept': 'application/json',
'accept-encoding': 'identity',
'content-length': '0',
'host': 'localhost:6101'
},
'method': 'GET',
'path': '/echo',
'qargs': {
'name': 'fame'
},
'version': 'HTTP/1.1'
})
responder = alpha.stewards.values()[0].responder
self.assertEqual(responder.status, response['status'])
self.assertEqual(responder.headers, response['headers'])
alpha.servant.closeAll()
beta.connector.close()
wireLogAlpha.close()
wireLogBeta.close()
def testValetServiceBottleStream(self):
"""
Test Valet WSGI service request response stream sse
"""
console.terse("{0}\n".format(
self.testValetServiceBottleStream.__doc__))
try:
import bottle
except ImportError as ex:
console.terse("Bottle not available.\n")
return
store = storing.Store(stamp=0.0)
app = bottle.default_app() # create bottle app
@app.get('/stream')
def streamGet():
"""
Create test server sent event stream that sends count events
"""
timer = StoreTimer(store, duration=2.0)
bottle.response.set_header('Content-Type',
'text/event-stream') #text
bottle.response.set_header('Cache-Control', 'no-cache')
# HTTP 1.1 servers detect text/event-stream and use Transfer-Encoding: chunked
# Set client-side auto-reconnect timeout, ms.
yield 'retry: 1000\n\n'
i = 0
yield 'id: {0}\n'.format(i)
i += 1
yield 'data: START\n\n'
n = 1
while not timer.expired:
yield 'id: {0}\n'.format(i)
i += 1
yield 'data: {0}\n\n'.format(n)
n += 1
yield "data: END\n\n"
console.terse("{0}\n".format("Building Valet ...\n"))
wireLogAlpha = wiring.WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
alpha = serving.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 = wiring.WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = clienting.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'/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 testValetServiceBasic(self):
"""
Test Valet WSGI service request response
"""
console.terse("{0}\n".format(self.testValetServiceBasic.__doc__))
store = storing.Store(stamp=0.0)
def wsgiApp(environ, start_response):
start_response('200 OK', [('Content-type', 'text/plain'),
('Content-length', '12')])
return [b"Hello World!"]
console.terse("{0}\n".format("Building Valet ...\n"))
wireLogAlpha = wiring.WireLog(buffify=True, same=True)
result = wireLogAlpha.reopen()
alpha = serving.Valet(port=6101,
bufsize=131072,
wlog=wireLogAlpha,
store=store,
app=wsgiApp)
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 = wiring.WireLog(buffify=True, same=True)
result = wireLogBeta.reopen()
path = "http://{0}:{1}/".format('localhost', alpha.servant.eha[1])
beta = clienting.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)
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)
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['body'], bytearray(b'Hello World!'))
self.assertEqual(response['status'], 200)
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()
