def test_roundtrip_format_unicode(self):
for _ in xrange(500):
v = get_random_object(unicode=True)
self.assertEqual(
v, tnetstring.loads(tnetstring.dumps(v, "utf8"), "utf8"))
self.assertEqual((v, ""),
tnetstring.pop(tnetstring.dumps(v, "utf16"),
"utf16"))
def thrash_tnetstring():
for obj, tns, json, msh in TESTS:
if TEST_DUMP_ONLY:
tnetstring.dumps(obj)
elif TEST_LOAD_ONLY:
assert tnetstring.loads(tns) == obj
else:
assert tnetstring.loads(tnetstring.dumps(obj)) == obj
def _send_to_zmq(self, content, channel):
self._lock.acquire()
if self._push_sock:
content[_ensure_utf8('channel')] = channel
self._push_sock.send(tnetstring.dumps(content))
else:
self._pub_controller.publish(channel,
tnetstring.dumps(content))
self._lock.release()
def test_unicode_handling(self):
self.assertRaises(ValueError,tnetstring.dumps,u"hello")
self.assertEquals(tnetstring.dumps(u"hello","utf8"),"5:hello,")
self.assertEquals(type(tnetstring.loads("5:hello,")),str)
self.assertEquals(type(tnetstring.loads("5:hello,","utf8")),unicode)
ALPHA = u"\N{GREEK CAPITAL LETTER ALPHA}lpha"
self.assertEquals(tnetstring.dumps(ALPHA,"utf8"),"6:"+ALPHA.encode("utf8")+",")
self.assertEquals(tnetstring.dumps(ALPHA,"utf16"),"12:"+ALPHA.encode("utf16")+",")
self.assertEquals(tnetstring.loads("12:\xff\xfe\x91\x03l\x00p\x00h\x00a\x00,","utf16"),ALPHA)
def test_unicode_handling(self):
self.assertRaises(ValueError, tnetstring.dumps, u"hello")
self.assertEquals(tnetstring.dumps(u"hello", "utf8"), "5:hello,")
self.assertEquals(type(tnetstring.loads("5:hello,")), str)
self.assertEquals(type(tnetstring.loads("5:hello,", "utf8")), unicode)
ALPHA = u"\N{GREEK CAPITAL LETTER ALPHA}lpha"
self.assertEquals(tnetstring.dumps(ALPHA, "utf8"),
"6:" + ALPHA.encode("utf8") + ",")
self.assertEquals(tnetstring.dumps(ALPHA, "utf16"),
"12:" + ALPHA.encode("utf16") + ",")
self.assertEquals(
tnetstring.loads("12:\xff\xfe\x91\x03l\x00p\x00h\x00a\x00,",
"utf16"), ALPHA)
def __init__ (self, sip_comm, sip_data, rtp_flow):
for uuid, cnt in sip_comm.iteritems ():
path = "%s/%s/"%(main_path, uuid)
print 'Dumping SIP uuid:\'%s\' (%d packets) in %s'%(uuid, cnt, path)
dialog, arr = sip_data [uuid]
i = 0
filearr = []
try:
os.makedirs (path)
except OSError, e:
# directory might already exist
pass
listpath = "%s/list.txt"%path
listfd = open (listpath, "w+")
listfd.write (
"# This file contains the listing of %d's dumped packets\n"%cnt)
listfd_legs = []
for timestamp, addr, pkt, legs_n in arr:
if not listfd_legs:
timestamppath = "%s/timestamp.txt"%path
timestampfd = open (timestamppath, "w+")
timestampfd.write (str (timestamp))
timestampfd.close ()
if legs_n in listfd_legs:
continue
listfd_legs += [legs_n]
src, dst = (addr [0], addr [1]), (addr [2], addr [3])
listfd.write ("# legs_%d from %s to %s\n"%(legs_n,
str (src),
str (dst)))
for timestamp, addr, pkt, legs_n in arr:
src, dst = (addr [0], addr [1]), (addr [2], addr [3])
dirpath = "%s/legs_%d"%(path, legs_n)
filename = "%d.txt"%i
filepath = "%s/%s"%(dirpath, filename)
filearr += [tnetstring.dumps ([filepath, timestamp,
list (addr)])]
listfd.write ("legs_%d/%d.txt\n"%(legs_n, i))
try:
os.makedirs (dirpath)
except OSError, e:
# directory might already exist
pass
fd = open (filepath, "w+")
fd.write (tnetstring.dumps ([timestamp, list (addr), str (pkt)],
'iso-8859-15'))
fd.close ()
i += 1
def server_rtp_create (_redis, ckey, s_id, port, bind_ip, rr):
_redis.lpush (redis_server_inst%rr,
tnetstring.dumps (["CREATE_RTP_SOCK",
[s_id,
bind_ip, port], ckey],
'iso-8859-15'))
return
def server_sip_create (_redis, ckey, s_id, bind_ip, port, rr, transport):
_redis.lpush (redis_server_inst%rr,
tnetstring.dumps (["CREATE_SIP%s_SOCK"%transport,
[s_id,
bind_ip, port], ckey],
'iso-8859-15'))
return
def _respond(self, value): resp = dict() if self.req_id: resp['id'] = self.req_id resp['success'] = True resp['value'] = ensure_utf8(value) self.rep_sock.send(tnetstring.dumps(resp))
def _respond_error(self, condition): resp = dict() if self.req_id: resp['id'] = self.req_id resp['success'] = False resp['condition'] = ensure_utf8(condition) self.rep_sock.send(tnetstring.dumps(resp))
def _respond(self, value): resp = dict() if self.req_id: resp['id'] = self.req_id resp['success'] = True resp['value'] = ensure_utf8(value) self.rep_sock.send(tnetstring.dumps(resp))
def publish(self, channel, id, prev_id, rheaders=None, rbody=None, sbody=None, code=None, reason=None):
self.lock.acquire()
if self.pubs is None:
self.pubs = list()
for p in self.proxies:
pub = gripcontrol.GripPubControl(p['control_uri'])
if 'control_iss' in p:
pub.set_auth_jwt({'iss': p['control_iss']}, p['key'])
self.pubs.append(pub)
formats = list()
if rbody is not None:
formats.append(gripcontrol.HttpResponseFormat(code=code, reason=reason, headers=rheaders, body=rbody))
if sbody is not None:
formats.append(gripcontrol.HttpStreamFormat(sbody))
item = pubcontrol.Item(formats, id, prev_id)
zitem = item.export()
zitem['channel'] = channel
zitem['http-response'] = convert_json_transport(zitem['http-response'])
self.sock.send(tnetstring.dumps(zitem))
for pub in self.pubs:
pub.publish_async(channel, item)
self.lock.release()
def _respond_error(self, condition): resp = dict() if self.req_id: resp['id'] = self.req_id resp['success'] = False resp['condition'] = ensure_utf8(condition) self.rep_sock.send(tnetstring.dumps(resp))
def test_send_to_zmq(self):
client = ZmqPubControlClientTestClass2('uri')
client._push_sock = ZmqSocketTestClass()
client._send_to_zmq({'content'.encode('utf-8'):
'content'.encode('utf-8')}, 'chan'.encode('utf-8'))
self.assertEquals(client._push_sock.send_data, tnetstring.dumps(
{'content'.encode('utf-8'): 'content'.encode('utf-8'),
'channel'.encode('utf-8'): 'chan'.encode('utf-8')}))
client = ZmqPubControlClientTestClass2('uri')
client._pub_controller = ZmqPubControllerTestClass()
client._send_to_zmq({'content'.encode('utf-8'):
'content'.encode('utf-8')}, 'chan'.encode('utf-8'))
self.assertEquals(client._pub_controller.publish_channel,
'chan'.encode('utf-8'))
self.assertEquals(client._pub_controller.publish_content,
tnetstring.dumps({'content'.encode('utf-8'):
'content'.encode('utf-8')}))
def _send_to_zmq(self, channel, item):
self._lock.acquire()
if self._zmq_pub_controller:
channel = _ensure_utf8(channel)
content = item.export(True, True)
self._zmq_pub_controller.publish(channel,
tnetstring.dumps(content))
self._lock.release()
def send_msg(self, msg):
msg[b'from'] = instance_id
msg[b'id'] = self.rid[1]
msg[b'seq'] = self.seq
self.seq += 1
print('OUT {} {}'.format(self.rid[0], msg))
out_sock.send(self.rid[0] + b' T' + tnetstring.dumps(msg))
def test_send_to_zmq(self):
client = ZmqPubControlClientTestClass2('uri')
client._push_sock = ZmqSocketTestClass()
client._send_to_zmq({'content'.encode('utf-8'):
'content'.encode('utf-8')}, 'chan'.encode('utf-8'))
self.assertEqual(client._push_sock.send_data, tnetstring.dumps(
{'content'.encode('utf-8'): 'content'.encode('utf-8'),
'channel'.encode('utf-8'): 'chan'.encode('utf-8')}))
client = ZmqPubControlClientTestClass2('uri')
client._pub_controller = ZmqPubControllerTestClass()
client._send_to_zmq({'content'.encode('utf-8'):
'content'.encode('utf-8')}, 'chan'.encode('utf-8'))
self.assertEqual(client._pub_controller.publish_channel,
'chan'.encode('utf-8'))
self.assertEqual(client._pub_controller.publish_content,
tnetstring.dumps({'content'.encode('utf-8'):
'content'.encode('utf-8')}))
def _send_to_zmq(self, channel, item): self._lock.acquire() if self._zmq_pub_controller: channel = _ensure_utf8(channel) content = item.export(True, True) self._zmq_pub_controller.publish(channel, tnetstring.dumps(content)) self._lock.release()
def add_test(v):
# These modules have a few round-tripping problems...
try:
assert cjson.decode(cjson.encode(v)) == v
assert yajl.loads(yajl.dumps(v)) == v
except Exception:
pass
else:
TESTS.append((v,tnetstring.dumps(v),cjson.encode(v)))
def makePickle(self, record):
""" Create message in TNetStrings format.
"""
msg = {}
self.format(record) # render 'message' attribute and others
for k in self.send_fields:
msg[k] = record.__dict__[k]
tnetstr = tnetstrings.dumps(msg)
return tnetstr
def makePickle(self, record):
""" Create message in TNetStrings format.
"""
msg = {}
self.format(record) # render 'message' attribute and others
for k in self.send_fields:
msg[k] = record.__dict__[k]
tnetstr = tnetstrings.dumps(msg)
return tnetstr
def call(self, method, args=dict()):
req = dict()
req['id'] = str(uuid.uuid4())
req['method'] = ensure_utf8(method)
req['args'] = ensure_utf8(args)
req_raw = tnetstring.dumps(req)
try:
if not self.sock.poll(30000, zmq.POLLOUT):
raise CallError('send-timeout')
m_list = list()
m_list.append('')
m_list.append(req_raw)
self.sock.send_multipart(m_list)
except zmq.ZMQError as e:
raise CallError('send-failed', e.message)
start = int(time.clock() * 1000)
while True:
elapsed = max(int(time.clock() * 1000) - start, 0)
try:
if not self.sock.poll(max(30000 - elapsed, 0), zmq.POLLIN):
raise CallError('receive-timeout')
m_list = self.sock.recv_multipart()
except zmq.ZMQError as e:
raise CallError('receive-failed', e.message)
if len(m_list) != 2:
print "response has wrong number of parts, skipping"
continue
if len(m_list[0]) > 0:
print "response first part is not empty, skipping"
continue
resp_raw = m_list[1]
try:
resp = tnetstring.loads(resp_raw)
except:
print "failed to parse response as tnetstring, skipping"
continue
if 'id' not in resp:
print "response missing id field, skipping"
continue
if resp['id'] != req['id']:
print "unexpected response id, skipping"
continue
break
if 'success' not in resp:
raise CallError('invalid-response', 'missing success field')
if resp['success']:
if 'value' not in resp:
raise CallError('invalid-response', 'missing value field')
return resp['value']
else:
if 'condition' not in resp:
raise CallError('invalid-response', 'missing condition field')
raise CallError(resp['condition'])
def call(self, method, args, timeout=10000):
req = dict()
req['id'] = str(uuid.uuid4())
req['method'] = ensure_utf8(method)
req['args'] = ensure_utf8(args)
req_raw = tnetstring.dumps(req)
start = int(time.clock() * 1000)
try:
if not self.sock.poll(timeout, zmq.POLLOUT):
raise CallError('send-timeout')
m_list = list()
m_list.append('')
m_list.append(req_raw)
self.sock.send_multipart(m_list)
except zmq.ZMQError as e:
raise CallError('send-failed', e.message)
while True:
elapsed = max(int(time.clock() * 1000) - start, 0)
try:
if not self.sock.poll(max(timeout - elapsed, 0), zmq.POLLIN):
raise CallError('receive-timeout')
m_list = self.sock.recv_multipart()
except zmq.ZMQError as e:
raise CallError('receive-failed', e.message)
if len(m_list) != 2:
print "response has wrong number of parts, skipping"
continue
if len(m_list[0]) > 0:
print "response first part is not empty, skipping"
continue
resp_raw = m_list[1]
try:
resp = tnetstring.loads(resp_raw)
except:
print "failed to parse response as tnetstring, skipping"
continue
if 'id' not in resp:
print "response missing id field, skipping"
continue
if resp['id'] != req['id']:
print "unexpected response id, skipping"
continue
break
if 'success' not in resp:
raise CallError('invalid-response', 'missing success field')
if resp['success']:
if 'value' not in resp:
raise CallError('invalid-response', 'missing value field')
return resp['value']
else:
if 'condition' not in resp:
raise CallError('invalid-response', 'missing condition field')
raise CallError(resp['condition'])
def keepalive_worker(): lock.acquire() for id, s in sessions.iteritems(): resp = dict() resp['from'] = client_id resp['id'] = id resp['seq'] = s.out_seq s.out_seq += 1 resp['type'] = 'credit' resp['credits'] = 0 print 'OUT %s' % resp out_sock.send(s.to_address + ' T' + tnetstring.dumps(resp)) lock.release()
def send_body(to_addr, conns, data):
ids = []
for c in conns:
ids.append({b'id': c.rid[1], b'seq': c.seq})
c.seq += 1
msg = {}
msg[b'from'] = instance_id
msg[b'id'] = ids
msg[b'body'] = data
msg[b'more'] = True
print('OUT {} {}'.format(to_addr, msg))
out_sock.send(to_addr + b' T' + tnetstring.dumps(msg))
def pkt_send (self, _id, data, host, port, rtp = False):
if not rtp:
self._last_packet ['_id'] = _id
self._last_packet ['data'] = data
self._last_packet ['host'] = host
self._last_packet ['port'] = port
try:
self._redis.lpush ('send_%s'%str (_id),
tnetstring.dumps ([host, port, data],
'iso-8859-15'))
if self._debug:
print "===> sending to %s:%d at %s"%(host, int (port),
time.ctime (time.time ()))
print str (data)
except:
return True
return False
def publish(self,
channel,
id,
prev_id,
rheaders=None,
rbody=None,
sbody=None,
code=None,
reason=None):
self.lock.acquire()
if self.pubs is None:
self.pubs = list()
for p in self.proxies:
pub = gripcontrol.GripPubControl(p['control_uri'])
if 'control_iss' in p:
pub.set_auth_jwt({'iss': p['control_iss']}, p['key'])
self.pubs.append(pub)
formats = list()
if rbody is not None:
formats.append(
gripcontrol.HttpResponseFormat(code=code,
reason=reason,
headers=rheaders,
body=rbody))
if sbody is not None:
formats.append(gripcontrol.HttpStreamFormat(sbody))
item = pubcontrol.Item(formats, id, prev_id)
zitem = item.export()
zitem['channel'] = channel
zitem['http-response'] = convert_json_transport(zitem['http-response'])
self.sock.send(tnetstring.dumps(zitem))
for pub in self.pubs:
pub.publish_async(channel, item)
self.lock.release()
def _handle_sip (self, date, data, addr, s_id):
try:
sip_pkt = SIPpacket ()
sip_pkt.fromString (data)
self._logger.debug (
"%s: received SIP message (%d bytes)"% (addr, len (data)))
redis_data = tnetstring.dumps ([s_id, date, list (addr), data],
'iso-8859-15')
valid = True
try:
# This is the SIP parser routine
# There is no totag and it is a request : push in 'method's list
# or compute session_id : 'fromtag:callid:branch'
# when method is BYE 'fromtag' from 'To' and branch from 'CSeq'
sip_pkt.to.enable ()
tp = sip_pkt.tp
if not tp and None is not sip_pkt.rm:
return [sip_pkt.rm, redis_data]
if "BYE" == sip_pkt.rm:
sip_pkt.to.enable ()
fp = sip_pkt.tp
branch = sip_pkt.cseq.seq
else:
sip_pkt._from.enable ()
fp = sip_pkt.fp
sip_pkt.via.enable ()
branch = sip_pkt.vb
callid = sip_pkt.callid
sess_id = "%s:%s:%s"% (fp, callid, branch)
return [sess_id, redis_data]
except KeyError, h:
self._logger.warn (
"Missing header '%s', droping packet"%str (h))
except Exception, e:
self._logger.exception (e)
self._logger.error (
"Unable to parse SIP request, dumping")
self._dump (data, suffix = "error")
def _discover_uris(self):
self._thread_cond.acquire()
if self._discovery_in_progress:
self._thread_cond.wait()
self._thread_cond.release()
self._verify_discovered_uris()
return
else:
self._discovery_in_progress = True
self._thread_cond.release()
if (self.uri is None or self._discovery_completed or
(self.pub_uri and self.push_uri)):
self._end_discovery(False)
return
sock = self._context.socket(zmq.REQ)
sock.linger = 0
sock.connect(self.uri)
start = int(timeit.default_timer() * 1000)
if not sock.poll(3000, zmq.POLLOUT):
sock.close()
self._end_discovery(False)
raise ValueError('uri discovery request failed: pollout timeout')
req = {_ensure_utf8('method'): _ensure_utf8('get-zmq-uris')}
sock.send(tnetstring.dumps(req))
elapsed = max(int(timeit.default_timer() * 1000) - start, 0)
if not sock.poll(max(3000 - elapsed, 0), zmq.POLLIN):
sock.close()
self._end_discovery(False)
raise ValueError('uri discovery request failed: pollin timeout')
resp = tnetstring.loads(sock.recv())
sock.close()
if (not resp.get(_ensure_utf8('success')) or
not resp.get(_ensure_utf8('value'))):
self._end_discovery(False)
raise ValueError('uri discovery request failed: %s' % resp)
self._set_discovered_uris(resp[_ensure_utf8('value')])
self._end_discovery(True)
self._verify_discovered_uris()
def test_roundtrip_format_examples(self):
for data, expect in FORMAT_EXAMPLES.items():
self.assertEqual(expect, tnetstring.loads(data))
self.assertEqual(expect,
tnetstring.loads(tnetstring.dumps(expect)))
self.assertEqual((expect, ""), tnetstring.pop(data))
def save(self):
(self.store.open(self.path, 'w', createdirs=True)
.write(tnetstring.dumps(self.data)))
self.store.save()
def server_remove_sip (_redis, ckey, bind_ip, port):
_redis.lpush (redis_server_command,
tnetstring.dumps (['REMOVE_SIP', [bind_ip, port], ckey],
'iso-8859-15'))
return
poller.register(sock, zmq.POLLIN) start = int(time.time() * 1000) while True: elapsed = int(time.time() * 1000) - start if elapsed >= 500: # give up break socks = dict(poller.poll(500 - elapsed)) if socks.get(sock) == zmq.POLLIN: m = sock.recv() if m[0] == '\x01' and m[1:] == channel: # subscription ready break hr = dict() hr['body'] = content + '\n' hs = dict() hs['content'] = content + '\n' ws = dict() ws['content'] = content formats = dict() formats['http-response'] = hr formats['http-stream'] = hs formats['ws-message'] = ws item = dict() item['formats'] = formats sock.send_multipart([channel, tnetstring.dumps(item)]) print 'Published'
s.out_seq += 1
resp['code'] = 200
resp['reason'] = 'OK'
headers = list()
if s.content_type:
headers.append(['Content-Type', s.content_type])
headers.append(['Content-Length', str(len(s.data))])
resp['headers'] = headers
resp['body'] = s.take_data()
if s.offset < len(s.data):
resp['more'] = True
else:
del sessions[s.id]
print 'OUT %s' % resp
out_sock.send(req['from'] + ' T' + tnetstring.dumps(resp))
else:
if len(body) > 0:
# send credits
resp = dict()
resp['from'] = client_id
resp['id'] = s.id
resp['seq'] = s.out_seq
s.out_seq += 1
resp['type'] = 'credit'
if not s.sent_credits:
resp['credits'] = 200000
s.sent_credits = True
else:
resp['credits'] = len(body)
ctx = zmq.Context()
out_sock = ctx.socket(zmq.PUSH)
out_sock.connect('ipc:///tmp/zurl-in')
out_stream_sock = ctx.socket(zmq.ROUTER)
out_stream_sock.connect('ipc:///tmp/zurl-in-stream')
in_sock = ctx.socket(zmq.SUB)
in_sock.setsockopt(zmq.SUBSCRIBE, client_id)
in_sock.connect('ipc:///tmp/zurl-out')
time.sleep(0.5)
rid = str(uuid.uuid4())
inseq = 0
outseq = 0
out_sock.send('T' + tnetstring.dumps({'from': client_id, 'id': rid, 'seq': outseq, 'method': 'GET', 'uri': sys.argv[1], 'stream': True, 'credits': 230000}))
outseq += 1
while True:
buf = in_sock.recv()
at = buf.find(' ')
receiver = buf[:at]
indata = tnetstring.loads(buf[at + 2:])
if indata['id'] != rid:
continue
print 'IN: %s' % indata
assert(indata['seq'] == inseq)
inseq += 1
if ('type' in indata and (indata['type'] == 'error' or indata['type'] == 'cancel')) or ('type' not in indata and 'more' not in indata):
break
raddr = indata['from']
# this program sends a response to a certain request ID
import sys
import time
import tnetstring
import zmq
body = sys.argv[1]
addr = sys.argv[2].encode()
rid = sys.argv[3].encode()
ctx = zmq.Context()
sock = ctx.socket(zmq.PUB)
sock.connect('ipc://client-in')
# await subscription
time.sleep(0.01)
resp = {}
resp[b'from'] = b'sendresp'
resp[b'id'] = rid
resp[b'code'] = 200
resp[b'reason'] = b'OK'
resp[b'headers'] = [[b'Content-Type', b'text/plain']]
resp[b'body'] = '{}\n'.format(body).encode()
m = [addr + b' T' + tnetstring.dumps(resp)]
sock.send_multipart(m)
elif args.content and not args.patch:
formats['http-stream'] = {'content': args.content + '\n'}
if args.content and not args.patch:
formats['ws-message'] = {'content': args.content}
if not formats:
print 'error: nothing to send'
sys.exit(1)
if args.sender:
meta['sender'] = args.sender
item = {'channel': args.channel, 'formats': formats}
if args.id:
item['id'] = args.id
if args.prev_id:
item['prev-id'] = args.prev_id
if meta:
item['meta'] = meta
ctx = zmq.Context()
sock = ctx.socket(zmq.PUSH)
sock.connect(args.spec)
sock.send(tnetstring.dumps(item))
print 'Published'
if len(sys.argv) < 2:
print 'usage: %s [url]' % sys.argv[0]
sys.exit(1)
ctx = zmq.Context()
sock = ctx.socket(zmq.REQ)
sock.connect('ipc:///tmp/zurl-req')
req = dict()
req['id'] = str(uuid.uuid4())
req['method'] = 'GET'
req['uri'] = sys.argv[1]
#req['follow-redirects'] = True
#req['ignore-tls-errors'] = True
sock.send('T' + tnetstring.dumps(req))
resp = tnetstring.loads(sock.recv()[1:])
if 'type' in resp and resp['type'] == 'error':
print 'error: %s' % resp['condition']
sys.exit(1)
print 'code=%d reason=[%s]' % (resp['code'], resp['reason'])
for h in resp['headers']:
print '%s: %s' % (h[0], h[1])
if 'body' in resp:
print '\n%s' % resp['body']
else:
print '\n'
def server_rtp_create_reply (_redis, ckey, s_id):
_redis.lpush (redis_client_reply%ckey,
tnetstring.dumps (["CREATE_RTP_REPLY",
[s_id]],
'iso-8859-15'))
return
def server_sip_create_reply (_redis, ckey, s_id, transport):
_redis.lpush (redis_client_reply%ckey,
tnetstring.dumps (["CREATE_SIP%s_REPLY"%transport,
[s_id]],
'iso-8859-15'))
return
def recv(self): return tnetstring.dumps(discovery_result)
def test_roundtrip_format_random(self):
for _ in xrange(500):
v = get_random_object()
self.assertEqual(v, tnetstring.loads(tnetstring.dumps(v)))
self.assertEqual((v, ""), tnetstring.pop(tnetstring.dumps(v)))
def test_discover_uris(self):
global pollin_response
global pollout_response
global discovery_result
global failed_discovery_result1
global failed_discovery_result2
time.clock = time.time
client = ZmqPubControlClientTestClass4('uri', 'push_uri', 'pub_uri')
client._discover_uris()
self.assertFalse(client._discovery_completed)
client = ZmqPubControlClientTestClass4('uri', 'push_uri', 'pub_uri')
client.uri = None
client.pub_uri = None
client.push_uri = None
client._discover_uris()
self.assertFalse(client._discovery_completed)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._discovery_completed = True
client._discover_uris()
self.assertTrue(client._discovery_completed)
self.assertFalse(hasattr(client._context, '.last_socket_created'))
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
pollin_response = 1
pollout_response = 1
client._context = ZmqContextTestClass()
client._discover_uris()
self.assertTrue(client._discovery_completed)
self.assertEquals(client._context.socket_type, zmq.REQ)
self.assertEquals(client._context.last_socket_created.
connect_uri, 'tcp://localhost:5563')
self.assertEquals(client._context.last_socket_created.
poll_params[0][0], 3000)
self.assertEquals(client._context.last_socket_created.
poll_params[0][1], zmq.POLLOUT)
self.assertTrue(client._context.last_socket_created.
poll_params[1][0] < 2000 and
client._context.last_socket_created.poll_params[1][0] > 1950)
self.assertEquals(client._context.last_socket_created.
poll_params[1][1], zmq.POLLIN)
self.assertTrue(client._context.last_socket_created.closed)
self.assertEquals(client._context.last_socket_created.send_data,
tnetstring.dumps({'method'.encode('utf-8'):
'get-zmq-uris'.encode('utf-8')}))
self.assertEquals(client.resolve_uris[0], 'publish-pull')
self.assertEquals(client.resolve_uris[1], 'publish-sub')
self.assertEquals(client.resolve_hosts[0], 'localhost')
self.assertEquals(client.resolve_hosts[1], 'localhost')
self.assertEquals(client.push_uri, 'publish-pull')
self.assertEquals(client.pub_uri, 'publish-sub')
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
pollin_response = 1
pollout_response = 0
with self.assertRaises(ValueError):
client._discover_uris()
self.assertFalse(client._discovery_completed)
self.assertEquals(client._context.last_socket_created.
poll_params[0][0], 3000)
self.assertEquals(client._context.last_socket_created.
poll_params[0][1], zmq.POLLOUT)
self.assertTrue(client._context.last_socket_created.closed)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
pollin_response = 0
pollout_response = 1
client._discover_uris_async()
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
pollin_response = 0
pollout_response = 1
with self.assertRaises(ValueError):
client._discover_uris()
self.assertFalse(client._discovery_completed)
self.assertEquals(client._context.last_socket_created.
poll_params[0][0], 3000)
self.assertEquals(client._context.last_socket_created.
poll_params[0][1], zmq.POLLOUT)
self.assertTrue(client._context.last_socket_created.closed)
pollin_response = 1
pollout_response = 1
client = ZmqPubControlClientTestClass4('uri',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
client._discover_uris()
self.assertEquals(client._context.socket_type, zmq.REQ)
self.assertEquals(client._context.last_socket_created.
connect_uri, 'uri')
self.assertTrue(client._context.last_socket_created.closed)
self.assertEquals(client.resolve_uris[0], 'publish-pull')
self.assertEquals(client.resolve_uris[1], 'publish-sub')
self.assertEquals(client.resolve_hosts[0], None)
self.assertEquals(client.resolve_hosts[1], None)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
discovery_result = failed_discovery_result1
client.resp = False
with self.assertRaises(ValueError):
client._discover_uris()
self.assertTrue(client._context.last_socket_created.closed)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
discovery_result = failed_discovery_result2
client.resp = False
with self.assertRaises(ValueError):
client._discover_uris()
self.assertTrue(client._context.last_socket_created.closed)
time.sleep(0.5)
pos = 0
file = open(sys.argv[2], 'r').read()
rid = str(uuid.uuid4())
outseq = 0
outcredits = 0
out_sock.send(
'T' + tnetstring.dumps({
'from': client_id,
'id': rid,
'seq': outseq,
'method': 'POST',
'uri': sys.argv[1],
'headers': [['Content-Length', str(len(file))]],
'stream': True,
'credits': 200000,
'more': True
}))
outseq += 1
raddr = None
while True:
buf = in_sock.recv()
at = buf.find(' ')
receiver = buf[:at]
data = tnetstring.loads(buf[at + 2:])
print 'IN: %s %s' % (receiver, data)
import zmq
if len(sys.argv) < 2:
print 'usage: %s [url]' % sys.argv[0]
sys.exit(1)
ctx = zmq.Context()
sock = ctx.socket(zmq.REQ)
sock.connect('ipc:///tmp/zurl-req')
req = dict()
req['id'] = str(uuid.uuid4())
req['method'] = 'GET'
req['uri'] = sys.argv[1]
#req['ignore-tls-errors'] = True
sock.send('T' + tnetstring.dumps(req))
resp = tnetstring.loads(sock.recv()[1:])
if 'type' in resp and resp['type'] == 'error':
print 'error: %s' % resp['condition']
sys.exit(1)
print 'code=%d reason=[%s]' % (resp['code'], resp['reason'])
for h in resp['headers']:
print '%s: %s' % (h[0], h[1])
if 'body' in resp:
print '\n%s' % resp['body']
else:
print '\n'
headers = []
if args.header:
for h in args.header:
k, v = h.split(':')
headers.append([k, v.lstrip()])
ctx = zmq.Context()
sock = ctx.socket(zmq.PUSH)
sock.connect(args.spec)
hr = {'body': args.content + '\n'}
if args.code is not None:
hr['code'] = args.code
if headers:
hr['headers'] = headers
hs = {'content': args.content + '\n'}
ws = {'content': args.content}
item = {
'channel': args.channel,
'formats': {
'http-response': hr,
'http-stream': hs,
'ws-message': ws
}
}
sock.send(tnetstring.dumps(item))
print 'Published'
def _publish_chunk(sock, data):
m = {'channel': 'audio', 'formats': {'http-stream': {'content': data}}}
sock.send(tnetstring.dumps(m), zmq.DONTWAIT)
if not header and not payload:
break
i += 1
ethernet = eth_decoder.decode (payload)
if ethernet.get_ether_type () == Packets.IP.ethertype:
ip = ip_decoder.decode (payload[ethernet.get_header_size ():])
if ip.get_ip_p () == Packets.UDP.protocol:
udp = udp_decoder.decode (
payload[ethernet.get_header_size ()+ip.get_header_size ():])
# print "IPv4 UDP packet %s:%d->%s:%d" % (ip.get_ip_src (),
# udp.get_uh_sport (),
# ip.get_ip_dst (),
# udp.get_uh_dport ()),
udph_length = 8
udp_data = payload [ ethernet.get_header_size () +
ip.get_header_size () + udph_length:]
# print len (udp_data)
pkt_list += [udp_data]
except pcapy.PcapError:
break
except KeyboardInterrupt:
print "dumping now"
break
if not i:
print "No packet match"
sys.exit (1)
fd = open (outfile, "w+")
fd.write (tnetstring.dumps (pkt_list, 'iso-8859-15'))
fd.close ()
print "dumped %d's packets"%i
out_stream_sock = ctx.socket(zmq.ROUTER)
out_stream_sock.connect('ipc:///tmp/zurl-in-stream')
in_sock = ctx.socket(zmq.SUB)
in_sock.setsockopt(zmq.SUBSCRIBE, client_id)
in_sock.connect('ipc:///tmp/zurl-out')
time.sleep(0.5)
rid = str(uuid.uuid4())
inseq = 0
outseq = 0
out_sock.send('T' + tnetstring.dumps({
'from': client_id,
'id': rid,
'seq': outseq,
'method': 'GET',
'uri': sys.argv[1],
'stream': True,
'credits': 230000
}))
outseq += 1
while True:
buf = in_sock.recv()
at = buf.find(' ')
receiver = buf[:at]
indata = tnetstring.loads(buf[at + 2:])
if indata['id'] != rid:
continue
print 'IN: %s' % indata
assert (indata['seq'] == inseq)
def thrash_tnetstring():
for obj, tns, json in TESTS:
assert tnetstring.loads(tns) == obj
assert tnetstring.loads(tnetstring.dumps(obj)) == obj
def save(self):
self.open('index.gz', 'w').write(tnetstring.dumps(self.index))
def test_roundtrip_big_integer(self):
i1 = math.factorial(30000)
s = tnetstring.dumps(i1)
i2 = tnetstring.loads(s)
self.assertEquals(i1, i2)
def recv(self): return tnetstring.dumps(discovery_result)
def server_sip_remove (_redis, ckey, rr):
_redis.lpush (redis_server_inst%rr,
tnetstring.dumps (["REMOVE_SIP_SOCK",
[s_id, bind_ip, port], ckey],
'iso-8859-15'))
return
headers = list() headers.append(['Content-Type', 'text/plain']) headers.append(['Content-Length', str(os.stat(filename).st_size)]) resp['headers'] = headers if len(body) > 0: resp['body'] = body if not eof: resp['more'] = True s.out_seq += 1 if eof: del sessions[id] print 'OUT %s' % resp out_sock.send(req['from'] + ' ' + tnetstring.dumps(resp)) elif socks.get(in_stream_sock) == zmq.POLLIN: parts = in_stream_sock.recv_multipart() req = tnetstring.loads(parts[1]) print 'IN stream %s' % req # we are only streaming output, so subsequent input messages must be credits if 'type' not in req or req['type'] != 'credit': print 'wrong packet type' continue id = req['id'] s = sessions.get(id) if s is None: continue
def test_discover_uris(self):
global pollin_response
global pollout_response
global discovery_result
global failed_discovery_result1
global failed_discovery_result2
time.clock = time.time
client = ZmqPubControlClientTestClass4('uri', 'push_uri', 'pub_uri')
client._discover_uris()
self.assertFalse(client._discovery_completed)
client = ZmqPubControlClientTestClass4('uri', 'push_uri', 'pub_uri')
client.uri = None
client.pub_uri = None
client.push_uri = None
client._discover_uris()
self.assertFalse(client._discovery_completed)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._discovery_completed = True
client._discover_uris()
self.assertTrue(client._discovery_completed)
self.assertFalse(hasattr(client._context, '.last_socket_created'))
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
pollin_response = 1
pollout_response = 1
client._context = ZmqContextTestClass()
client._discover_uris()
self.assertTrue(client._discovery_completed)
self.assertEqual(client._context.socket_type, zmq.REQ)
self.assertEqual(client._context.last_socket_created.
connect_uri, 'tcp://localhost:5563')
self.assertEqual(client._context.last_socket_created.
poll_params[0][0], 3000)
self.assertEqual(client._context.last_socket_created.
poll_params[0][1], zmq.POLLOUT)
self.assertTrue(client._context.last_socket_created.
poll_params[1][0] < 2000 and
client._context.last_socket_created.poll_params[1][0] > 1950)
self.assertEqual(client._context.last_socket_created.
poll_params[1][1], zmq.POLLIN)
self.assertTrue(client._context.last_socket_created.closed)
self.assertEqual(client._context.last_socket_created.send_data,
tnetstring.dumps({'method'.encode('utf-8'):
'get-zmq-uris'.encode('utf-8')}))
self.assertEqual(client.resolve_uris[0], 'publish-pull')
self.assertEqual(client.resolve_uris[1], 'publish-sub')
self.assertEqual(client.resolve_hosts[0], 'localhost')
self.assertEqual(client.resolve_hosts[1], 'localhost')
self.assertEqual(client.push_uri, 'publish-pull')
self.assertEqual(client.pub_uri, 'publish-sub')
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
pollin_response = 1
pollout_response = 0
with self.assertRaises(ValueError):
client._discover_uris()
self.assertFalse(client._discovery_completed)
self.assertEqual(client._context.last_socket_created.
poll_params[0][0], 3000)
self.assertEqual(client._context.last_socket_created.
poll_params[0][1], zmq.POLLOUT)
self.assertTrue(client._context.last_socket_created.closed)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
pollin_response = 0
pollout_response = 1
client._discover_uris_async()
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
pollin_response = 0
pollout_response = 1
with self.assertRaises(ValueError):
client._discover_uris()
self.assertFalse(client._discovery_completed)
self.assertEqual(client._context.last_socket_created.
poll_params[0][0], 3000)
self.assertEqual(client._context.last_socket_created.
poll_params[0][1], zmq.POLLOUT)
self.assertTrue(client._context.last_socket_created.closed)
pollin_response = 1
pollout_response = 1
client = ZmqPubControlClientTestClass4('uri',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
client._discover_uris()
self.assertEqual(client._context.socket_type, zmq.REQ)
self.assertEqual(client._context.last_socket_created.
connect_uri, 'uri')
self.assertTrue(client._context.last_socket_created.closed)
self.assertEqual(client.resolve_uris[0], 'publish-pull')
self.assertEqual(client.resolve_uris[1], 'publish-sub')
self.assertEqual(client.resolve_hosts[0], None)
self.assertEqual(client.resolve_hosts[1], None)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
discovery_result = failed_discovery_result1
client.resp = False
with self.assertRaises(ValueError):
client._discover_uris()
self.assertTrue(client._context.last_socket_created.closed)
client = ZmqPubControlClientTestClass4('tcp://localhost:5563',
'push_uri', 'pub_uri')
client.pub_uri = None
client.push_uri = None
client._context = ZmqContextTestClass()
discovery_result = failed_discovery_result2
client.resp = False
with self.assertRaises(ValueError):
client._discover_uris()
self.assertTrue(client._context.last_socket_created.closed)
