def connectionFailed(self, res):
"""connecting -> disconnected
"""
self.__C, C = DeferredManager(), self.__C
C.callback(None)
# now C armed, D fired
Connector.connectionFailed(self, res)
def connectionLost(self, res):
"""connected -> disconnected
"""
self.__C=DeferredManager()
self.__D, D = DeferredManager(), self.__D
if self.__protocol is not None:
# the None case only happens if there was
# an exception during the connection setup
D.callback(self.__protocol)
self.__protocol=None
# now C armed, D fired
Connector.connectionLost(self, res)
def test_tcp_repr(self):
c = Connector('localhost', 666, object(), 0, object())
expect = "<twisted.internet.tcp.Connector instance at 0x%x " \
"disconnected %s>"
expect = expect % (id(c), c.getDestination())
self.assertEqual(repr(c), expect)
def clientConnectionLost(self, connector: Connector, reason: str) -> None:
"""If we get disconnected, reconnect to server."""
log.warning("WhiskerMainPortFactory: disconnected")
connector.connect()
def connectServer(serverName, serverDict, defaultAntiIdle, defaultIdleTimeout):
""" Establish connections to the specified server according to the server information dict
(constructed from the config file). Returns the number of connections that were attempted
to be made """
defaultConnectTimeout = 30
connectionCount = 0
hosts = serverDict['hosts']
connections = int(serverDict['connections'])
for host in hosts:
antiIdle = int(setWithDefault(serverDict, 'antiIdle', defaultAntiIdle))
idleTimeout = int(
setWithDefault(serverDict, 'idleTimeout', defaultIdleTimeout))
skipGroupCmd = setWithDefault(serverDict, 'skipGroupCmd', False)
fillServer = setWithDefault(serverDict, 'fillserver', 0)
useSSL = setWithDefault(serverDict, 'ssl', False)
nsf = NZBLeecherFactory(serverDict['username'], serverDict['password'],
idleTimeout, antiIdle, host, serverName,
skipGroupCmd, fillServer)
color = nsf.color
Hellanzb.nsfs.append(nsf)
split = host.split(':')
host = split[0]
if len(split) == 2:
port = int(split[1])
else:
port = 119
nsf.host, nsf.port = host, port
preWrappedNsf = nsf
nsf = HellaThrottlingFactory(nsf)
ctxf = None
if useSSL:
try:
from twisted.internet.ssl import Connector as SSLConnector
from twisted.internet.ssl import ClientContextFactory
except ImportError, ie:
error('Unable to use SSL for server: %s\npyOpenSSL is not '
'installed: %s' % (serverName, str(ie)))
shutdownAndExit(1)
ctxf = ClientContextFactory()
for connection in range(connections):
if serverDict.has_key('bindTo') and serverDict['bindTo'] != None and \
serverDict['bindTo'] != '':
if antiIdle != 0:
if useSSL:
reactor.connectSSL(host,
port,
nsf,
ctxf,
bindAddress=(serverDict['bindTo'],
0))
else:
reactor.connectTCP(host,
port,
nsf,
bindAddress=(serverDict['bindTo'],
0))
else:
if useSSL:
connector = SSLConnector(host,
port,
nsf,
ctxf,
defaultConnectTimeout,
(serverDict['bindTo'], 0),
reactor=reactor)
else:
connector = Connector(host,
port,
nsf,
defaultConnectTimeout,
(serverDict['bindTo'], 0),
reactor=reactor)
else:
if antiIdle != 0:
if useSSL:
reactor.connectSSL(host, port, nsf, ctxf)
else:
reactor.connectTCP(host, port, nsf)
else:
if useSSL:
connector = SSLConnector(host,
port,
nsf,
ctxf,
defaultConnectTimeout,
None,
reactor=reactor)
else:
connector = Connector(host,
port,
nsf,
defaultConnectTimeout,
None,
reactor=reactor)
if antiIdle == 0:
preWrappedNsf.leecherConnectors.append(connector)
connectionCount += 1
preWrappedNsf.setConnectionCount(connectionCount)
def __init__(self, *args, **kws):
Connector.__init__(self, *args, **kws)
self.__C=DeferredManager()
self.__D=DeferredManager()
self.__D.callback(None)
def clientConnectionLost(self, connector: Connector, reason: str) -> None:
"""If we get disconnected, reconnect to server."""
log.warning("WhiskerMainPortFactory: disconnected")
connector.connect()