def acrcloud_monitor_service():
try:
port = config['server']['port']
reactor.listenTCP(port, ServerFactory())
reactor.run()
except Exception as e:
traceback.print_exc()
def getTelnetFactory(commands, prompt, **users):
if not users:
raise SSHServerError("You must provide at least one "
"username/password combination "
"to run this Telnet server.")
cmds = {}
for command in commands:
cmds[command.name] = command
commands = cmds
for exit_cmd in ['_exit', 'exit']:
if exit_cmd not in commands:
commands[exit_cmd] = MockSSH.command_exit
telnetRealm = TelnetRealm(prompt, commands)
telnetPortal = portal.Portal(
telnetRealm,
(checkers.InMemoryUsernamePasswordDatabaseDontUse(**users), ))
telnetPortal.registerChecker(
checkers.InMemoryUsernamePasswordDatabaseDontUse(**users))
telnetFactory = ServerFactory()
telnetFactory.protocol = makeTelnetProtocol(telnetPortal, telnetRealm,
users)
return telnetFactory
def test_unknownSocketErrorRaise(self):
"""
A C{socket.error} raised by C{accept(2)} whose C{errno} is
unknown to the recovery logic is logged.
"""
knownErrors = list(_ACCEPT_ERRORS)
knownErrors.extend([EAGAIN, EPERM, EWOULDBLOCK])
# Windows has object()s stubs for some errnos.
unknownAcceptError = max(
error for error in knownErrors
if isinstance(error, (int, compat.long))
) + 1
class FakeSocketWithUnknownAcceptError(object):
"""
Pretend to be a socket in an overloaded system whose
C{accept} method can only be called
C{maximumNumberOfAccepts} times.
"""
def accept(oself):
raise socket.error(unknownAcceptError,
"unknown socket error message")
factory = ServerFactory()
port = self.port(0, factory, interface='127.0.0.1')
self.patch(port, "socket", FakeSocketWithUnknownAcceptError())
port.doRead()
failures = self.flushLoggedErrors(socket.error)
self.assertEqual(1, len(failures))
self.assertEqual(failures[0].value.args[0], unknownAcceptError)
def _acceptFailureTest(self, socketErrorNumber):
"""
Test behavior in the face of an exception from C{accept(2)}.
On any exception which indicates the platform is unable or unwilling
to allocate further resources to us, the existing port should remain
listening, a message should be logged, and the exception should not
propagate outward from doRead.
@param socketErrorNumber: The errno to simulate from accept.
"""
class FakeSocket(object):
"""
Pretend to be a socket in an overloaded system.
"""
def accept(self):
raise socket.error(
socketErrorNumber, os.strerror(socketErrorNumber))
factory = ServerFactory()
port = self.port(0, factory, interface='127.0.0.1')
self.patch(port, "socket", FakeSocket())
port.doRead()
expectedFormat = "Could not accept new connection ({acceptError})"
expectedErrorCode = errno.errorcode[socketErrorNumber]
matchingMessages = [
(msg.get('log_format') == expectedFormat
and msg.get('acceptError') == expectedErrorCode)
for msg in self.messages
]
self.assertGreater(len(matchingMessages), 0,
"Log event for failed accept not found in "
"%r" % (self.messages,))
def get_service(self):
factory = ServerFactory()
factory.protocol = SimpleTelnetSession
factory.game = self.game
service = internet.TCPServer(self.options.getint('port'), factory)
service.setName("SimpleTelnetServer")
return service
def getOpenFlowServerFactory(self):
f = ServerFactory()
f.protocol = OpenFlowServerProtocol
f.handle_switch_openflow_msg = self.handle_switch_openflow_msg
f.add_switchConnection = self.add_switchConnection
f.remove_switchConnection = self.remove_switchConnection
return f
def listen_inner_tcp(self, port):
type_str = FlagType.trans_server_type(Context.GData.server_type)
svr_info = Context.GData.server_info
Context.Log.info(type_str, 'listen on port', port, 'with', self.innerProtocol)
factory = ServerFactory()
factory.protocol = self.innerProtocol
reactor.listenTCP(port, factory, interface=svr_info['host'])
def test_deprecatedMode(self):
"""
Passing any value for the C{mode} parameter of L{listenUNIX} causes a
deprecation warning to be emitted.
"""
self._deprecatedModeTest('IReactorUNIX', 'listenUNIX', self.mktemp(),
ServerFactory())
def _benchmark(byteCount, clientProtocol):
result = {}
finished = Deferred()
def cbFinished(ignored):
result[u'disconnected'] = time()
result[u'duration'] = result[u'disconnected'] - result[u'connected']
return result
finished.addCallback(cbFinished)
f = ServerFactory()
f.protocol = lambda: ServerProtocol(byteCount, finished)
server = reactor.listenTCP(0, f)
f2 = ClientCreator(reactor, clientProtocol)
proto = f2.connectTCP('127.0.0.1', server.getHost().port)
def connected(proto):
result[u'connected'] = time()
return proto
proto.addCallback(connected)
proto.addCallback(_write, byteCount)
return finished
def start(_settings, _backend, telnet_port=8023):
"""
Start telnet server
"""
global settings
global backend
backend = _backend
# Settings
settings = _settings()
# Thread sensitive interface for stdout/stdin
std.setup()
# Telnet
telnet_factory = ServerFactory()
telnet_factory.protocol = lambda: TelnetTransport(TelnetDeployer)
# Handle signals
def handle_sigint(signal, frame):
if active_sessions:
print 'Running, %i active session(s).' % len(active_sessions)
else:
print 'No active sessions, exiting'
reactor.stop()
signal.signal(signal.SIGINT, handle_sigint)
# Run the reactor!
print 'Listening telnet on localhost:%s...' % telnet_port
reactor.listenTCP(telnet_port, telnet_factory)
reactor.run()
def run_proxy(args=None):
service = MultiService()
options = get_options(args)
open_log(os.path.join(options['gamedir'], 'proxy.log'))
pidfile = os.path.join(options['gamedir'], 'proxy.pid')
check_pid(pidfile)
config.read(options.config_paths())
port = config.getint('Proxy', 'AMP port')
factory = ReconnectingClientFactory()
factory.maxDelay = 1
factory.protocol = AmpClientProtocol
client = internet.TCPClient('127.0.0.1', port, factory)
service.addService(client)
ports_str = config.get('Proxy', 'telnet ports')
for portVal in ports_str.split(','):
try:
port = int(portVal)
except ValueError:
continue
factory = ServerFactory()
factory.protocol = ProxyTelnetSession
child = internet.TCPServer(port, factory)
child.setName("ProxyTelnet%d" % port)
service.addService(child)
service.startService()
reactor.run()
os.remove(pidfile)
def getOpenFlowServerFactory(self):
f = ServerFactory()
f.protocol = OpenFlowTunnelProtocol
f.forward_openflow_msg = self.forward_openflow_msg
f.add_tunnelConnection = self.add_tunnelConnection
f.remove_tunnelConnection = self.remove_tunnelConnection
return f
def createCacheService(config):
from carbon.cache import MetricCache, UDPForward
from carbon.conf import settings
from carbon.protocols import CacheManagementHandler
# Configure application components
events.metricReceived.addHandler(MetricCache.store)
root_service = createBaseService(config)
factory = ServerFactory()
factory.protocol = CacheManagementHandler
service = TCPServer(int(settings.CACHE_QUERY_PORT),
factory,
interface=settings.CACHE_QUERY_INTERFACE)
service.setServiceParent(root_service)
# have to import this *after* settings are defined
from carbon.writer import WriterService
service = WriterService()
service.setServiceParent(root_service)
# Turn on UDP forwarding
if settings.ENABLE_UDP_FORWARDING:
udp_forward = UDPForward()
events.metricReceived.addHandler(udp_forward.sendDatapoint)
if settings.USE_FLOW_CONTROL:
events.cacheFull.addHandler(events.pauseReceivingMetrics)
events.cacheSpaceAvailable.addHandler(events.resumeReceivingMetrics)
return root_service
def test_connectEvent(self):
"""
This test checks that we correctly get notifications event for a
client. This ought to prevent a regression under Windows using the GTK2
reactor. See #3925.
"""
reactor = self.buildReactor()
serverFactory = ServerFactory()
serverFactory.protocol = Protocol
server = reactor.listenTCP(0, serverFactory)
connected = []
class CheckConnection(Protocol):
def connectionMade(self):
connected.append(self)
reactor.stop()
clientFactory = Stop(reactor)
clientFactory.protocol = CheckConnection
client = reactor.connectTCP('127.0.0.1',
server.getHost().port, clientFactory)
reactor.run()
self.assertTrue(connected)
def setUp(self):
self.filesdir = self.mktemp()
self.store = Store(filesdir=self.filesdir)
self.realFactory = ServerFactory()
self.factory = DummyFactory(store=self.store,
realFactory=self.realFactory)
self.ports = []
def createBaseService(options):
root_service = RurouniRootService()
root_service.setName('rurouni')
receive_services = (
(settings.LINE_RECEIVER_INTERFACE,
settings.LINE_RECEIVER_PORT,
protocols.MetricLineReceiver
),
(settings.PICKLE_RECEIVER_INTERFACE,
settings.PICKLE_RECEIVER_PORT,
protocols.MetricPickleReceiver
),
)
for interface, port, protocol in receive_services:
if port:
factory = ServerFactory()
factory.protocol = protocol
service = TCPServer(int(port), factory, interface=interface)
service.setServiceParent(root_service)
from rurouni.state.instrumentation import InstrumentationService
service = InstrumentationService()
service.setServiceParent(root_service)
return root_service
def test_stopOnlyCloses(self):
"""
When the L{IListeningPort} returned by
L{IReactorSocket.adoptStreamPort} is stopped using
C{stopListening}, the underlying socket is closed but not
shutdown. This allows another process which still has a
reference to it to continue accepting connections over it.
"""
reactor = self.buildReactor()
portSocket = socket.socket()
self.addCleanup(portSocket.close)
portSocket.listen(1)
portSocket.setblocking(False)
# The file descriptor is duplicated by adoptStreamPort
port = reactor.adoptStreamPort(portSocket.fileno(), portSocket.family,
ServerFactory())
d = port.stopListening()
def stopped(ignored):
# Should still be possible to accept a connection on
# portSocket. If it was shutdown, the exception would be
# EINVAL instead.
exc = self.assertRaises(socket.error, portSocket.accept)
self.assertEqual(exc.args[0], errno.EAGAIN)
d.addCallback(stopped)
d.addErrback(err, "Failed to accept on original port.")
needsRunningReactor(
reactor, lambda: d.addCallback(lambda ignored: reactor.stop()))
reactor.run()
def AMP_server(game, port):
factory = ServerFactory()
factory.protocol = AMPServerProtocol
factory.game = game
service = internet.TCPServer(port, factory)
service.setName("AMPServer")
return service
def main(reactor, duration):
concurrency = 50
factory = ServerFactory()
factory.protocol = CloseConnection
interface = '127.0.0.%d' % (int(time()) % 254 + 1, )
interface = '127.0.0.1'
port = reactor.listenTCP(0, factory, interface=interface)
client = Client(
reactor,
TCP4ClientEndpoint(reactor,
port.getHost().host,
port.getHost().port,
bindAddress=(interface, 0)))
d = client.run(concurrency, duration)
def cleanup(passthrough):
d = port.stopListening()
d.addCallback(lambda ignored: passthrough)
return d
d.addCallback(cleanup)
return d
def test_handshake(self):
"""
The TLS handshake is performed when L{TLSMemoryBIOProtocol} is
connected to a transport.
"""
clientFactory = ClientFactory()
clientFactory.protocol = Protocol
clientContextFactory, handshakeDeferred = (
HandshakeCallbackContextFactory.factoryAndDeferred())
wrapperFactory = TLSMemoryBIOFactory(clientContextFactory, True,
clientFactory)
sslClientProtocol = wrapperFactory.buildProtocol(None)
serverFactory = ServerFactory()
serverFactory.protocol = Protocol
serverContextFactory = DefaultOpenSSLContextFactory(certPath, certPath)
wrapperFactory = TLSMemoryBIOFactory(serverContextFactory, False,
serverFactory)
sslServerProtocol = wrapperFactory.buildProtocol(None)
connectionDeferred = loopbackAsync(sslServerProtocol,
sslClientProtocol)
# Only wait for the handshake to complete. Anything after that isn't
# important here.
return handshakeDeferred
def run_interface(config):
factory = ServerFactory()
factory.protocol = lambda: TelnetTransport(JunctionTelnetInterface)
port = int(config['App']['TelnetInterfacePort'])
logging.info("starting telnet cli interface on port %d" % port)
service = TCPServer(port, factory)
service.startService()
def makeService(config):
s = appservice.MultiService()
conf = inetdconf.InetdConf()
conf.parseFile(open(config['file']))
for service in conf.services:
protocol = service.protocol
if service.protocol.startswith('rpc/'):
log.msg('Skipping rpc service due to lack of rpc support')
continue
if (protocol, service.socketType) not in [('tcp', 'stream'),
('udp', 'dgram')]:
log.msg('Skipping unsupported type/protocol: %s/%s' %
(service.socketType, service.protocol))
continue
# Convert the username into a uid (if necessary)
try:
service.user = int(service.user)
except ValueError:
try:
service.user = pwd.getpwnam(service.user)[2]
except KeyError:
log.msg('Unknown user: '******'s primary group
service.group = pwd.getpwuid(service.user)[3]
else:
try:
service.group = int(service.group)
except ValueError:
try:
service.group = grp.getgrnam(service.group)[2]
except KeyError:
log.msg('Unknown group: ' + service.group)
continue
if service.program == 'internal':
if config['nointernal']:
continue
# Internal services can use a standard ServerFactory
if service.name not in inetd.internalProtocols:
log.msg('Unknown internal service: ' + service.name)
continue
factory = ServerFactory()
factory.protocol = inetd.internalProtocols[service.name]
else:
factory = inetd.InetdFactory(service)
if protocol == 'tcp':
internet.TCPServer(service.port, factory).setServiceParent(s)
elif protocol == 'udp':
raise RuntimeError("not supporting UDP")
return s
def createCacheService(config):
from carbon.cache import MetricCache
from carbon.conf import settings
from carbon.protocols import CacheManagementHandler
# Configure application components
events.metricReceived.addHandler(MetricCache.store)
root_service = createBaseService(config)
factory = ServerFactory()
factory.protocol = CacheManagementHandler
service = TCPServer(int(settings.CACHE_QUERY_PORT),
factory,
interface=settings.CACHE_QUERY_INTERFACE,
backlog=settings.CACHE_QUERY_BACKLOG)
service.setServiceParent(root_service)
# have to import this *after* settings are defined
from carbon.writer import WriterService
service = WriterService()
service.setServiceParent(root_service)
if settings.USE_FLOW_CONTROL:
events.cacheFull.addHandler(events.pauseReceivingMetrics)
events.cacheSpaceAvailable.addHandler(events.resumeReceivingMetrics)
return root_service
def port(self, **kw):
store = Store()
factory = DummyFactory(store=store)
factory.realFactory = ServerFactory()
port = StringEndpointPort(store=store, factory=factory, **kw)
port._endpointService = self._fakeService
return port
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 serverFactoryFor(protocol):
"""
Helper function which provides the signature L{ServerFactory} should
provide.
"""
factory = ServerFactory()
factory.protocol = protocol
return factory
def _setup_tcp(self):
self.factory = ServerFactory()
self.factory.protocol = IndexMasterProtocol
self.factory.file_service = self
self.factory.file_dir = self.file_dir
self.factory.file_db = self.file_db
self.factory.key = self.key
self.factory.l = self.l
reactor.listenTCP(self.listen_port, self.factory)
def setUp(self):
super().setUp()
self.handler = TwistedHandler()
self.handler.factory = ServerFactory()
self.handler.factory.config = self.config
self.handler.factory.protocol_factory = ProtocolFactory(
self.config, self.app)
self.handler.transport = MagicMock(
**{"getPeer.return_value": Mock(host="myhost", port=1234)})
def test_connectionLostFailed(self):
"""
L{Port.stopListening} returns a L{Deferred} which errbacks if
L{Port.connectionLost} raises an exception.
"""
port = Port(12345, ServerFactory())
port.connected = True
port.connectionLost = lambda reason: 1 // 0
return self.assertFailure(port.stopListening(), ZeroDivisionError)
def __init__(self):
from twisted.internet import reactor
self.factory = ServerFactory()
self.factory.protocol = ClientConnection
try:
os.remove('/tmp/.sock.stalker')
except:
pass
self.port = reactor.listenUNIX('/tmp/.sock.stalker', self.factory)
