def startListening(self):
"""
Create and bind my socket, and begin listening on it.
This is called on unserialization, and must be called after creating a
server to begin listening on the specified port.
"""
tcp._reservedFD.reserve()
log.msg(
"%s starting on %r"
% (
self._getLogPrefix(self.factory),
_coerceToFilesystemEncoding("", self.port),
)
)
if self.wantPID:
self.lockFile = lockfile.FilesystemLock(self.port + b".lock")
if not self.lockFile.lock():
raise error.CannotListenError(None, self.port, "Cannot acquire lock")
else:
if not self.lockFile.clean:
try:
# This is a best-attempt at cleaning up
# left-over unix sockets on the filesystem.
# If it fails, there's not much else we can
# do. The bind() below will fail with an
# exception that actually propagates.
if stat.S_ISSOCK(os.stat(self.port).st_mode):
os.remove(self.port)
except BaseException:
pass
self.factory.doStart()
try:
if self._preexistingSocket is not None:
skt = self._preexistingSocket
self._preexistingSocket = None
else:
skt = self.createInternetSocket()
skt.bind(self.port)
except OSError as le:
raise error.CannotListenError(None, self.port, le)
else:
if _inFilesystemNamespace(self.port):
# Make the socket readable and writable to the world.
os.chmod(self.port, self.mode)
skt.listen(self.backlog)
self.connected = True
self.socket = skt
self.fileno = self.socket.fileno
self.numberAccepts = 100
self.startReading()
def startListening(self):
try:
skt = self.reactor.createSocket(self.addressFamily,
self.socketType)
# TODO: resolve self.interface if necessary
if self.addressFamily == socket.AF_INET6:
addr = _resolveIPv6(self.interface, self.port)
else:
addr = (self.interface, self.port)
skt.bind(addr)
except socket.error as le:
raise error.CannotListenError(self.interface, self.port, le)
self.addrLen = _iocp.maxAddrLen(skt.fileno())
# Make sure that if we listened on port 0, we update that to
# reflect what the OS actually assigned us.
self._realPortNumber = skt.getsockname()[1]
log.msg("%s starting on %s" %
(self._getLogPrefix(self.factory), self._realPortNumber))
self.factory.doStart()
skt.listen(self.backlog)
self.connected = True
self.disconnected = False
self.reactor.addActiveHandle(self)
self.socket = skt
self.getFileHandle = self.socket.fileno
self.doAccept()
def _bindSocket(self):
"""
Prepare and assign a L{socket.socket} instance to
C{self.socket}.
Either creates a new SOCK_DGRAM L{socket.socket} bound to
C{self.interface} and C{self.port} or takes an existing
L{socket.socket} provided via the
L{interfaces.IReactorSocket.adoptDatagramPort} interface.
"""
if self._preexistingSocket is None:
# Create a new socket and make it listen
try:
skt = self.createInternetSocket()
skt.bind((self.interface, self.port))
except socket.error as le:
raise error.CannotListenError(self.interface, self.port, le)
else:
# Re-use the externally specified socket
skt = self._preexistingSocket
self._preexistingSocket = None
# Make sure that if we listened on port 0, we update that to
# reflect what the OS actually assigned us.
self._realPortNumber = skt.getsockname()[1]
log.msg("%s starting on %s" %
(self._getLogPrefix(self.protocol), self._realPortNumber))
self.connected = 1
self.socket = skt
self.fileno = self.socket.fileno
def __call__(self, proto, trans):
self.count += 1
if self.count < 2:
return defer.fail(error.CannotListenError(None, None, None))
proto._set_valid_events('STATUS_CLIENT')
proto.makeConnection(trans)
proto.post_bootstrap.callback(proto)
return proto.post_bootstrap
def listenTCP(self, port, factory, **kwargs):
'''returns IListeningPort'''
if self.failures > 0:
self.failures -= 1
raise error.CannotListenError(None, None, None)
if port == 0:
port = self._port_generator.next()
p = FakeListeningPort(port)
p.factory = factory
p.startListening()
return p
def _bindSocket(self):
log.msg(f"{self.protocol.__class__} starting on {repr(self.port)}")
try:
skt = self.createInternetSocket() # XXX: haha misnamed method
if self.port:
skt.bind(self.port)
except OSError as le:
raise error.CannotListenError(None, self.port, le)
if self.port and _inFilesystemNamespace(self.port):
# Make the socket readable and writable to the world.
os.chmod(self.port, self.mode)
self.connected = 1
self.socket = skt
self.fileno = self.socket.fileno
def _bindSocket(self):
"""
Open the tunnel.
"""
log.msg(format="%(protocol)s starting on %(interface)s",
protocol=self.protocol.__class__,
interface=self.interface)
try:
fileno, interface = self._openTunnel(
self.interface, self._mode | TunnelFlags.IFF_NO_PI)
except (IOError, OSError) as e:
raise error.CannotListenError(None, self.interface, e)
self.interface = interface
self._fileno = fileno
self.connected = 1
def _bindSocket(self):
try:
skt = self.createSocket()
skt.bind((self.interface, self.port))
except OSError as le:
raise error.CannotListenError(self.interface, self.port, le)
# Make sure that if we listened on port 0, we update that to
# reflect what the OS actually assigned us.
self._realPortNumber = skt.getsockname()[1]
log.msg("%s starting on %s" %
(self._getLogPrefix(self.protocol), self._realPortNumber))
self.connected = True
self.socket = skt
self.getFileHandle = self.socket.fileno
def port( portNumber=-1, protocolClass=SNMPProtocol ): """Create a new listening TwistedSNMP port (with attached protocol) portNumber -- a numeric port specifier, or a sequence of numeric port specifiers to search if not specified, defaults to range(25000,30000) protocolClass -- the protocol class to create, will be called with default arguments () to create the protocol instance XXX should that be an instance? this is a convenience method, but seems silly to restrict it to protocols that have the same initialiser. Oh well. This is a convenience function which allows you to specify a range of UDP ports which will be searched in order to create a new TwistedSNMP protocol. Since the client-side protocol's port number is of minimal interest it is often handy to have this functionality available. returns Twisted UDP port object, with the SNMPProtocol instance available as port.protocol on that object """ if portNumber == -1: ports = xrange(25000,30000) elif isinstance( portNumber, (int,long)): ports = [portNumber] else: ports = portNumber for port in ports: try: return reactor.listenUDP( port, protocolClass(), ) except twisted_error.CannotListenError: pass raise twisted_error.CannotListenError( 'localhost', port, """Could not listen on *any* port in our range of potential ports! %s"""%( repr(ports)[:30], ), )
def _bindSocket(self):
"""
_bindSocket taken from Twisted 13.1.0 to suppress logging.
"""
try:
skt = self.createInternetSocket()
skt.bind((self.interface, self.port))
except socket.error as le:
raise error.CannotListenError(self.interface, self.port, le)
# Make sure that if we listened on port 0, we update that to
# reflect what the OS actually assigned us.
self._realPortNumber = skt.getsockname()[1]
# Here we remove the logging.
# log.msg("%s starting on %s" % (
# self._getLogPrefix(self.protocol), self._realPortNumber))
self.connected = 1
self.socket = skt
self.fileno = self.socket.fileno
def test_endpointListenFailure(self):
"""
When an endpoint tries to listen on an already listening port, a
C{CannotListenError} failure is errbacked.
"""
factory = object()
exception = error.CannotListenError('', 80, factory)
mreactor = RaisingMemoryReactor(listenException=exception)
ep, ignoredArgs, ignoredDest = self.createServerEndpoint(
mreactor, factory)
d = ep.listen(object())
receivedExceptions = []
def checkFailure(f):
receivedExceptions.append(f.value)
d.addErrback(checkFailure)
self.assertEquals(receivedExceptions, [exception])
def connect_tcp(host, port, factory, timeout=0, bindAddress=None):
if len(fails):
fails.pop()
raise error.CannotListenError('on-purpose-error', None, None)
addr = Mock()
factory.doStart()
proto = factory.buildProtocol(addr)
tpp = proto._wrappedProtocol
def fake_event_listener(what, cb):
if what == 'STATUS_CLIENT':
# should ignore non-BOOTSTRAP messages
cb('STATUS_CLIENT not-bootstrap')
cb('STATUS_CLIENT BOOTSTRAP PROGRESS=100 TAG=foo SUMMARY=bar'
)
return defer.succeed(None)
tpp.add_event_listener = fake_event_listener
def fake_queue(cmd):
if cmd.split()[0] == 'PROTOCOLINFO':
return defer.succeed('AUTH METHODS=NULL')
elif cmd == 'GETINFO config/names':
return defer.succeed('config/names=')
elif cmd == 'GETINFO signal/names':
return defer.succeed('signal/names=')
elif cmd == 'GETINFO version':
return defer.succeed('version=0.1.2.3')
elif cmd == 'GETINFO events/names':
return defer.succeed('events/names=STATUS_CLIENT')
elif cmd == 'GETINFO config/defaults':
return defer.succeed('config/defaults=')
return defer.succeed(None)
tpp.queue_command = fake_queue
proto.makeConnection(Mock())
return proto
def listenTCP(self, port, factory, **kwargs):
if self.failures > 0:
self.failures -= 1
raise error.CannotListenError(None, None, None)
return FakeListeningPort()
def _bindSocket(self):
try:
skt = self.createSocket()
skt.bind((self.interface, self.port))
except socket.error, le:
raise error.CannotListenError(self.interface, self.port, le)
def listenUDP(self, port, *args):
ports.append(port)
if len(ports) == 1:
raise error.CannotListenError(None, port, None)
