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)