def test_sock_plex(self):
def onmesg(event):
sock = event[1].get('sock')
mesg = event[1].get('mesg')
sock.tx(tufo('hi:got', mesg=mesg))
plex = s_socket.Plex()
s1, s2 = s_socket.socketpair()
s2.on('link:sock:mesg', onmesg)
waiter = self.getTestWait(s2, 1, 'link:sock:mesg')
plex.addPlexSock(s2)
s1.tx(tufo('hi:there', whee='whee'))
ret = s1.recvobj()
mesg = ret[1].get('mesg')
self.eq(ret[0], 'hi:got')
s1.fini()
plex.fini()
def test_sock_plex_txbuf(self):
# windows sockets seem to allow *huge* buffers in non-blocking
# so triggering txbuf takes *way* too much ram to be a feasable test
if s_thishost.get('platform') == 'windows':
return
plex = s_socket.Plex()
s1, s2 = s_socket.socketpair()
plex.addPlexSock(s2)
s2.tx(tufo('hi', there='there'))
self.assertEqual(s1.recvobj()[0], 'hi')
s2.tx(tufo('OMG', y='A' * 409000))
self.assertIsNotNone(s2.txbuf)
s2.tx(tufo('foo', bar='baz'))
self.assertEqual(len(s2.txque), 1)
m1 = s1.recvobj()
m2 = s1.recvobj()
self.assertEqual(len(m1[1].get('y')), 409000)
self.assertEqual(m2[0], 'foo')
s1.fini()
s2.fini()
plex.fini()
def __init__(self, relay, plex=None, sock=None):
s_eventbus.EventBus.__init__(self)
self.onfini(self._onProxyFini)
# NOTE: the _tele_ prefixes are designed to prevent accidental
# derefs with overlapping names from working correctly
self._tele_sid = None
self._tele_q = s_queue.Queue()
self._tele_pushed = {}
# allow the server to give us events to fire back on
# reconnect so we can help re-init our server-side state
self._tele_reminders = []
if plex is None:
plex = s_socket.Plex()
self.onfini(plex.fini)
self._tele_plex = plex
self._tele_boss = s_async.Boss()
self._tele_plex.on('link:sock:mesg', self._onLinkSockMesg)
self._raw_on('tele:yield:init', self._onTeleYieldInit)
self._raw_on('tele:yield:item', self._onTeleYieldItem)
self._raw_on('tele:yield:fini', self._onTeleYieldFini)
self._raw_on('tele:reminder', self._onTeleReminder)
self._raw_on('fifo:xmit', self._onFifoXmit)
self._raw_on('job:done', self._tele_boss.dist)
self._raw_on('sock:gzip', self._onSockGzip)
self._raw_on('tele:call', self._onTeleCall)
self._raw_on('tele:sock:init', self._onTeleSockInit)
self._tele_cthr = self.consume(self._tele_q)
self._tele_ons = {}
self._tele_sock = None
self._tele_relay = relay # LinkRelay()
self._tele_link = relay.link
self._tele_yields = {}
self._tele_csides = {}
self._tele_reflect = None
# obj name is path minus leading "/"
self._tele_name = relay.link[1].get('path')[1:]
if sock is None:
sock = self._tele_relay.connect()
self._initTeleSock(sock=sock)
def test_socket_glob_plex(self):
plex0 = s_scope.get('plex')
self.nn(plex0)
with s_scope.enter():
plex1 = s_socket.Plex()
s_scope.set('plex', plex1)
self.ne(id(plex0), id(s_scope.get('plex')))
plex1.fini()
self.eq(id(plex0), id(s_scope.get('plex')))
def __init__(self, relay, plex=None, sock=None):
s_eventbus.EventBus.__init__(self)
self.onfini(self._onProxyFini)
# NOTE: the _tele_ prefixes are designed to prevent accidental
# derefs with overlapping names from working correctly
self._tele_sid = None
self._tele_q = s_queue.Queue()
self._tele_pushed = {}
if plex is None:
plex = s_socket.Plex()
self._tele_plex = plex
self._tele_boss = s_async.Boss()
self._tele_plex.on('link:sock:mesg', self._onLinkSockMesg)
self._raw_on('tele:yield:init', self._onTeleYieldInit)
self._raw_on('tele:yield:item', self._onTeleYieldItem)
self._raw_on('tele:yield:fini', self._onTeleYieldFini)
self._raw_on('job:done', self._tele_boss.dist)
self._raw_on('sock:gzip', self._onSockGzip)
self._raw_on('tele:call', self._onTeleCall)
poolmax = relay.getLinkProp('poolmax', -1)
poolsize = relay.getLinkProp('poolsize', 0)
self._tele_cthr = self.consume(self._tele_q)
self._tele_pool = s_threads.Pool(size=poolsize, maxsize=poolmax)
self._tele_ons = {}
self._tele_sock = None
self._tele_relay = relay # LinkRelay()
self._tele_link = relay.link
self._tele_yields = {}
self._tele_csides = {}
self._tele_reflect = None
# obj name is path minus leading "/"
self._tele_name = relay.link[1].get('path')[1:]
if sock is None:
sock = self._tele_relay.connect()
self._initTeleSock(sock=sock)
def __init__(self, relay, plex=None):
s_eventbus.EventBus.__init__(self)
self.onfini(self._onProxyFini)
# NOTE: the _tele_ prefixes are designed to prevent accidental
# derefs with overlapping names from working correctly
self._tele_sid = None
self._tele_pki = None
self._tele_q = s_queue.Queue()
self._tele_pushed = {}
if plex == None:
plex = s_socket.Plex()
self._tele_plex = plex
self._tele_boss = s_async.Boss()
self._raw_on('tele:yield:init', self._onTeleYieldInit)
self._raw_on('tele:yield:item', self._onTeleYieldItem)
self._raw_on('tele:yield:fini', self._onTeleYieldFini)
self._raw_on('job:done', self._tele_boss.dist)
self._raw_on('tele:call', self._onTeleCall)
poolmax = relay.getLinkProp('poolmax', -1)
poolsize = relay.getLinkProp('poolsize', 0)
self._tele_cthr = self.consume(self._tele_q)
self._tele_pool = s_threads.Pool(size=poolsize, maxsize=poolmax)
self._tele_ons = set()
self._tele_sock = None
self._tele_relay = relay # LinkRelay()
self._tele_yields = {}
# obj name is path minus leading "/"
self._tele_name = relay.link[1].get('path')[1:]
if relay.getLinkProp('pki'):
#TODO pkiurl
self._tele_pki = relay.getLinkProp('pkistor')
if self._tele_pki == None:
self._tele_pki = s_pki.getUserPki()
self._initTeleSock()
def __init__(self, pool=None):
EventBus.__init__(self)
DmonConf.__init__(self)
self.auth = None
self.socks = {} # sockets by iden
self.shared = {} # objects provided by daemon
self.pushed = {} # objects provided by sockets
self.csides = {} # item:[ (name,path), ... ]
self.reflect = {} # objects reflect info by name
self._dmon_ons = {}
self._dmon_links = [] # list of listen links
self._dmon_yields = set()
if pool is None:
pool = s_threads.Pool(size=8, maxsize=-1)
self.pool = pool
self.plex = s_socket.Plex()
self.cura = s_session.Curator()
self.onfini(self.plex.fini)
self.onfini(self.pool.fini)
self.onfini(self.cura.fini)
self.on('link:sock:init', self._onLinkSockInit)
self.plex.on('link:sock:mesg', self._onLinkSockMesg)
self.mesgfuncs = {}
self.setMesgFunc('tele:syn', self._onTeleSynMesg)
self.setMesgFunc('sock:gzip', self._onSockGzipMesg)
self.setMesgFunc('tele:call', self._onTeleCallMesg)
# for "client shared" objects...
self.setMesgFunc('tele:push', self._onTelePushMesg)
self.setMesgFunc('tele:retn', self._onTeleRetnMesg)
self.setMesgFunc('tele:on', self._onTeleOnMesg)
self.setMesgFunc('tele:off', self._onTeleOffMesg)
self.setMesgFunc('tele:yield:fini', self._onTeleYieldFini)
def test_sock_plex_txbuf(self):
# windows sockets seem to allow *huge* buffers in non-blocking
# so triggering txbuf takes *way* too much ram to be a feasable test
if s_thishost.get('platform') == 'windows':
return
plex = s_socket.Plex()
s1, s2 = s_socket.socketpair()
plex.addPlexSock(s2)
self.eq(len(plex.getPlexSocks()), 2)
# the rx socket is a blocking socket which cause calls to
# rx() to block on the recv() call in the main thread of
# the python program
t0 = tufo('hi', there='there')
t1 = tufo('OMG', y='A' * 409000)
t2 = tufo('foo', bar='baz')
s2.tx(t0)
m0 = s1.recvobj()
self.eq(m0[0], 'hi')
# So this is pushing a large message which is going to be
# transmitted in parts - hence the NEXT assertion statement
s2.tx(t1)
self.nn(s2.txbuf)
s2.tx(t2)
self.eq(len(s2.txque), 1)
m1 = s1.recvobj()
m2 = s1.recvobj()
self.eq(len(m1[1].get('y')), 409000)
self.eq(m2[0], 'foo')
s1.fini()
s2.fini()
plex.fini()
def __init__(self, core=None, pool=None):
EventBus.__init__(self)
DmonConf.__init__(self)
if core == None:
core = s_cortex.openurl('ram:///')
self.socks = {} # sockets by iden
self.shared = {} # objects provided by daemon
self.pushed = {} # objects provided by sockets
self._dmon_links = [] # list of listen links
self._dmon_yields = set()
if pool == None:
pool = s_threads.Pool(size=8, maxsize=-1)
self.pki = s_pki.PkiStor(core)
self.pool = pool
self.core = core
self.plex = s_socket.Plex()
self.onfini(self.plex.fini)
self.onfini(self.pool.fini)
self.on('link:sock:init', self._onLinkSockInit)
self.plex.on('link:sock:mesg', self._onLinkSockMesg)
self.mesgfuncs = {}
self.setMesgFunc('tele:syn', self._onTeleSynMesg)
self.setMesgFunc('tele:skey', self._onTeleSkeyMesg)
self.setMesgFunc('tele:call', self._onTeleCallMesg)
# for "client shared" objects...
self.setMesgFunc('tele:push', self._onTelePushMesg)
self.setMesgFunc('tele:retn', self._onTeleRetnMesg)
self.setMesgFunc('tele:on', self._onTeleOnMesg)
self.setMesgFunc('tele:off', self._onTeleOffMesg)
self.setMesgFunc('tele:yield:fini', self._onTeleYieldFini)
