def __init__(self, wrappedFactory):
"""Constructor.
See WrappingFactory.__init__.
"""
WrappingFactory.__init__(self, wrappedFactory)
self.allConnectionsGone = None
def __init__(self, wrappedFactory, maxConnectionCount=sys.maxint):
WrappingFactory.__init__(self, wrappedFactory)
self.connectionCount = 0
self.maxConnectionCount = maxConnectionCount
self.ht = Hellanzb.ht
self.ht.factories.append(self)
def __init__(self,
wrappedFactory,
whitelist,
connection_type="connection"):
self.whitelist = whitelist
self.connection_type = connection_type
WrappingFactory.__init__(self, wrappedFactory)
def __init__(self, wrappedFactory, maxConnectionCount=sys.maxint):
WrappingFactory.__init__(self, wrappedFactory)
self.connectionCount = 0
self.maxConnectionCount = maxConnectionCount
self.ht = Hellanzb.ht
self.ht.factories.append(self)
def __init__(self, wrappedFactory):
"""Constructor.
See WrappingFactory.__init__.
"""
WrappingFactory.__init__(self, wrappedFactory)
self.allConnectionsGone = None
def __init__(self, contextFactory, isClient, wrappedFactory):
WrappingFactory.__init__(self, wrappedFactory)
self._contextFactory = contextFactory
self._isClient = isClient
# Force some parameter checking in pyOpenSSL. It's better to fail now
# than after we've set up the transport.
contextFactory.getContext()
def __init__(self, contextFactory, isClient, wrappedFactory):
WrappingFactory.__init__(self, wrappedFactory)
self._contextFactory = contextFactory
self._isClient = isClient
# Force some parameter checking in pyOpenSSL. It's better to fail now
# than after we've set up the transport.
contextFactory.getContext()
def unregisterProtocol(self, p):
WrappingFactory.unregisterProtocol(self, p)
self.connectionCount -= 1
self.ht.connectionCount -= 1
if self.ht.connectionCount == 0:
for name in ('unthrottleReadsID', 'checkReadBandwidthID',
'unthrottleWritesID', 'checkWriteBandwidthID'):
self.cancelScheduled(getattr(self.ht, name))
def unregisterProtocol(self, p):
WrappingFactory.unregisterProtocol(self, p)
self.connectionCount -= 1
self.ht.connectionCount -= 1
if self.ht.connectionCount == 0:
for name in ('unthrottleReadsID', 'checkReadBandwidthID',
'unthrottleWritesID', 'checkWriteBandwidthID'):
self.cancelScheduled(getattr(self.ht, name))
def __init__(self, contextFactory, isClient, wrappedFactory):
"""
Create a L{TLSMemoryBIOFactory}.
@param contextFactory: Configuration parameters used to create an
OpenSSL connection. In order of preference, what you should pass
here should be:
1. L{twisted.internet.ssl.CertificateOptions} (if you're
writing a server) or the result of
L{twisted.internet.ssl.optionsForClientTLS} (if you're
writing a client). If you want security you should really
use one of these.
2. If you really want to implement something yourself, supply a
provider of L{IOpenSSLClientConnectionCreator} or
L{IOpenSSLServerConnectionCreator}.
3. If you really have to, supply a
L{twisted.internet.ssl.ContextFactory}. This will likely be
deprecated at some point so please upgrade to the new
interfaces.
@type contextFactory: L{IOpenSSLClientConnectionCreator} or
L{IOpenSSLServerConnectionCreator}, or, for compatibility with
older code, anything implementing
L{twisted.internet.interfaces.IOpenSSLContextFactory}. See
U{https://twistedmatrix.com/trac/ticket/7215} for information on
the upcoming deprecation of passing a
L{twisted.internet.ssl.ContextFactory} here.
@param isClient: Is this a factory for TLS client connections; in other
words, those that will send a C{ClientHello} greeting? L{True} if
so, L{False} otherwise. This flag determines what interface is
expected of C{contextFactory}. If L{True}, C{contextFactory}
should provide L{IOpenSSLClientConnectionCreator}; otherwise it
should provide L{IOpenSSLServerConnectionCreator}.
@type isClient: L{bool}
@param wrappedFactory: A factory which will create the
application-level protocol.
@type wrappedFactory: L{twisted.internet.interfaces.IProtocolFactory}
"""
WrappingFactory.__init__(self, wrappedFactory)
if isClient:
creatorInterface = IOpenSSLClientConnectionCreator
else:
creatorInterface = IOpenSSLServerConnectionCreator
self._creatorInterface = creatorInterface
if not creatorInterface.providedBy(contextFactory):
contextFactory = _ContextFactoryToConnectionFactory(contextFactory)
self._connectionCreator = contextFactory
def __init__(self, contextFactory, isClient, wrappedFactory):
"""
Create a L{TLSMemoryBIOFactory}.
@param contextFactory: Configuration parameters used to create an
OpenSSL connection. In order of preference, what you should pass
here should be:
1. L{twisted.internet.ssl.CertificateOptions} (if you're
writing a server) or the result of
L{twisted.internet.ssl.optionsForClientTLS} (if you're
writing a client). If you want security you should really
use one of these.
2. If you really want to implement something yourself, supply a
provider of L{IOpenSSLClientConnectionCreator} or
L{IOpenSSLServerConnectionCreator}.
3. If you really have to, supply a
L{twisted.internet.ssl.ContextFactory}. This will likely be
deprecated at some point so please upgrade to the new
interfaces.
@type contextFactory: L{IOpenSSLClientConnectionCreator} or
L{IOpenSSLServerConnectionCreator}, or, for compatibility with
older code, anything implementing
L{twisted.internet.interfaces.IOpenSSLContextFactory}. See
U{https://twistedmatrix.com/trac/ticket/7215} for information on
the upcoming deprecation of passing a
L{twisted.internet.ssl.ContextFactory} here.
@param isClient: Is this a factory for TLS client connections; in other
words, those that will send a C{ClientHello} greeting? L{True} if
so, L{False} otherwise. This flag determines what interface is
expected of C{contextFactory}. If L{True}, C{contextFactory}
should provide L{IOpenSSLClientConnectionCreator}; otherwise it
should provide L{IOpenSSLServerConnectionCreator}.
@type isClient: L{bool}
@param wrappedFactory: A factory which will create the
application-level protocol.
@type wrappedFactory: L{twisted.internet.interfaces.IProtocolFactory}
"""
WrappingFactory.__init__(self, wrappedFactory)
if isClient:
creatorInterface = IOpenSSLClientConnectionCreator
else:
creatorInterface = IOpenSSLServerConnectionCreator
self._creatorInterface = creatorInterface
if not creatorInterface.providedBy(contextFactory):
contextFactory = _ContextFactoryToConnectionFactory(contextFactory)
self._connectionCreator = contextFactory
def setUp(self):
name = self.mktemp()
os.mkdir(name)
FilePath(name).child("file").setContent(b"0123456789")
r = static.File(name)
r.putChild(b"redirect", util.Redirect(b"/file"))
r.putChild(b"wait", ForeverTakingResource())
r.putChild(b"hang-after-headers", ForeverTakingResource(write=True))
r.putChild(b"nolength", NoLengthResource())
r.putChild(b"host", HostHeaderResource())
r.putChild(b"payload", PayloadResource())
r.putChild(b"broken", BrokenDownloadResource())
r.putChild(b"contentlength", ContentLengthHeaderResource())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.host = 'localhost'
if self.scheme == 'https':
self.port = reactor.listenSSL(0,
self.wrapper,
ssl_context_factory(),
interface=self.host)
else:
self.port = reactor.listenTCP(0, self.wrapper, interface=self.host)
self.portno = self.port.getHost().port
self.download_handler = self.download_handler_cls(Settings())
self.download_request = self.download_handler.download_request
def setUp(self):
self.tmpname = self.mktemp()
os.mkdir(self.tmpname)
FilePath(self.tmpname).child("file").setContent(b"0123456789")
r = static.File(self.tmpname)
r.putChild(b"redirect", util.Redirect(b"/file"))
r.putChild(b"wait", ForeverTakingResource())
r.putChild(b"hang-after-headers", ForeverTakingResource(write=True))
r.putChild(b"nolength", NoLengthResource())
r.putChild(b"host", HostHeaderResource())
r.putChild(b"payload", PayloadResource())
r.putChild(b"broken", BrokenDownloadResource())
r.putChild(b"chunked", ChunkedResource())
r.putChild(b"broken-chunked", BrokenChunkedResource())
r.putChild(b"contentlength", ContentLengthHeaderResource())
r.putChild(b"nocontenttype", EmptyContentTypeHeaderResource())
r.putChild(b"largechunkedfile", LargeChunkedFileResource())
r.putChild(b"echo", Echo())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.host = 'localhost'
if self.scheme == 'https':
self.port = reactor.listenSSL(0,
self.wrapper,
ssl_context_factory(
self.keyfile, self.certfile),
interface=self.host)
else:
self.port = reactor.listenTCP(0, self.wrapper, interface=self.host)
self.portno = self.port.getHost().port
self.download_handler = create_instance(self.download_handler_cls,
None, get_crawler())
self.download_request = self.download_handler.download_request
def setUp(self):
self.agent = None # for twisted.web.client.Agent test
self.cleanupServerConnections = 0
r = resource.Resource()
r.putChild(b"file", Data(b"0123456789", "text/html"))
r.putChild(b"redirect", Redirect(b"/file"))
self.infiniteRedirectResource = CountingRedirect(b"/infiniteRedirect")
r.putChild(b"infiniteRedirect", self.infiniteRedirectResource)
r.putChild(b"wait", ForeverTakingResource())
r.putChild(b"write-then-wait", ForeverTakingResource(write=True))
r.putChild(b"never-read", ForeverTakingNoReadingResource())
r.putChild(b"error", ErrorResource())
r.putChild(b"nolength", NoLengthResource())
r.putChild(b"host", HostHeaderResource())
r.putChild(b"payload", PayloadResource())
r.putChild(b"broken", BrokenDownloadResource())
r.putChild(b"cookiemirror", CookieMirrorResource())
r.putChild(b'delay1', DelayResource(1))
r.putChild(b'delay2', DelayResource(2))
self.afterFoundGetCounter = CountingResource()
r.putChild(b"afterFoundGetCounter", self.afterFoundGetCounter)
r.putChild(b"afterFoundGetRedirect", Redirect(b"/afterFoundGetCounter"))
miscasedHead = Data(b"miscased-head GET response content", "major/minor")
miscasedHead.render_Head = lambda request: b"miscased-head content"
r.putChild(b"miscased-head", miscasedHead)
self.extendedRedirect = ExtendedRedirect(b'/extendedRedirect')
r.putChild(b"extendedRedirect", self.extendedRedirect)
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = self._listen(self.wrapper)
self.portno = self.port.getHost().port
def setUp(self):
self.cleanupServerConnections = 0
name = self.mktemp()
os.mkdir(name)
FilePath(name).child("file").setContent("0123456789")
r = static.File(name)
r.putChild("redirect", util.Redirect("/file"))
self.infiniteRedirectResource = CountingRedirect("/infiniteRedirect")
r.putChild("infiniteRedirect", self.infiniteRedirectResource)
r.putChild("wait", ForeverTakingResource())
r.putChild("write-then-wait", ForeverTakingResource(write=True))
r.putChild("error", ErrorResource())
r.putChild("nolength", NoLengthResource())
r.putChild("host", HostHeaderResource())
r.putChild("payload", PayloadResource())
r.putChild("broken", BrokenDownloadResource())
r.putChild("cookiemirror", CookieMirrorResource())
miscasedHead = static.Data("miscased-head GET response content",
"major/minor")
miscasedHead.render_Head = lambda request: "miscased-head content"
r.putChild("miscased-head", miscasedHead)
self.extendedRedirect = ExtendedRedirect('/extendedRedirect')
r.putChild("extendedRedirect", self.extendedRedirect)
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = self._listen(self.wrapper)
self.portno = self.port.getHost().port
def buildProtocol(self, addr):
remote_ip = ip_address(addr.host)
if any(remote_ip in network for network in self.whitelist):
return WrappingFactory.buildProtocol(self, addr)
else:
log.info("Attempted submission from non-whitelisted %s" % str(addr))
return None
def setUp(self):
site = server.Site(UriResource(), timeout=None)
wrapper = WrappingFactory(site)
self.port = reactor.listenTCP(0, wrapper, interface='127.0.0.1')
self.portno = self.port.getHost().port
self.download_handler = self.download_handler_cls(Settings())
self.download_request = self.download_handler.download_request
def buildProtocol(self, addr):
peerHost = addr.host
connectionCount = self.peerConnections.get(peerHost, 0)
if connectionCount >= self._maxConnectionsPerPeer:
log.limit_reached(self._name, peerHost)
return None
self.peerConnections[peerHost] = connectionCount + 1
return WrappingFactory.buildProtocol(self, addr)
def buildProtocol(self, addr):
remote_ip = ip_address(addr.host)
if any(remote_ip in network for network in self.whitelist):
return WrappingFactory.buildProtocol(self, addr)
else:
log.info("Attempted %s from non-whitelisted %s" %
(self.connection_type, str(addr)))
return None
def setUp(self):
self.cleanupServerConnections = 0
self.site = server.Site(MiyamotoResource.setup(), timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = reactor.listenTCP(8080,
self.wrapper,
interface="127.0.0.1")
self.portno = self.port.getHost().port
def setUp(self):
site = server.Site(UriResource(), timeout=None)
wrapper = WrappingFactory(site)
self.port = reactor.listenTCP(0, wrapper, interface='127.0.0.1')
self.portno = self.port.getHost().port
self.download_handler = HttpDownloadHandler(
Settings({'CONCURRENT_REQUESTS_PER_DOMAIN': 8}))
self.download_request = self.download_handler.download_request
def setUp(self):
self.cleanupServerConnections = 0
name = self.mktemp()
os.mkdir(name)
FilePath(name).child("file").setContent("0123456789")
r = static.File(name)
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = self._listen(self.wrapper)
self.portno = self.port.getHost().port
def setUp(self):
self.tmpname = self.mktemp()
os.mkdir(self.tmpname)
FilePath(self.tmpname).child("file").setContent(b"0123456789")
r = static.File(self.tmpname)
r.putChild(b"payload", PayloadResource())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = self._listen(self.wrapper)
self.portno = self.port.getHost().port
def registerProtocol(self, p):
"""
Called by protocol to register itself.
"""
WrappingFactory.registerProtocol(self, p)
if self.requests_countdown > 0:
self.requests_countdown -= 1
if self.requests_countdown == 0:
# bai bai mai friend
#
# known bug: currently when the limit is reached all
# the active requests are trashed.
# this simple solution is used to achive
# stronger stability.
try:
reactor.stop()
except:
pass
def buildProtocol(self, addr):
try:
remote_ip = ip_address(addr.host)
if not any(remote_ip in network for network in self.whitelist):
log.info(f"Attempted {self.connection_type} from "
f"non-whitelisted {addr}")
return None
except AttributeError:
log.warn(f"Bypassing whitelist for {self.connection_type} "
f"from {addr}")
return WrappingFactory.buildProtocol(self, addr)
def buildProtocol(self, addr):
try:
remote_ip = ip_address(addr.host)
if not any(remote_ip in network for network in self.whitelist):
log.info(f"Attempted {self.connection_type} from "
f"non-whitelisted {addr}")
return None
except AttributeError:
log.warn(f"Bypassing whitelist for {self.connection_type} "
f"from {addr}")
return WrappingFactory.buildProtocol(self, addr)
def registerProtocol(self, p):
"""
Called by protocol to register itself.
"""
WrappingFactory.registerProtocol(self, p)
if self.requests_countdown > 0:
self.requests_countdown -= 1
if self.requests_countdown == 0:
# bai bai mai friend
#
# known bug: currently when the limit is reached all
# the active requests are trashed.
# this simple solution is used to achieve
# stronger stability.
try:
reactor.stop()
except Exception:
pass
def buildProtocol(self, addr):
if self.ht.connectionCount == 0:
if self.ht.readLimit is not None:
self.ht.checkReadBandwidth()
if self.ht.writeLimit is not None:
self.ht.checkWriteBandwidth()
if self.connectionCount < self.maxConnectionCount:
self.connectionCount += 1
self.ht.connectionCount += 1
return WrappingFactory.buildProtocol(self, addr)
else:
log.msg("Max connection count reached!")
return None
def buildProtocol(self, addr):
if self.ht.connectionCount == 0:
if self.ht.readLimit is not None:
self.ht.checkReadBandwidth()
if self.ht.writeLimit is not None:
self.ht.checkWriteBandwidth()
if self.connectionCount < self.maxConnectionCount:
self.connectionCount += 1
self.ht.connectionCount += 1
return WrappingFactory.buildProtocol(self, addr)
else:
log.msg("Max connection count reached!")
return None
def setUp(self):
self.tmpname = self.mktemp()
os.mkdir(self.tmpname)
FilePath(self.tmpname).child("file").setContent(b"0123456789")
r = static.File(self.tmpname)
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.host = 'localhost'
self.port = reactor.listenSSL(
0, self.wrapper, ssl_context_factory(self.keyfile, self.certfile, cipher_string='CAMELLIA256-SHA'),
interface=self.host)
self.portno = self.port.getHost().port
crawler = get_crawler(settings_dict={'DOWNLOADER_CLIENT_TLS_CIPHERS': 'CAMELLIA256-SHA'})
self.download_handler = create_instance(self.download_handler_cls, None, crawler)
self.download_request = self.download_handler.download_request
def setUp(self):
name = self.mktemp()
os.mkdir(name)
FilePath(name).child('file').setContent('0123456789')
r = static.File(name)
r.putChild('redirect', util.Redirect('/file'))
r.putChild('wait', ForeverTakingResource())
r.putChild('error', ErrorResource())
r.putChild('nolength', NoLengthResource())
r.putChild('host', HostHeaderResource())
r.putChild('payload', PayloadResource())
r.putChild('broken', BrokenDownloadResource())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = self._listen(self.wrapper)
self.portno = self.port.getHost().port
def setUp(self):
name = self.mktemp()
os.mkdir(name)
FilePath(name).child("file").setContent("0123456789")
r = static.File(name)
r.putChild("redirect", util.Redirect("/file"))
r.putChild("wait", ForeverTakingResource())
r.putChild("nolength", NoLengthResource())
r.putChild("host", HostHeaderResource())
r.putChild("payload", PayloadResource())
r.putChild("broken", BrokenDownloadResource())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = reactor.listenTCP(0, self.wrapper, interface='127.0.0.1')
self.portno = self.port.getHost().port
self.download_request = HttpDownloadHandler().download_request
def setUp(self):
name = self.mktemp()
os.mkdir(name)
FilePath(name).child("file").setContent("0123456789")
r = static.File(name)
r.putChild("redirect", util.Redirect("/file"))
r.putChild("wait", ForeverTakingResource())
r.putChild("error", ErrorResource())
r.putChild("nolength", NoLengthResource())
r.putChild("host", HostHeaderResource())
r.putChild("payload", PayloadResource())
r.putChild("broken", BrokenDownloadResource())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = self._listen(self.wrapper)
self.portno = self.port.getHost().port
def setUp(self):
self.cleanupServerConnections = 0
name = self.mktemp()
os.mkdir(name)
FilePath(name).child("file").setContent("0123456789")
r = static.File(name)
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
pub_key = file(PUBKEY)
pub_key_data = pub_key.read()
pub_key.close()
pub_key_san = file(PUBSANKEY)
pub_key_san_data = pub_key_san.read()
pub_key_san.close()
ssl._ca_certs = [
load_certificate(FILETYPE_PEM, pub_key_data),
load_certificate(FILETYPE_PEM, pub_key_san_data)
]
def setUp(self):
name = self.mktemp()
os.mkdir(name)
FilePath(name).child('file').setContent('0123456789')
r = static.File(name)
r.putChild('redirect', util.Redirect('/file'))
r.putChild('wait', ForeverTakingResource())
r.putChild('hang-after-headers', ForeverTakingResource(write=True))
r.putChild('nolength', NoLengthResource())
r.putChild('host', HostHeaderResource())
r.putChild('payload', PayloadResource())
r.putChild('broken', BrokenDownloadResource())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = reactor.listenTCP(0, self.wrapper, interface='127.0.0.1')
self.portno = self.port.getHost().port
self.download_handler = self.download_handler_cls(
Settings({'CONCURRENT_REQUESTS_PER_DOMAIN': 8}))
self.download_request = self.download_handler.download_request
def test_download_with_proxy_https_noconnect():
def _test(response):
assert response.status == 200
assert response.url == request.url
assert response.body == b"0123456789"
tmpname = tempfile.mkdtemp(dir="/tmp/")
FilePath(tmpname).child("file").setContent(b"0123456789")
r = static.File(tmpname)
site = server.Site(r, timeout=None)
wrapper = WrappingFactory(site)
port = reactor.listenTCP(0, wrapper, interface="localhost")
portno = port.getHost().port
http_proxy = "http://localhost:%d/file" % (portno, )
request = Request(http_proxy)
downloader = get_downloader()
return downloader.download_request(request,
Spider("foo")).addCallback(_test)
def setUp(self):
self.cleanupServerConnections = 0
name = self.mktemp()
os.mkdir(name)
FilePath(name).child("file").setContent("0123456789")
r = static.File(name)
r.putChild("redirect", util.Redirect("/file"))
self.infiniteRedirectResource = CountingRedirect("/infiniteRedirect")
r.putChild("infiniteRedirect", self.infiniteRedirectResource)
r.putChild("wait", ForeverTakingResource())
r.putChild("write-then-wait", ForeverTakingResource(write=True))
r.putChild("error", ErrorResource())
r.putChild("nolength", NoLengthResource())
r.putChild("host", HostHeaderResource())
r.putChild("payload", PayloadResource())
r.putChild("broken", BrokenDownloadResource())
r.putChild("cookiemirror", CookieMirrorResource())
self.site = server.Site(r, timeout=None)
self.wrapper = WrappingFactory(self.site)
self.port = self._listen(self.wrapper)
self.portno = self.port.getHost().port
def unregisterProtocol(self, protocol):
WrappingFactory.unregisterProtocol(self, protocol)
self.logs.remove(protocol.logfile)
self.finishedLogs.append(protocol.logfile)
del self.finishedLogs[:-self.LOGFILE_LIMIT]
def __init__(self, host, port, wrappedFactory):
self.host = host
self.port = port
self.deferred = defer.Deferred(self._cancel)
WrappingFactory.__init__(self, wrappedFactory)
def __init__(self, wrappedFactory, host, port, optimistic):
WrappingFactory.__init__(self, wrappedFactory)
self._host = host
self._port = port
self._optimistic = optimistic
self._onConnection = defer.Deferred()
privateKey=privateKey,
verifierDB=verifierDB)
else:
Echo.connectionMade(self)
def connectionLost(self, reason):
pass #Handle any TLS exceptions here
class Echo2(Echo):
def lineReceived(self, data):
if data == "STARTTLS":
self.transport.setServerHandshakeOp(certChain=certChain,
privateKey=privateKey,
verifierDB=verifierDB)
else:
Echo.lineReceived(self, data)
def connectionLost(self, reason):
pass #Handle any TLS exceptions here
factory = Factory()
factory.protocol = Echo1
#factory.protocol = Echo2
wrappingFactory = WrappingFactory(factory)
wrappingFactory.protocol = TLSTwistedProtocolWrapper
log.startLogging(sys.stdout)
reactor.listenTCP(1079, wrappingFactory)
reactor.run()
def buildProtocol(self, addr):
protocol = WrappingFactory.buildProtocol(self, addr)
protocol.setWriteLimit(self.writeLimit)
return protocol
def __init__(self, wrappedFactory, whitelist, connection_type="connection"):
self.whitelist = whitelist
self.connection_type = connection_type
WrappingFactory.__init__(self, wrappedFactory)
def unregisterProtocol(self, p):
"""See WrappingFactory.unregisterProtocol."""
WrappingFactory.unregisterProtocol(self, p)
if len(self.protocols) == 0:
if self.allConnectionsGone is not None:
self.allConnectionsGone.callback(None)
def __init__(self, wrappedFactory, whitelist):
self.whitelist = whitelist
WrappingFactory.__init__(self, wrappedFactory)
def __init__(self, wrappedFactory, jsonEncoder=None, jsonDecoder=None):
WrappingFactory.__init__(self, wrappedFactory)
self.jsonEncoder = jsonEncoder
self.jsonDecoder = jsonDecoder
def __init__(self, wrappedFactory, heartbeatPeriod=25.0, clock=reactor):
WrappingFactory.__init__(self, wrappedFactory)
self.heartbeatPeriod = heartbeatPeriod
self.clock = clock
def __init__(self, wrappedFactory, writeLimit):
WrappingFactory.__init__(self, wrappedFactory)
self.writeLimit = writeLimit
def __init__(self, wrappedFactory, allowedRequests):
WrappingFactory.__init__(self, wrappedFactory)
self.requests_countdown = allowedRequests
def __init__(self, wrappedFactory, host, port, optimistic):
WrappingFactory.__init__(self, wrappedFactory)
self._host = host
self._port = port
self._optimistic = optimistic
self._onConnection = defer.Deferred()
def __init__(self, wrappedFactory):
WrappingFactory.__init__(self, wrappedFactory)
self.logs = []
self.finishedLogs = []
def __init__(self, realFactory): WrappingFactory.__init__(self, realFactory) self.connectionNotification = Deferred()
def unregisterProtocol(self, protocol):
WrappingFactory.unregisterProtocol(self, protocol)
self.logs.remove(protocol.logfile)
self.finishedLogs.append(protocol.logfile)
del self.finishedLogs[:-self.LOGFILE_LIMIT]
def __init__(self, contextFactory, isClient, wrappedFactory):
WrappingFactory.__init__(self, wrappedFactory)
self._contextFactory = contextFactory
self._isClient = isClient
def stopFactory(self):
"""See WrappingFactory.stopFactory."""
WrappingFactory.stopFactory(self)
self.allConnectionsGone = Deferred()
if len(self.protocols) == 0:
self.allConnectionsGone.callback(None)
