def doByebye(self, usn):
'''Do byebye'''
self.info(f'Sending byebye notification for {usn}')
resp = [
'NOTIFY * HTTP/1.1',
f'HOST: {SSDP_ADDR}:{SSDP_PORT}',
'NTS: ssdp:byebye',
]
try:
stcpy = dict(iter(self.known[usn].items()))
stcpy['NT'] = stcpy['ST']
del stcpy['ST']
del stcpy['MANIFESTATION']
del stcpy['SILENT']
del stcpy['HOST']
del stcpy['last-seen']
resp.extend([f'{k}: {v}' for k, v in stcpy.items()])
resp.extend(('', ''))
r = '\r\n'.join(resp).encode('ascii')
self.debug(f'doByebye content {resp}')
if not self.transport:
self.warning('transport not initialized...' +
'trying to initialize a FakeDatagramTransport')
self.transport = proto_helpers.FakeDatagramTransport()
self.makeConnection(self.transport)
try:
self.transport.write(r, (SSDP_ADDR, SSDP_PORT))
except (AttributeError, socket.error) as msg:
self.info(f'failure sending out byebye notification: {msg}')
except KeyError as msg:
self.debug(f'error building byebye notification: {msg}')
def setUp(self):
"""
Create a L{dns.DNSDatagramProtocol} with a deterministic clock.
"""
self.clock = task.Clock()
self.controller = TestController()
self.proto = dns.DNSDatagramProtocol(self.controller)
transport = proto_helpers.FakeDatagramTransport()
self.proto.makeConnection(transport)
self.proto.callLater = self.clock.callLater
def setUp(self):
self.peer_addr = ('127.0.0.1', 12345)
self.protocol = FakeServerProtocol(self.peer_addr)
self.protocol.stupcore.get_timeout = lambda x: 0.1
self.protocol.stupcore.RETRY_THRESHOLD = 3
self.protocol.stupcore.send_seq_id = 0
self.protocol.stupcore.output_buffer = RingBuffer(1000, 0)
self.protocol.stupcore.WAIT_ALL_DONE_TIMEOUT = 0.1
self.transport = proto_helpers.FakeDatagramTransport()
self.protocol.makeConnection(self.transport)
def setUp(self):
self.proxy = sip.RegisterProxy(host="intarweb.us")
self.proxy.authorizers = self.proxy.authorizers.copy()
self.proxy.authorizers['digest'] = FakeDigestAuthorizer()
self.registry = FakeRegistry("intarweb.us")
self.proxy.registry = self.proxy.locator = self.registry
self.transport = proto_helpers.FakeDatagramTransport()
self.proxy.transport = self.transport
r = TestRealm()
p = cred.portal.Portal(r)
c = cred.checkers.InMemoryUsernamePasswordDatabaseDontUse()
c.addUser('*****@*****.**', 'password')
p.registerChecker(c)
self.proxy.portal = p
def init_server(self):
# an example response of how one might create the deferred
def example_response(datagram):
key = (key for key, value in TESTPACKETS.items()
if value == datagram).next()
return TESTRESPONSES[key]
from twisted.test import proto_helpers
self.echo_proto = ServerFactory('udp', lambda: Deferred())
self.proto = ServerFactory(
'udp', lambda: Deferred().addCallback(example_response))
self.tr = proto_helpers.FakeDatagramTransport()
for pr in [self.echo_proto, self.proto]:
pr.transport = self.tr
pr.startProtocol()
def loopix_mixes():
sec_params = SphinxParams(header_len=1024)
dbManager.create_mixnodes_table('Mixnodes')
mixes = []
pubs_mixes = []
for i in range(3):
mix = LoopixMixNode(sec_params, 'Mix%d' % (i + 1), 9999 - i,
'1.2.3.%d' % i, i)
mix.transport = proto_helpers.FakeDatagramTransport()
mix.config_params = mix.config_params._replace(DATABASE_NAME='test.db')
mixes.append(mix)
dbManager.insert_row_into_table('Mixnodes', [
None, mix.name, mix.port, mix.host,
sqlite3.Binary(petlib.pack.encode(mix.pubk)), mix.group
])
pubs_mixes = [Mix(m.name, m.port, m.host, m.pubk, m.group) for m in mixes]
return mixes, pubs_mixes
def loopix_providers():
sec_params = SphinxParams(header_len=1024)
dbManager.create_providers_table('Providers')
providers = []
pubs_providers = []
for i in range(3):
p = LoopixProvider(sec_params, 'Provider%d' % (i + 1), 9995 - i,
'1.2.%d.4' % i)
p.transport = proto_helpers.FakeDatagramTransport()
p.config_params = p.config_params._replace(DATABASE_NAME='test.db')
providers.append(p)
dbManager.insert_row_into_table('Providers', [
None, p.name, p.port, p.host,
sqlite3.Binary(petlib.pack.encode(p.pubk))
])
pubs_providers = [
Provider(p.name, p.port, p.host, p.pubk) for p in providers
]
return providers, pubs_providers
def loopix_clients(pubs_providers, pubs_mixes):
sec_params = SphinxParams(header_len=1024)
dbManager.create_users_table('Users')
clients = []
pubs_clients = []
for i in range(3):
provider = pubs_providers[i]
c = LoopixClient(sec_params, 'Client%d' % (i + 1), 9993 - i,
'1.%d.3.4' % i, provider.name)
c.register_mixes(pubs_mixes)
c.transport = proto_helpers.FakeDatagramTransport()
c.config_params = c.config_params._replace(DATABASE_NAME='test.db')
c.provider = dbManager.select_provider_by_name(provider.name)
clients.append(c)
dbManager.insert_row_into_table('Users', [
None, c.name, c.port, c.host,
sqlite3.Binary(petlib.pack.encode(c.pubk)), c.provider.name
])
pubs_clients = [
User(c.name, c.port, c.host, c.pubk, c.provider) for c in clients
]
return clients, pubs_clients
def doNotify(self, usn):
'''Do notification'''
if self.known[usn]['SILENT'] is True:
return
self.info(f'Sending alive notification for {usn}')
# self.info(f'\t - self.known[usn]: {self.known[usn]}')
resp = [
'NOTIFY * HTTP/1.1',
f'HOST: {SSDP_ADDR}:{SSDP_PORT}',
'NTS: ssdp:alive',
]
stcpy = dict(iter(self.known[usn].items()))
stcpy['NT'] = stcpy['ST']
del stcpy['ST']
del stcpy['MANIFESTATION']
del stcpy['SILENT']
del stcpy['HOST']
del stcpy['last-seen']
resp.extend([f'{k}: {v}' for k, v in stcpy.items()])
resp.extend(('', ''))
r = '\r\n'.join(resp).encode('ascii')
self.debug(f'doNotify content {r} [transport is: {self.transport}]')
if not self.transport:
try:
self.warning('transport not initialized...' +
'trying to initialize a FakeDatagramTransport')
self.transport = proto_helpers.FakeDatagramTransport()
except Exception as er:
self.error(f'Cannot initialize transport: {er}')
try:
self.transport.write(r, (SSDP_ADDR, SSDP_PORT))
except (AttributeError, socket.error) as msg:
self.info(f'failure sending out alive notification: {msg}')
def setUp(self):
self.protocol = PeerProtocol()
self.transport = proto_helpers.FakeDatagramTransport()
self.protocol.transport = self.transport
self.protocol.startProtocol()
self.peer_addr = ('127.0.0.1', 8100)
def setUp(self):
self.proto = ssdp.SSDPServer(test=True)
self.tr = proto_helpers.FakeDatagramTransport()
self.proto.makeConnection(self.tr)
def setUp(self):
self.tr = proto_helpers.FakeDatagramTransport()
self.ssdp_server = ssdp.SSDPServer(test=True)
self.ssdp_server.makeConnection(self.tr)
self.proto = msearch.MSearch(self.ssdp_server, test=True)
self.proto.makeConnection(self.tr)
