def buildProtocol(self, address): """ Overriden method to distinguish between the two protocols. """ if address.port == 8888: self.protocol = DirectoryProtocol self.dirProto = ClientFactory.buildProtocol(self, address) return self.dirProto else: self.protocol = PeerProtocol return ClientFactory.buildProtocol(self, address)
def buildProtocol(self, address): """ Overriden method to distinguish between the two protocols. """ if address.port == 8888: self.protocol = DirectoryProtocol self.dirProto = ClientFactory.buildProtocol(self, address) return self.dirProto else: self.protocol = PeerProtocol return ClientFactory.buildProtocol(self, address)
def testStor(self): # Connect client = ftp.FTPClient(passive=self.passive) client.debug = 1 factory = ClientFactory() factory.noisy = 0 factory.buildProtocol = lambda s, c=client: c reactor.connectTCP('localhost', self.ftp_port, factory) expectedContent = "Hello\n"*4 def gotResult(c): c.write(expectedContent) c.finish() def gotErr(f): self.errback(f) t = client.storeFile("HelloThere") t[0].addCallbacks(gotResult, gotErr) t[1].addCallbacks(self.callback, self.errback) # Wait for a result id = reactor.callLater(5, self.errback, "timed out") # timeout so we don't freeze while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] self.assertEquals(open('HelloThere').read(), expectedContent)
def testRetr(self): # Connect client = ftp.FTPClient(passive=self.passive) factory = ClientFactory() factory.noisy = 0 factory.buildProtocol = lambda s, c=client: c reactor.connectTCP('localhost', self.ftp_port, factory) # download ftp_crap proto = BufferingProtocol() d = client.retr(os.path.basename('ftp_crap'), proto) d.addCallbacks(self.callback, self.errback) # Wait for a result id = reactor.callLater(5, self.errback, "timed out") # timeout so we don't freeze while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] # Check that the file is the same as read directly off the disk self.failUnless(type(self.result) == types.ListType, 'callback result is wrong type: ' + str(self.result)) data = proto.buf.getvalue() self.failUnless(data == open('ftp_crap', "rb").read(), 'RETRieved file does not match original')
def testShortFileListings(self): # Connect client = ftp.FTPClient(passive=self.passive) factory = ClientFactory() factory.noisy = 0 factory.buildProtocol = lambda s, c=client: c reactor.connectTCP('localhost', self.ftp_port, factory) # Issue the command and set the callbacks p = BufferingProtocol() d = client.nlst('.', p) d.addCallbacks(self.callback, self.errback) # Wait for the result id = reactor.callLater(5, self.errback, "timed out") # timeout so we don't freeze while not hasattr(self, 'result') and not hasattr(self, 'error'): reactor.iterate() try: id.cancel() except ValueError: pass error = getattr(self, 'error', None) if error: raise error[0], error[1], error[2] # Check that the listing contains this file (ftp_crap) filenames = p.buf.getvalue().split('\r\n') self.failUnless('ftp_crap' in filenames, 'ftp_crap not in file listing')
def buildProtocol(self, addr): """ Instantiate sub protocol. """ p = ClientFactory.buildProtocol(self, addr) p.initialAction = self.deferreds.pop(0) return p
class SpdyProtocolTest(TestCase): def setUp(self): self.factory = ClientFactory() self.factory.protocol = spdy.SpdyProtocol self.proto = self.factory.buildProtocol(('127.0.0.1', 0)) self.tr = proto_helpers.StringTransport() self.proto.makeConnection(self.tr) def tearDown(self): return self.tr.loseConnection() def send(self, data): self.proto.dataReceived(data) def testExampleFrames(self): called = [] def request(streamId, headers): called.append(None) self.assertEqual(1, streamId) self.assertEqual('GET', headers.getRawHeaders('method')[0]) self.proto.requestFactory = request self.send(example_frames) self.assertEqual(1, len(called))
def buildProtocol(self, addr): """Provision protocol with the dedicated logger """ proto = ClientFactory.buildProtocol(self, addr) proto.log = self.log return proto
def buildProtocol(self, addr): """Provision protocol with the dedicated logger """ proto = ClientFactory.buildProtocol(self, addr) proto.log = self.log return proto
def test_send_peh_upon_connection(self): '''To test client protocol we isloate it from the ClientFactory''' with patch.object(datetime, 'datetime', Mock(wraps=datetime.datetime)) as patched: fixed_date = datetime.datetime(2014, 1, 1, 12, 0, 0) patched.now.return_value = fixed_date factory = ClientFactory() factory.comaster = self.comaster factory.protocol = MaraClientProtocol proto = factory.buildProtocol(('127.0.0.1', 0)) proto.construct = MaraFrame # Disable unnesesary behaviour def stop(): proto.stop() reactor.stop() proto.sendPoll = MagicMock(side_effect=stop) transport = proto_helpers.StringTransport() proto.makeConnection(transport) bytes_sent_to_device = transport.value() result = MaraFrame.parse(bytes_sent_to_device) self.assertEqual(result.dest, 0xFF) self.assertEqual(result.source, 2) # We don't need to check BCC since it's already coded into MaraFrame self.assertEqual(result.peh, fixed_date) reactor.run() # Shuld have stopped self.assertEqual(self.comaster.update_peh_timestamp.call_count, 1) self.assertEqual(self.comaster.update_peh_timestamp.call_args[0][0], fixed_date)
def buildProtocol(self, address): logger.vdebug( "Building protocol in StarboundClientFactory to address %s", address) protocol = ClientFactory.buildProtocol(self, address) protocol.server_protocol = self.server_protocol return protocol
def buildProtocol(self, addr): p = ClientFactory.buildProtocol(self, addr) if not hasattr(self,'deferred'): self.deferred = defer.Deferred() self.reactor.callLater(0, self.deferred.callback, p) del self.deferred return p
def buildProtocol(self, addr): log.msg("Building protocol for %r" % addr) proto = ClientFactory.buildProtocol(self, addr) proto.app = self.app self.proto = proto self.join.ready() return proto
def test_connectTCP(self): """ Called on the object returned by L{loggedReactor}, C{connectTCP} calls the wrapped reactor's C{connectTCP} method with the original factory wrapped in a L{_TrafficLoggingFactory}. """ class RecordDataProtocol(Protocol): def dataReceived(self, data): self.data = data proto = RecordDataProtocol() factory = ClientFactory() factory.protocol = lambda: proto reactor = MemoryReactor() logged = loggedReactor(reactor) logged.connectTCP('192.168.1.2', 1234, factory, 21, '127.0.0.2') [(host, port, factory, timeout, bindAddress)] = reactor.tcpClients self.assertEqual('192.168.1.2', host) self.assertEqual(1234, port) self.assertIsInstance(factory, _TrafficLoggingFactory) self.assertEqual(21, timeout) self.assertEqual('127.0.0.2', bindAddress) # Verify that the factory and protocol specified are really being used protocol = factory.buildProtocol(None) protocol.makeConnection(None) protocol.dataReceived("foo") self.assertEqual(proto.data, "foo")
def test_connectTCP(self): """ Called on the object returned by L{loggedReactor}, C{connectTCP} calls the wrapped reactor's C{connectTCP} method with the original factory wrapped in a L{_TrafficLoggingFactory}. """ class RecordDataProtocol(Protocol): def dataReceived(self, data): self.data = data proto = RecordDataProtocol() factory = ClientFactory() factory.protocol = lambda: proto reactor = MemoryReactor() logged = loggedReactor(reactor) logged.connectTCP('192.168.1.2', 1234, factory, 21, '127.0.0.2') [(host, port, factory, timeout, bindAddress)] = reactor.tcpClients self.assertEqual('192.168.1.2', host) self.assertEqual(1234, port) self.assertIsInstance(factory, _TrafficLoggingFactory) self.assertEqual(21, timeout) self.assertEqual('127.0.0.2', bindAddress) # Verify that the factory and protocol specified are really being used protocol = factory.buildProtocol(None) protocol.makeConnection(None) protocol.dataReceived("foo") self.assertEqual(proto.data, "foo")
def new_protocol_tcp(self): """ Create a new client protocol connected to the server. :returns: a IRelayTestClient implementation """ server_factory = ServerFactory() server_factory.protocol = TransitConnection server_factory.transit = self._transit_server server_factory.log_requests = self.log_requests server_protocol = server_factory.buildProtocol(('127.0.0.1', 0)) @implementer(IRelayTestClient) class TransitClientProtocolTcp(Protocol): """ Speak the transit client protocol used by the tests over TCP """ _received = b"" connected = False # override Protocol callbacks def connectionMade(self): self.connected = True return Protocol.connectionMade(self) def connectionLost(self, reason): self.connected = False return Protocol.connectionLost(self, reason) def dataReceived(self, data): self._received = self._received + data # IRelayTestClient def send(self, data): self.transport.write(data) def disconnect(self): self.transport.loseConnection() def reset_received_data(self): self._received = b"" def get_received_data(self): return self._received client_factory = ClientFactory() client_factory.protocol = TransitClientProtocolTcp client_protocol = client_factory.buildProtocol(('127.0.0.1', 31337)) pump = iosim.connect( server_protocol, iosim.makeFakeServer(server_protocol), client_protocol, iosim.makeFakeClient(client_protocol), ) pump.flush() self._pumps.append(pump) return client_protocol
def buildProtocol(self, address): logger.vdebug( 'Building protocol in StarboundClientFactory to address %s', address ) protocol = ClientFactory.buildProtocol(self, address) protocol.server_protocol = self.server_protocol return protocol
def buildProtocol(self, addr): r = ClientFactory.buildProtocol(self, addr) r.postHandshakeEndpoint = self.postHandshakeEndpoint r.postHandshakeFactory = self.postHandshakeFactory r.handshakeDone = self.handshakeDone r._timestamps = self._timestamps r._timer = self._timer return r
def buildProtocol(self, addr): p = ClientFactory.buildProtocol(self, addr) p.followRedirect = self.followRedirect p.afterFoundGet = self.afterFoundGet if self.timeout: timeoutCall = reactor.callLater(self.timeout, p.timeout) self.deferred.addBoth(self._cancelTimeout, timeoutCall) return p
def buildProtocol(self, addr): r = ClientFactory.buildProtocol(self, addr) r.postHandshakeEndpoint = self.postHandshakeEndpoint r.postHandshakeFactory = self.postHandshakeFactory r.handshakeDone = self.handshakeDone r._timestamps = self._timestamps r._timer = self._timer return r
def buildProtocol(self, addr): """Provision protocol """ proto = ClientFactory.buildProtocol(self, addr) # Setup logger proto.log = self.log return proto
def buildProtocol(self, addr): """Provision protocol """ proto = ClientFactory.buildProtocol(self, addr) # Setup logger proto.log = self.log return proto
def makeProto(self, *a, **kw): protoClass = kw.pop('_protoClass', self.protocol) fac = ClientFactory(*a, **kw) fac.protocol = protoClass proto = fac.buildProtocol(None) transport = proto_helpers.StringTransport() transport.abortConnection = lambda: None proto.makeConnection(transport) return fac, proto
def buildProtocol(self, address): '''set up connection protocol override method from ClientFactory.buildProtocol does not meet pylint spec for name, exclude''' #if address not in SOURCE_LIST: SOURCE_LIST.append(address) #if address not in CONNECTED_LIST: CONNECTED_LIST.append(address) proto = ClientFactory.buildProtocol(self, address) proto.task_num = self.task_num self.task_num += 1 return proto
def buildProtocol(self, addr): p = ClientFactory.buildProtocol(self, addr) #give SideServer his b_side self.a_side.set_b_side(p) d = self.converter.get_a_side(p) # later set ASideSession to be a_side d.addCallback(p.set_other_side) return p
def buildProtocol(self, addr): p = ClientFactory.buildProtocol(self, addr) #give SideServer his b_side self.a_side.set_b_side(p) d = self.converter.get_a_side(p) # later set ASideSession to be a_side d.addCallback(p.set_other_side) return p
def buildProtocol(self, address): self._connectedProtocol = ClientFactory.buildProtocol(self, address) if self._config != None: self._connectedProtocol.configure(**self._config) while len(self._queue) > 0: args = self._queue.pop() self._connectedProtocol.sendMessage(*args) return self._connectedProtocol
def buildProtocol(self, addr): proto = _ClientFactory.buildProtocol(self, addr) proto.scheme = self.scheme proto.host = self.host proto.port = self.port if self.timeout is not None: proto.setTimeout(self.timeout) return proto
def sbRequestAccepted((host, port, key)): LogEvent(INFO, self.ident) self.key = key self.reply = 0 factory = ClientFactory() factory.buildProtocol = lambda addr: self self.msncon.connectors.append( reactor.connectTCP(host, port, factory, bindAddress=(MSNConnection.BINDADDRESS, 0)))
def buildProtocol(self, address): # Create the fuzzer instance protocol_instance = ClientFactory.buildProtocol(self, address) # Tell the fuzzer instance which type of session it should run protocol_instance.current_session = iter(self.session.next()) protocol_instance.fuzzdata = self.fuzzdata protocol_instance.session_id = str(uuid.uuid4()) protocol_instance.fuzz_ratio = self.fuzz_ratio protocol_instance.send_delay = self.send_delay protocol_instance.validcases_path = self.validcases_path return protocol_instance
def makeProto(self, *a, **kw): protoClass = kw.pop('_protoClass', self.protocol) fac = ClientFactory(*a, **kw) fac.protocol = protoClass def raise_(ex): raise ex fac.bobConnectionFailed = lambda reason: raise_(reason) proto = fac.buildProtocol(None) transport = proto_helpers.StringTransport() transport.abortConnection = lambda: None proto.makeConnection(transport) return fac, proto
def buildProtocol(self, address): # Create the fuzzer instance protocol_instance = ClientFactory.buildProtocol(self, address) # Tell the fuzzer instance which type of session it should run protocol_instance.current_session = iter(self.session.next()) protocol_instance.fuzzdata = self.fuzzdata protocol_instance.session_id = str(uuid.uuid4()) protocol_instance.fuzz_ratio = self.fuzz_ratio protocol_instance.send_delay = self.send_delay protocol_instance.validcases_path = self.validcases_path return protocol_instance
def buildProtocol(self, addr): """ Instantiate sub protocol. """ if self.nodePortNumber == 0: raise RuntimeError("Local node number not set") p = ClientFactory.buildProtocol(self, addr) p.initialAction = ("alive2Request", self.nodePortNumber, self.nodeType, self.distrVSNRange, self.nodeName.split("@")[0]) return p
def makeProto(self, *a, **kw): protoClass = kw.pop('_protoClass', self.protocol) fac = ClientFactory(*a, **kw) fac.protocol = protoClass fac.options = {} def raise_(ex): raise ex fac.bobConnectionFailed = lambda reason: raise_(reason) proto = fac.buildProtocol(None) transport = proto_helpers.StringTransport() transport.abortConnection = lambda: None proto.makeConnection(transport) return fac, proto
def connectReply(self, host, port, key, sessionID): LogEvent(INFO, self.ident) self.ready = False self.key = key self.sessionID = sessionID self.reply = 1 factory = ClientFactory() factory.buildProtocol = lambda addr: self self.msncon.connectors.append( reactor.connectTCP(host, port, factory, bindAddress=(MSNConnection.BINDADDRESS, 0)))
def buildProtocol(self, address): # Create a object of the Protocol # The returned instance will handle input on an incoming server # connection, and an attribute "factory" pointing to the creating # factory. # Alternatively, L{None} may be returned to immediately close the # new connection. # Call the base-class's buildProtocol since our Protocol is basic proto = ClientFactory.buildProtocol(self, address) proto.task_num = self.task_num # Assign the new protocol its id self.task_num += 1 # Increment the id return proto # Return the built protocol
def makeProto(self, *a, **kw): protoClass = kw.pop('_protoClass', self.protocol) fac = ClientFactory(*a, **kw) fac.nickname = 'foo' fac.privKey = None fac.options = {} fac.protocol = protoClass fac.resultNotOK = Mock() def raise_(ex): raise ex fac.connectionFailed = lambda reason: raise_(reason) proto = fac.buildProtocol(None) transport = proto_helpers.StringTransport() transport.abortConnection = lambda: None proto.makeConnection(transport) return fac, proto
def buildProtocol(self, address): # Create the fuzzer instance protocol_instance = ClientFactory.buildProtocol(self, address) if self.valid_connect: protocol_instance.dont_fuzz = ['connect'] else: protocol_instance.dont_fuzz = [] # Tell the fuzzer instance which type of session it should run protocol_instance.current_session = itertools.cycle(next(self.session)) protocol_instance.fuzzdata = self.fuzzdata protocol_instance.session_id = str(uuid.uuid4()) protocol_instance.fuzz_ratio = self.fuzz_ratio protocol_instance.send_delay = self.send_delay protocol_instance.validcases_path = self.validcases_path return protocol_instance
def buildProtocol(self, address): """Build protocol and store it in this instance.""" proto = ClientFactory.buildProtocol(self, address) self.connectedProtocol = proto return proto def connectionLost(self, reason): """Handle connection loss.""" self.connectedProtocol = None feed.log('ANDROIDSENSORCLIENTFACTORY-connectionLost','%d - Connection to sensor %s was terminated: %s' % time.time(), self.sensor, reason.getErrorMessage()) def clientConnectionFailed(self, connector, reason): """Handle a failed connection attempt to the sensor.""" if not self.deferred is None: d, self.deferred = self.deferred, None d.errback(Failure(Exception('Connection to %s sensor failed' % self.sensor))) else: contextmonkeyreactor.stop() raise SystemError('The connection attempt to %s sensor failed more than once. Check if emulator is running' % self.sensor)
def makeProto(self, *a, **kw): protoClass = kw.pop('_protoClass', self.protocol) fac = ClientFactory(*a, **kw) fac.nickname = 'foo' fac.privKey = None fac.port = None fac.localPort = None fac.options = {} fac.sigType = None fac.protocol = protoClass fac.resultNotOK = Mock() def raise_(reason): raise reason.value fac.connectionFailed = lambda reason: raise_(reason) proto = fac.buildProtocol(None) transport = proto_helpers.StringTransport() transport.abortConnection = lambda: None proto.makeConnection(transport) return fac, proto
def buildProtocol(self, addr): conn = addr.host, addr.port result = ClientFactory.buildProtocol(self, addr) result.other_side = conn def on_connect(): """This callback will be called when actual connection happened.""" self._all_connections.append(result) if addr.port in map(itemgetter(1), self.neighbours): self.log.info('Connected to another server: %s:%s' % conn) self.add_connection(result) else: self.log.info('Connection from another server accepted: %s:%s' % conn) def on_disconnect(): self.remove_connection(result) result.on_connect = on_connect result.on_disconnect = on_disconnect return result
def buildProtocol(self, addr): conn = addr.host, addr.port result = ClientFactory.buildProtocol(self, addr) result.other_side = conn def on_connect(): """This callback will be called when actual connection happened.""" self._all_connections.append(result) if addr.port in map(itemgetter(1), self.neighbours): self.log.info('Connected to another server: %s:%s' % conn) self.add_connection(result) else: self.log.info( 'Connection from another server accepted: %s:%s' % conn) def on_disconnect(): self.remove_connection(result) result.on_connect = on_connect result.on_disconnect = on_disconnect return result
def buildProtocol(self, addr): protocol = ClientFactory.buildProtocol(self, addr) protocol.wrapper = self.get_wrapper() return protocol
def buildProtocol(self, addr): self.connection = ClientFactory.buildProtocol(self, addr) print("connection in client is:",self.connection) return self.connection
def buildProtocol(self, address): # Create the fuzzer instance protocol_instance = ClientFactory.buildProtocol(self, address) # Tell the fuzzer instance which type of session it should run protocol_instance.session_id = str(uuid.uuid4()) return protocol_instance
def buildProtocol(self, address): protocol = ClientFactory.buildProtocol(self, address) protocol.server_protocol = self.server_protocol return protocol
def buildProtocol(self, addr): self.delayed = reactor.callLater(5, self._connected_successfully) return ClientFactory.buildProtocol(self, addr)
def buildProtocol(self, addr): p = ClientFactory.buildProtocol(self, addr) #This is a sneaky way of passing the protocol instance back to the caller reactor.callLater(0, self.buildProtocolDeferred.callback, p) return p
def buildProtocol(self, addr): self.delayed = reactor.callLater(5, self._connected_successfully) return ClientFactory.buildProtocol(self, addr)
def buildProtocol(self, addr): p = ClientFactory.buildProtocol(self, addr) #This is a sneaky way of passing the protocol instance back to the caller #pylint: disable=no-member reactor.callLater(0, self.buildProtocolDeferred.callback, p) return p
def buildProtocol(self, address): protocol = ClientFactory.buildProtocol(self, address) protocol.server_protocol = self.server_protocol return protocol
def buildProtocoll(self, addr): proto = ClientFactory.buildProtocol(self, addr) return proto
def buildProtocol(self, address): proto = ClientFactory.buildProtocol(self, address); self.connectedProtocol = proto; return proto;
def buildProtocol(self, *args, **kw): prot = ClientFactory.buildProtocol(self, *args, **kw) prot.server = self.server return prot
def buildProtocol(self, addr): prot = ClientFactory.buildProtocol(self, addr) prot.config = self.config return prot
def buildProtocol(self, address): proto = ClientFactory.buildProtocol(self, address) proto.task_num = self.task_num self.task_num += 1 return proto
def buildProtocol(self, address): proto = ClientFactory.buildProtocol(self, address) proto.task_num = self.task_num self.task_num += 1 return proto
def buildProtocol(self, addr): protocol = ClientFactory.buildProtocol(self, addr) protocol.wrapper = self.get_wrapper() return protocol