Python Factory.buildProtocol方法代码示例

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     if self.accept_list != None and addr.host not in self.accept_list:
         return None
     p = Factory.buildProtocol(self, addr)
     p.command_cb = self.command_cb
     p.raddr = addr
     return p

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     """
     Builds the protocol
     """
     p = Factory.buildProtocol(self, addr)
     p.hub = self.hub
     return p

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
    def test_connectionCancelledBeforeSecure(self):
        """
        If the connection is cancelled before the SSH transport layer has
        finished key exchange (ie, gotten to the point where we may attempt to
        authenticate), the L{Deferred} returned by
        L{SSHCommandClientEndpoint.connect} fires with a L{Failure} wrapping
        L{CancelledError} and the connection is aborted.
        """
        endpoint = SSHCommandClientEndpoint.newConnection(
            self.reactor, b"/bin/ls -l", b"dummy user",
            self.hostname, self.port, knownHosts=self.knownHosts,
            ui=FixedResponseUI(False))

        factory = Factory()
        factory.protocol = Protocol
        d = endpoint.connect(factory)

        transport = AbortableFakeTransport(None, isServer=False)
        factory = self.reactor.tcpClients[0][2]
        client = factory.buildProtocol(None)
        client.makeConnection(transport)
        d.cancel()

        self.failureResultOf(d).trap(CancelledError)
        self.assertTrue(transport.aborted)
        # Make sure the connection closing doesn't result in unexpected
        # behavior when due to cancellation:
        client.connectionLost(Failure(ConnectionDone()))

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     p = Factory.buildProtocol(self, addr)
     
     p.player = {}
     p.player_uuid = self.player_uuid
     p.username = self.username
     
     return p

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     if self.dead:
         return None
     ip = addr.host
     connections = self.peerConnections.get(ip, 0)
     maxConnections = self.servconfig["client_peer_exempt"][ip] if ip in self.servconfig["client_peer_exempt"] else self.servconfig["client_peer_connections"]
     if maxConnections and connections >= maxConnections:
         log.msg("A client at IP address {} has exceeded the session limit".format(ip))
         return None
     self.peerConnections[ip] = connections + 1
     return Factory.buildProtocol(self, addr)

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
    def start(self):
        """
        Start the socks5 server by listening on the specified TCP ports.
        """
        def build_protocol(_):
            socks5connection = Socks5Connection(self)
            self.sessions.append(socks5connection)
            return socks5connection

        factory = Factory()
        factory.buildProtocol = build_protocol
        self.twisted_port = reactor.listenTCP(self.port, factory)

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def test_defaultBuildProtocol(self):
     """
     L{Factory.buildProtocol} by default constructs a protocol by calling
     its C{protocol} attribute, and attaches the factory to the result.
     """
     class SomeProtocol(Protocol):
         pass
     f = Factory()
     f.protocol = SomeProtocol
     protocol = f.buildProtocol(None)
     self.assertIsInstance(protocol, SomeProtocol)
     self.assertIdentical(protocol.factory, f)

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
    def buildProtocol(self, addr):
        proto = Factory.buildProtocol(self, addr)
        for prev_proto in self.already_proto:
            assert isinstance(prev_proto.locator, CoordinatorLocatorDecorator), 'Каждый локатор должен быть ' \
                                                                                'декорирован для задания своего ' \
                                                                                'списка incoming_connections'
            assert prev_proto.locator.decorated_locator is self.coordinator_locator, 'координирующий ' \
                                                                                     'локатор должен быть один'
            prev_proto.locator.add_incoming_connection(proto)
            proto.locator.add_incoming_connection(prev_proto)

        # add for the next protos
        self.already_proto.append(proto)
        return proto

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     if self.dead:
         return None
     ip = addr.host
     # self.unique_ips.add(ip)
     # self.stats_data["total_connections"] = len(self.unique_ips)
     # if self.app_ip_log:
     #    with open(self.app_ip_log,"w") as f:
     #        f.write(json.dumps(list(self.unique_ips), separators=(',',':')))
     conn = self.peerConnections.get(ip, 0)
     max = self.client_peer_exempt[ip] if ip in self.client_peer_exempt else self.client_peer_connections
     if max and conn >= max:
         return None
     # self.stats_data["connections"] += 1
     self.peerConnections[ip] = conn + 1
     return Factory.buildProtocol(self, addr)

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
    def test_connectionClosedBeforeSecure(self):
        """
        If the connection closes at any point before the SSH transport layer
        has finished key exchange (ie, gotten to the point where we may attempt
        to authenticate), the L{Deferred} returned by
        L{SSHCommandClientEndpoint.connect} fires with a L{Failure} wrapping
        the reason for the lost connection.
        """
        endpoint = SSHCommandClientEndpoint.newConnection(
            self.reactor, b"/bin/ls -l", b"dummy user",
            self.hostname, self.port, knownHosts=self.knownHosts,
            ui=FixedResponseUI(False))

        factory = Factory()
        factory.protocol = Protocol
        d = endpoint.connect(factory)

        transport = StringTransport()
        factory = self.reactor.tcpClients[0][2]
        client = factory.buildProtocol(None)
        client.makeConnection(transport)

        client.connectionLost(Failure(ConnectionDone()))
        self.failureResultOf(d).trap(ConnectionDone)

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     if addr.host not in self.only_ip and "0.0.0.0" not in self.only_ip:
         return
     return Factory.buildProtocol(self, addr)

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     self.resetDelay()   # Reset the delay
     self.p = Factory.buildProtocol(self, addr)
     return self.p

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     prot = Factory.buildProtocol(self, addr)
     self.protocols.append(prot)
     return prot

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     p = Factory.buildProtocol(self, addr)
     p.control_session = self.control_session
     return p

# 需要导入模块: from twisted.internet.protocol import Factory [as 别名]
# 或者: from twisted.internet.protocol.Factory import buildProtocol [as 别名]
 def buildProtocol(self, addr):
     log.msg("Client connected from:", (addr,))
     protocol = Factory.buildProtocol(self, addr)
     protocol.register(self.map)
     protocol.addr = addr
     return protocol