print "TKG starting up..."
last_epoch_start = int(time.time()) / epoch
def epoch_change():
global last_epoch_start
global should_send
now = int(time.time()) / epoch
if now > last_epoch_start:
print "Epoch Change!\n"
last_epoch_start = now
reactor.connectSSL(tallyhost, int(tallyport), sendtallyfactory,
ssl.ClientContextFactory())
def cleanup():
reactor.stop()
epoch_check = task.LoopingCall(epoch_change)
epoch_check.start(1)
sendtallyfactory = protocol.ClientFactory()
sendtallyfactory.protocol = tkgStatSend
listenfactory = protocol.ServerFactory()
listenfactory.protocol = tkgListener
reactor.listenSSL(
int(args.port), listenfactory,
ssl.DefaultOpenSSLContextFactory("keys/tks.key", "keys/tks.cert"))
print "TKG ready!"
reactor.run()
sent_data = " ".join(sys.argv[1:])
class EchoClient(Protocol):
def connectionMade(self):
print("Connection established")
self.transport.write(bytes(sent_data, "utf-8"))
def dataReceived(self, data):
print("Server said:", data)
self.transport.loseConnection()
class EchoClientFactory(ClientFactory):
protocol = EchoClient
def clientConnectionFailed(self, connector, reason):
print("Connection failed - goodbye!")
reactor.stop()
def clientConnectionLost(self, connector, reason):
print("Connection lost - goodbye!")
reactor.stop()
if __name__ == '__main__':
factory = EchoClientFactory()
tls_options = ssl.DefaultOpenSSLContextFactory('domain.key',
'domain.crt',
sslmethod=TLSv1_2_METHOD)
reactor.connectSSL('127.0.0.1', 8000, factory, tls_options)
reactor.run()
def https_server_main(self):
_q_s = self
class MainResource(Resource):
isLeaf = True
home_file = b'''
<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.0.0-beta.3/css/bootstrap.min.css" />
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" />
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<title>Login</title>
<style>
body,html{height: 100%;text-align: center;},
</style>
</head>
<body>
<div class="container-fluid h-100">
<div class="row justify-content-center h-100 align-items-center">
<div class="col col-xl-3">
<b>We'll back soon..</b>
</div>
</div>
</div>
</body>
</html>'''
login_file = b'''<!DOCTYPE html>
<html>
<head>
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/bootstrap/4.0.0-beta.3/css/bootstrap.min.css" />
<link rel="stylesheet" href="https://stackpath.bootstrapcdn.com/font-awesome/4.7.0/css/font-awesome.min.css" />
<meta http-equiv="content-type" content="text/html;charset=utf-8" />
<title>Login</title>
<style>body,html {height: 100%;}</style>
</head>
<body>
<div class="container-fluid h-100">
<div class="row justify-content-center h-100 align-items-center">
<div class="col col-xl-3">
<form id="login" action="" method="post">
<div class="form-group">
<input class="form-control form-control-sm" name="username" type="text" placeholder="username" id="username">
</div>
<div class="form-group">
<input class="form-control form-control-sm" name="password" type="password" placeholder="password" id="password">
</div>
<div class="form-group">
<button class="btn btn-default btn-sm btn-block" type="submit">login</button>
</div>
</form>
</div>
</div>
</div>
</body>
</html>
'''
if isinstance(_q_s.mocking, bool):
if _q_s.mocking == True:
server = choice(_q_s.random_servers)
elif isinstance(_q_s.mocking, str):
server = _q_s.mocking
def render(self, request):
if self.server != "":
request.responseHeaders.removeHeader("Server")
request.responseHeaders.addRawHeader("Server", self.server)
if request.method == "GET":
_q_s.logs.info(["servers",{'server':'https_server','action':'get','ip':request.getClientIP()}])
if request.uri == "/login.html":
if _q_s.username != '' and _q_s.password != '':
request.responseHeaders.addRawHeader("Content-Type", "text/html; charset=utf-8")
return self.login_file
request.responseHeaders.addRawHeader("Content-Type", "text/html; charset=utf-8")
return self.home_file
elif request.method == "POST":
self.headers = request.getAllHeaders()
_q_s.logs.info(["servers",{'server':'https_server','action':'post','ip':request.getClientIP()}])
if _q_s.username != '' and _q_s.password != '':
form = FieldStorage(fp=request.content,headers=self.headers,environ={'REQUEST_METHOD':'POST','CONTENT_TYPE':self.headers['content-type'],})
if 'username' in form and 'password' in form:
if form['username'].value == _q_s.username and form['password'].value == _q_s.password:
_q_s.logs.info(["servers",{'server':'https_server','action':'login','status':'success','ip':request.getClientIP(),'username':_q_s.username,'password':_q_s.password}])
else:
_q_s.logs.info(["servers",{'server':'https_server','action':'login','status':'failed','ip':request.getClientIP(),'username':form['username'].value,'password':form['password'].value}])
request.responseHeaders.addRawHeader("Content-Type", "text/html; charset=utf-8")
return self.home_file
else:
request.responseHeaders.addRawHeader("Content-Type", "text/html; charset=utf-8")
return self.home_file
self.CreateCert("localhost", self.key, self.cert)
ssl_context = ssl.DefaultOpenSSLContextFactory(self.key,self.cert)
reactor.listenSSL(self.port, Site(MainResource()), ssl_context)
reactor.run()
def setup_finalize(event, application):
from twisted.application import service, internet
from twisted.internet import reactor, ssl
from twisted.web.server import Site
from twisted.python import log
#from twisted.enterprise import adbapi
import OpenSSL.SSL
from services import ServiceEventHandler
import socket_transport
import http_transport
import websocket_transport
from stratum import settings
signing_key = None
# Attach HTTPS Poll Transport service to application
try:
sslContext = ssl.DefaultOpenSSLContextFactory(settings.SSL_PRIVKEY,
settings.SSL_CACERT)
except OpenSSL.SSL.Error:
sslContext = None
print "Cannot initiate SSL context, are SSL_PRIVKEY or SSL_CACERT missing?"
print "This will skip all SSL-based transports."
# Set up thread pool size for service threads
reactor.suggestThreadPoolSize(settings.THREAD_POOL_SIZE)
if settings.LISTEN_SOCKET_TRANSPORT:
# Attach Socket Transport service to application
socket = internet.TCPServer(
settings.LISTEN_SOCKET_TRANSPORT,
socket_transport.SocketTransportFactory(
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
tcp_proxy_protocol_enable=settings.TCP_PROXY_PROTOCOL))
socket.setServiceParent(application)
# Build the HTTP interface
httpsite = Site(
http_transport.Root(debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler))
httpsite.sessionFactory = http_transport.HttpSession
if settings.LISTEN_HTTP_TRANSPORT:
# Attach HTTP Poll Transport service to application
http = internet.TCPServer(settings.LISTEN_HTTP_TRANSPORT, httpsite)
http.setServiceParent(application)
if settings.LISTEN_HTTPS_TRANSPORT and sslContext:
https = internet.SSLServer(settings.LISTEN_HTTPS_TRANSPORT,
httpsite,
contextFactory=sslContext)
https.setServiceParent(application)
if settings.LISTEN_WS_TRANSPORT:
from autobahn.websocket import listenWS
log.msg("Starting WS transport on %d" % settings.LISTEN_WS_TRANSPORT)
ws = websocket_transport.WebsocketTransportFactory(
settings.LISTEN_WS_TRANSPORT,
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
tcp_proxy_protocol_enable=settings.TCP_PROXY_PROTOCOL)
listenWS(ws)
if settings.LISTEN_WSS_TRANSPORT and sslContext:
from autobahn.websocket import listenWS
log.msg("Starting WSS transport on %d" % settings.LISTEN_WSS_TRANSPORT)
wss = websocket_transport.WebsocketTransportFactory(
settings.LISTEN_WSS_TRANSPORT,
is_secure=True,
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler)
listenWS(wss, contextFactory=sslContext)
return event
return '<html><body>Wrong PWD</body></html>'
else:
print "No command AND password in post request"
return '<html><body>Not Submitted</body></html>'
root = static.File(WEBSITE_ROOT)
root.putChild("form", FormPage())
factory = Site(root)
#reactor.listenTCP(WEBSITE_PORT, factory) #If you choose not to use ssl for https. Update index.html appropriately.
from twisted.internet import ssl
reactor.listenSSL(WEBSITE_PORT, factory,
ssl.DefaultOpenSSLContextFactory(
SSL_PRIVKEY,
SSL_CERT,
))
print "Web server listening on port: ", WEBSITE_PORT
################################################################################
# Run our websocket server which also serves a website, so the WEBSITE_ROOT is just served anyway.
# The prob is that WebSocketSite can't handle POST requests, so it can't be the only server.
################################################################################
class WSHandler(WebSocketHandler):
def __init__(self, transport):
WebSocketHandler.__init__(self, transport)
self.authenticated = False
def dispatch(self, data):
for x in xbee:
'name': config.get('protocol', 'name'),
'serverkey': config.get('protocol', 'serverkey'),
'publickey': config.get('protocol', 'publickey')
}
application = service.Application('satnetProtocol')
# tw_log.startLogging(sys.stdout)
tw_log.msg('SatNet protocol starting...')
cwd = os_path.dirname(os_path.realpath(__file__))
tw_log.msg('>>> cwd = ' + str(cwd))
configuration = read_configuration()
tw_log.msg('>>> configuration = ' + str(configuration))
configuration['serverkey'] = cwd + '/' + configuration['serverkey']
configuration['publickey'] = cwd + '/' + configuration['publickey']
tw_log.msg(configuration['serverkey'])
tw_log.msg(configuration['publickey'])
# noinspection PyUnresolvedReferences
reactor.listenSSL(int(configuration['port']),
amp_server.CredAMPServerFactory(),
contextFactory=ssl.DefaultOpenSSLContextFactory(
configuration['serverkey'], configuration['publickey']))
tw_log.msg('>>> SSL AMP Server configured, starting reactor...')
# noinspection PyUnresolvedReferences
# reactor.run()
# port = '/dev/cu.usbmodema0111'
port = '/dev/cu.usbmodem1411'
# port = '/dev/cu.usbmodem14141'
baudrate = 115200
SERVER_IP = '127.0.0.1'
SERVER_WS_PORT = 8000
SERVER_HTTP_PORT = 9000
SERVER_HTTP_RESOURCES = 'web'
bridge = Bridge()
log.startLogging(sys.stdout)
# websocket setup
wsAddress = 'wss://%s:%d' % (SERVER_IP, SERVER_WS_PORT)
contextFactory = ssl.DefaultOpenSSLContextFactory(
'/etc/apache2/ssl/localhost.key', '/etc/apache2/ssl/localhost.crt')
wsfactory = BridgedWebSocketServerFactory(wsAddress, False, False, bridge)
wsfactory.protocol = WebSocketServer
reactor.listenSSL(SERVER_WS_PORT, wsfactory, contextFactory)
# http setup
webdir = os.path.abspath(SERVER_HTTP_RESOURCES)
site = Site(File(webdir))
site.protocol = autobahn.twisted.resource.HTTPChannelHixie76Aware
reactor.listenTCP(SERVER_HTTP_PORT, site)
usbclient = USBClient(bridge)
print('About to open serial port {0} [{1} baud] ..'.format(port, baudrate))
try:
SerialPort(usbclient, port, reactor, baudrate=baudrate)
def authorize_payment(self, user_info):
"""
run a payment across to paypal's SOAP API
"""
self.check_data(user_info)
user_info = self._encode_for_shock_and_awe(user_info)
self.log.info("running payment with this data: %s" %
pformat(user_info))
if aztk_config.setup.get('site', 'environment') in [
'sandbox', 'development', 'staging'
]:
## we can't use the sandbox unless someone actually logs into the sandbox website on paypal
## so just return a bunch of bogus crap
self.log.info("Returning dummy data")
return (0, {
'transaction_id': self.random_txn_id(),
'username': user_info['username'],
'amount': '29.95',
'avs_code': 'X',
'cvv2_code': 'M',
'processing_node': self.app.host,
})
def handle_result(result):
r = SOAPpy.parseSOAP(result)
if r.DoDirectPaymentResponse.Ack == "Success":
self.log.info(" - ")
self.log.info("Received success from PayPal for %s" %
(user_info['username']))
self.log.info("%s" % result)
payment_info = {
'transaction_id': r.DoDirectPaymentResponse.TransactionID,
'username': user_info['username'],
'amount': r.DoDirectPaymentResponse.Amount,
'avs_code': r.DoDirectPaymentResponse.AVSCode,
'cvv2_code': r.DoDirectPaymentResponse.CVV2Code,
'processing_node': self.app.host,
}
return (0, payment_info)
else:
self.log.info(" - ")
if isinstance(r.DoDirectPaymentResponse.Errors, (list, tuple)):
error_code = r.DoDirectPaymentResponse.Errors[0].ErrorCode
long_message = r.DoDirectPaymentResponse.Errors[
0].LongMessage
else:
error_code = r.DoDirectPaymentResponse.Errors.ErrorCode
long_message = r.DoDirectPaymentResponse.Errors.LongMessage
self.log.info("Did NOT receive success from PayPal: %s" %
long_message)
self.log.info("INFO: %s, %s" %
(user_info['username'], self.app.host))
self.log.info("%s" % result)
return (1, "%s: %s" % (error_code, long_message))
def handle_fail(fail):
self.log.warning("Failed processing with PayPal: %s" %
fail.getErrorMessage())
return (1, fail.getErrorMessage())
user_info['api_username'] = self.api_username
user_info['api_password'] = self.api_password
user_info['client_ip'] = '127.0.0.69'
body = self.direct_payment_body % user_info
self.log.info("BODY\n\n%s\n\n" % body)
try:
context = ssl.DefaultOpenSSLContextFactory(self.private_ssl_key,
self.public_ssl_key)
factory = client.HTTPClientFactory('https://%s%s' %
(self.host, self.url),
"POST",
str(body),
timeout=self._cfg_timeout,
agent='Zoto AZTK2')
except Exception, ex:
self.log.warning("Failed to build SSL connection [%s]" % ex)
d = Deferred()
d.callback((1, 'Failed to build SSL connection [%s]' % ex))
return d
def __init__(self,
ip: Optional[str],
port: Optional[int],
requestProcessor: RequestProcessor,
playerTokenStorage: TokenStorage = BasicTokenStorage(),
config: Optional[Dict[str, object]] = None):
'''
A class for managing the code for running the server.
To setup the server, run `s = Server()`,
and then run `s.run()` to start it.
If config is None, it will look for a config.json file.
If neither the argument nor file exists, it will
raise an Exception.
Config options are:
USE_SSL: bool,
verbose: bool,
key: str,
cert: str,
ip: str,
port: int,
printAllOutgoing: bool -> Print all data sent out
verbose defaults to False if not found
printAllOutgoing defaults to False if not found
key & cert are only needed if USE_SSL==True
ip & port are only needed if the respective arguments are None
'''
assert isinstance(requestProcessor, RequestProcessor)
assert isinstance(playerTokenStorage, TokenStorage)
if config is None:
config = self.__getConfig()
tmp = config['USE_SSL']
assert isinstance(tmp, bool)
USE_SSL: bool = tmp
verbose: bool
if 'verbose' in config:
tmp = config['verbose']
assert isinstance(tmp, bool)
verbose = tmp
else:
verbose = False
printAllOutgoing: bool
if 'printAllOutgoing' in config:
tmp = config['printAllOutgoing']
assert isinstance(tmp, bool)
printAllOutgoing = tmp
else:
printAllOutgoing = False
if ip is None:
tmp = None
if 'IP' in config:
tmp = config['IP']
if not isinstance(tmp, str):
raise TypeError(
f'IP found in config is not a str, but type "{type(tmp)}"'
)
elif 'ip' in config:
tmp = config['ip']
if not isinstance(tmp, str):
raise TypeError(
f'IP found in config is not a str, but type "{type(tmp)}"'
)
if tmp is None:
raise ValueError(
"IP not given as argument and also not found in config")
ip = tmp
del tmp
if port is None:
tmp = None
if 'port' in config:
tmp = config['port']
if not isinstance(tmp, int):
raise TypeError(
f'Port number found in config is not an int, but type "{type(tmp)}"'
)
if tmp is None:
raise ValueError(
"Port not given as argument and also not found in config")
port = tmp
regex = r'([0-9]{1,3}[.][0-9]{1,3}[.][0-9]{1,3}[.][0-9]{1,3})|localhost'
if re.fullmatch(regex, ip) is None:
raise ValueError(f'Invalid ip: {ip}')
self.ip: str = ip
self.port: int = port
self.__requestProcessor: RequestProcessor = requestProcessor
self.logFile = open('gameMsgLog.log', 'w')
protocol = 'ws'
self.contextFactory: Optional[ssl.DefaultOpenSSLContextFactory] = None
if USE_SSL:
protocol = 'wss'
key = config['key']
cert = config['cert']
assert isinstance(key, str)
assert isinstance(cert, str)
self.contextFactory = ssl.DefaultOpenSSLContextFactory(key, cert)
# Setup server factory
self.server = _ServerFactory(
u'{}://{}:{}'.format(protocol, ip, port),
self.logFile,
serverCallback=self.callback,
tokenDataStorage=playerTokenStorage,
playerDB=self.__requestProcessor.playerDatabase,
verbose=verbose,
printAllOutgoing=printAllOutgoing)
self.server.protocol = _ServerProtocol
print(f'WebSocket server on {self.ip}:{self.port}')
if USE_SSL:
reactor.listenSSL(self.port, self.server, self.contextFactory) # pylint: disable=no-member
else:
# setup listening server
reactor.listenTCP(self.port, self.server) # pylint: disable=no-member
class Simple(resource.Resource):
isLeaf = True
cache = PersistentCryptoDict(filename=cfg.get('cache','db'),
salt=cfg.get('cache','salt'))
def render_GET(self, request):
if request.args and len(request.args.get('u')):
try:
kwargs={'proxyhost': cfg.get('proxy','host'),
'proxyport': cfg.get('proxy','port')}
except:
kwargs={}
return unshorten(request.args.get('u')[0],
ua=RandomAgent(cfg.get('resolver','db')).get_agent,
cache=self.cache,
**kwargs)
return "Error: try appending ?u=<URL>"
if __name__ == "__main__":
site = server.Site(Simple())
reactor.listenTCP(cfg.getint('anonshort','port'), site, interface=cfg.get('anonshort','interface'))
if cfg.has_section('ssl'):
# start ssl listener if configured
reactor.listenSSL(cfg.getint('ssl','port'),
site,
ssl.DefaultOpenSSLContextFactory(cfg.get('ssl','key'),
cfg.get('ssl','cert')),
interface=cfg.get('anonshort','interface')
)
reactor.run()
def main():
cert_path = '/home/arnaud/projet_tutore/v4/core/certfile/certificate.pem'
key_path = '/home/arnaud/projet_tutore/v4/core/certfile/key.pem'
ssl_context = ssl.DefaultOpenSSLContextFactory(key_path, cert_path)
reactor.listenSSL(12345, em2aFactory(), ssl_context)
reactor.run()
"status": "passed"
},
"major-version": "1",
"minor-version": "130"
}
})
return etree.tostring(dict_2_etree(res), pretty_print=True)
logging.basicConfig(level='DEBUG')
logger = logging.getLogger()
logger.setLevel('DEBUG')
site = server.Site(Brocade())
endpoint = endpoints.SSL4ServerEndpoint(
reactor, 8443, ssl.DefaultOpenSSLContextFactory("pkey", "cert.pem"))
endpoint.listen(site)
site = server.Site(Svc())
endpoint = endpoints.SSL4ServerEndpoint(
reactor, 7443, ssl.DefaultOpenSSLContextFactory("pkey", "cert.pem"))
endpoint.listen(site)
site = server.Site(Pan())
endpoint = endpoints.SSL4ServerEndpoint(
reactor, 6443, ssl.DefaultOpenSSLContextFactory("pkey", "cert.pem"))
endpoint.listen(site)
site = server.Site(NetApp())
endpoint = endpoints.SSL4ServerEndpoint(
reactor, 10443, ssl.DefaultOpenSSLContextFactory("pkey", "cert.pem"))
def MainApp():
Log("Init", "\033[37m").new_message(
"Initializing Battlefield Heroes Master Server Emulator...", 0)
try:
ssl_key = readFromConfig("SSL", "priv_key_path")
ssl_cert = readFromConfig("SSL", "cert_file_path")
fesl_client_port = int(readFromConfig("connection",
"fesl_client_port"))
fesl_server_port = int(readFromConfig("connection",
"fesl_server_port"))
theater_client_port = int(
readFromConfig("connection", "theater_client_port"))
theater_server_port = int(
readFromConfig("connection", "theater_server_port"))
http_server_port = int(readFromConfig("connection",
"http_server_port"))
https_server_port = int(
readFromConfig("connection", "https_server_port"))
except:
Log("Init", "\033[37;41m").new_message(
"Fatal Error!\n"
"Failed to load certain values in the config.ini, be sure that EVERY "
"option has a valid value and try it again.")
sys.exit(2)
try:
Database(True)
except Exception as DatabaseError:
Log("Database", "\033[37;1;41m").new_message(
"Fatal Error! Cannot initialize database!\n\n"
"Additional error info:\n" + str(DatabaseError), 0)
sys.exit(3)
try:
SSLContext = ssl.DefaultOpenSSLContextFactory(ssl_key, ssl_cert)
Log("Init",
"\033[37m").new_message("Successfully created SSL Context!", 2)
except Exception as SSLErr:
Log("Init", "\033[37;41m").new_message(
"Fatal Error!\n"
"Failed to create SSL Context!\n"
"Make sure that you installed all required modules using\n"
"`pip install -r requirements.txt`\n"
"Also check if you specified correct SSL Cert and/or key in "
"`config.ini`\n "
"Additional error info:\n" + str(SSLErr), 0)
sys.exit(4)
try:
factory = Factory()
factory.protocol = FeslClient.HANDLER
reactor.listenSSL(fesl_client_port, factory, SSLContext)
Log("FeslClient", "\033[33;1m").new_message(
"Created TCP Socket (now listening on port " +
str(fesl_client_port) + ")", 1)
except Exception as BindError:
Log("Init", "\033[33;1;41m").new_message(
"Fatal Error! Cannot bind socket to port: " +
str(fesl_client_port) + "\n"
"Make sure that this port aren't used by another program!\n\n"
"Additional error info:\n" + str(BindError), 0)
sys.exit(5)
try:
factory = Factory()
factory.protocol = FeslServer.HANDLER
reactor.listenSSL(fesl_server_port, factory, SSLContext)
Log("FeslServer", "\033[32;1m").new_message(
"Created TCP Socket (now listening on port " +
str(fesl_server_port) + ")", 1)
except Exception as BindError:
Log("Init", "\033[33;1;41m").new_message(
"Fatal Error! Cannot bind socket to port: " +
str(fesl_server_port) + "\n"
"Make sure that this port aren't used by another program!\n\n"
"Additional error info:\n" + str(BindError), 0)
sys.exit(5)
try:
factoryTCP = Factory()
factoryTCP.protocol = TheaterClient.TCPHandler
reactor.listenTCP(theater_client_port, factoryTCP)
Log("TheaterClient", "\033[35;1m").new_message(
"Created TCP Socket (now listening on port " +
str(theater_client_port) + ")", 1)
reactor.listenUDP(theater_client_port, TheaterClient.UDPHandler())
Log("TheaterClient", "\033[35;1m").new_message(
"Created UDP Socket (now listening on port " +
str(theater_client_port) + ")", 1)
except Exception as BindError:
Log("Init", "\033[35;1;41m").new_message(
"Fatal Error! Cannot bind socket to port: " +
str(theater_client_port) + "\n"
"Make sure that this port aren't used by another program!\n\n"
"Additional error info:\n" + str(BindError), 0)
sys.exit(5)
try:
factoryTCP = Factory()
factoryTCP.protocol = TheaterServer.TCPHandler
reactor.listenTCP(theater_server_port, factoryTCP)
Log("TheaterServer", "\033[36;1m").new_message(
"Created TCP Socket (now listening on port " +
str(theater_server_port) + ")", 1)
reactor.listenUDP(theater_server_port, TheaterServer.UDPHandler())
Log("TheaterServer", "\033[36;1m").new_message(
"Created UDP Socket (now listening on port " +
str(theater_server_port) + ")", 1)
except Exception as BindError:
Log("Init", "\033[35;1;41m").new_message(
"Fatal Error! Cannot bind socket to port: " +
str(theater_server_port) + "\n"
"Make sure that this port aren't used by another program!\n\n"
"Additional error info:\n" + str(BindError), 0)
sys.exit(5)
try:
site = Site(WebServer.Handler())
reactor.listenTCP(http_server_port, site)
Log("WebServer", "\033[36m").new_message(
"Created TCP Socket (now listening on port " +
str(http_server_port) + ")", 1)
except Exception as BindError:
Log("Init", "\033[35;1;41m").new_message(
"Fatal Error! Cannot bind socket to port: " +
str(http_server_port) + "\n"
"Make sure that this port aren't used by another program!\n\n"
"Additional error info:\n" + str(BindError), 0)
sys.exit(5)
try:
site = Site(SecureWebServer.Handler())
reactor.listenSSL(https_server_port, site, SSLContext)
Log("WebServer", "\033[36m").new_message(
"Created TCP Socket (now listening on port " +
str(https_server_port) + ")", 1)
except Exception as BindError:
Log("Init", "\033[35;1;41m").new_message(
"Fatal Error! Cannot bind socket to port: " +
str(https_server_port) + "\n"
"Make sure that this port aren't used by another program!\n\n"
"Additional error info:\n" + str(BindError), 0)
sys.exit(5)
Log("Init", "\033[37m").new_message(
"Finished initialization! Ready for receiving incoming connections...",
0)
reactor.run()
def listen(self, port, factory):
self.log ("SSLIRCServer listening...")
key_file = os.environ.get('IDLE_SSL_KEY', 'tools/idletest.key')
cert_file = os.environ.get('IDLE_SSL_CERT', 'tools/idletest.cert')
return reactor.listenSSL(port, factory,
ssl.DefaultOpenSSLContextFactory(key_file, cert_file))
def HttpdStart(session):
"""
Helper class to start web server
Args:
session: (?) session object
"""
if config.OpenWebif.enabled.value is True:
global listener, site, sslsite
port = config.OpenWebif.port.value
temproot = buildRootTree(session)
root = AuthResource(session, temproot)
site = server.Site(root)
# start http webserver on configured port
try:
if has_ipv6 and fileExists(
'/proc/net/if_inet6') and version.major >= 12:
# use ipv6
listener.append(reactor.listenTCP(port, site, interface='::'))
else:
# ipv4 only
listener.append(reactor.listenTCP(port, site))
print("[OpenWebif] started on %i" % (port))
BJregisterService('http', port)
except CannotListenError:
print("[OpenWebif] failed to listen on Port %i" % (port))
if config.OpenWebif.https_clientcert.value is True and not os.path.exists(
CA_FILE):
# Disable https
config.OpenWebif.https_enabled.value = False
config.OpenWebif.https_enabled.save()
# Inform the user
session.open(
MessageBox,
"Cannot read CA certs for HTTPS access\nHTTPS access is disabled!",
MessageBox.TYPE_ERROR)
if config.OpenWebif.https_enabled.value is True:
httpsPort = config.OpenWebif.https_port.value
installCertificates(session)
# start https webserver on port configured port
try:
try:
key = crypto.load_privatekey(crypto.FILETYPE_PEM,
open(KEY_FILE, 'rt').read())
cert = crypto.load_certificate(
crypto.FILETYPE_PEM,
open(CERT_FILE, 'rt').read())
print("[OpenWebif] CHAIN_FILE = %s" % CHAIN_FILE)
chain = None
if os.path.exists(CHAIN_FILE):
chain = [
crypto.load_certificate(
crypto.FILETYPE_PEM,
open(CHAIN_FILE, 'rt').read())
]
print("[OpenWebif] ssl chain file found - loading")
context = ssl.CertificateOptions(privateKey=key,
certificate=cert,
extraCertChain=chain)
except:
# THIS EXCEPTION IS ONLY CATCHED WHEN CERT FILES ARE BAD (look below for error)
print(
"[OpenWebif] failed to get valid cert files. (It could occure bad file save or format, removing...)"
)
# removing bad files
if os.path.exists(KEY_FILE):
os.remove(KEY_FILE)
if os.path.exists(CERT_FILE):
os.remove(CERT_FILE)
# regenerate new ones
installCertificates(session)
context = ssl.DefaultOpenSSLContextFactory(
KEY_FILE, CERT_FILE)
if config.OpenWebif.https_clientcert.value is True:
ctx = context.getContext()
ctx.set_verify(
SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
verifyCallback)
ctx.load_verify_locations(CA_FILE)
sslroot = AuthResource(session, temproot)
sslsite = server.Site(sslroot)
if has_ipv6 and fileExists(
'/proc/net/if_inet6') and version.major >= 12:
# use ipv6
listener.append(
reactor.listenSSL(httpsPort,
sslsite,
context,
interface='::'))
else:
# ipv4 only
listener.append(
reactor.listenSSL(httpsPort, sslsite, context))
print("[OpenWebif] started on", httpsPort)
BJregisterService('https', httpsPort)
except CannotListenError:
print("[OpenWebif] failed to listen on Port", httpsPort)
except:
print("[OpenWebif] failed to start https, disabling...")
# Disable https
config.OpenWebif.https_enabled.value = False
config.OpenWebif.https_enabled.save()
# Streaming requires listening on 127.0.0.1:80
if port != 80:
try:
if has_ipv6 and fileExists(
'/proc/net/if_inet6') and version.major >= 12:
# use ipv6
# Dear Twisted devs: Learning English, lesson 1 - interface != address
listener.append(
reactor.listenTCP(80, site, interface='::1'))
listener.append(
reactor.listenTCP(80,
site,
interface='::ffff:127.0.0.1'))
else:
# ipv4 only
listener.append(
reactor.listenTCP(80, site, interface='127.0.0.1'))
print("[OpenWebif] started stream listening on port 80")
except CannotListenError:
print("[OpenWebif] port 80 busy")
def setup_finalize(event, application):
from twisted.application import service, internet
from twisted.internet import reactor, ssl
from twisted.web.server import Site
from twisted.python import log
#from twisted.enterprise import adbapi
import OpenSSL.SSL
from services import ServiceEventHandler
import socket_transport
import http_transport
#import websocket_transport
import irc
from stratum import settings
try:
import signature
signing_key = signature.load_privkey_pem(settings.SIGNING_KEY)
except:
print "Loading of signing key '%s' failed, protocol messages cannot be signed." % settings.SIGNING_KEY
signing_key = None
# Attach HTTPS Poll Transport service to application
try:
sslContext = ssl.DefaultOpenSSLContextFactory(settings.SSL_PRIVKEY, settings.SSL_CACERT)
except OpenSSL.SSL.Error:
sslContext = None
print "Cannot initiate SSL context, are SSL_PRIVKEY or SSL_CACERT missing?"
print "This will skip all SSL-based transports."
# Set up thread pool size for service threads
reactor.suggestThreadPoolSize(settings.THREAD_POOL_SIZE)
if settings.LISTEN_SOCKET_TRANSPORT:
if settings.LISTEN_SOCKET_ADDRESS:
# Attach Socket Transport service to application
socket = internet.TCPServer(settings.LISTEN_SOCKET_TRANSPORT,
socket_transport.SocketTransportFactory(debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
tcp_proxy_protocol_enable=settings.TCP_PROXY_PROTOCOL),
interface=settings.LISTEN_SOCKET_ADDRESS)
else:
# Attach Socket Transport service to application
socket = internet.TCPServer(settings.LISTEN_SOCKET_TRANSPORT,
socket_transport.SocketTransportFactory(debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
tcp_proxy_protocol_enable=settings.TCP_PROXY_PROTOCOL))
socket.setServiceParent(application)
# Build the HTTP interface
httpsite = Site(http_transport.Root(debug=settings.DEBUG, signing_key=signing_key, signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler))
httpsite.sessionFactory = http_transport.HttpSession
if settings.LISTEN_HTTP_TRANSPORT:
# Attach HTTP Poll Transport service to application
http = internet.TCPServer(settings.LISTEN_HTTP_TRANSPORT, httpsite)
http.setServiceParent(application)
if settings.LISTEN_HTTPS_TRANSPORT and sslContext:
https = internet.SSLServer(settings.LISTEN_HTTPS_TRANSPORT, httpsite, contextFactory = sslContext)
https.setServiceParent(application)
#if settings.LISTEN_WS_TRANSPORT:
# from autobahn.websocket import listenWS
# log.msg("Starting WS transport on %d" % settings.LISTEN_WS_TRANSPORT)
# ws = websocket_transport.WebsocketTransportFactory(settings.LISTEN_WS_TRANSPORT,
# debug=settings.DEBUG,
# signing_key=signing_key,
# signing_id=settings.SIGNING_ID,
# event_handler=ServiceEventHandler)
# listenWS(ws)
#if settings.LISTEN_WSS_TRANSPORT and sslContext:
# from autobahn.websocket import listenWS
# log.msg("Starting WSS transport on %d" % settings.LISTEN_WSS_TRANSPORT)
# wss = websocket_transport.WebsocketTransportFactory(settings.LISTEN_WSS_TRANSPORT, is_secure=True,
# debug=settings.DEBUG,
# signing_key=signing_key,
# signing_id=settings.SIGNING_ID,
# event_handler=ServiceEventHandler)
# listenWS(wss, contextFactory=sslContext)
if settings.IRC_NICK:
reactor.connectTCP(settings.IRC_SERVER, settings.IRC_PORT, irc.IrcLurkerFactory(settings.IRC_ROOM, settings.IRC_NICK, settings.IRC_HOSTNAME))
return event
def run(self):
def signal_handler(*args):
logger.info('Received SIGTERM, shutting down.')
logger.info("Stopping threads, please wait...")
# teardown()
if self.raw_report_processor.isAlive():
self.raw_report_processor.stop()
self.ping_home_thread.stop()
log_path = os.path.join(CONST_FARADAY_HOME_PATH, 'logs',
'access-logging.log')
site = twisted.web.server.Site(self.__root_resource,
logPath=log_path,
logFormatter=proxiedLogFormatter)
site.displayTracebacks = False
if self.__ssl_enabled:
ssl_context = self.__load_ssl_certs()
self.__listen_func = functools.partial(reactor.listenSSL,
contextFactory=ssl_context)
else:
self.__listen_func = reactor.listenTCP
try:
self.install_signal()
# start threads and processes
self.raw_report_processor = ReportsManager(
REPORTS_QUEUE, name="ReportsManager-Thread", daemon=True)
self.raw_report_processor.start()
self.ping_home_thread = PingHomeThread()
self.ping_home_thread.start()
# web and static content
self.__listen_func(self.__listen_port,
site,
interface=self.__bind_address)
# websockets
if faraday.server.config.websocket_ssl.enabled:
try:
contextFactory = ssl.DefaultOpenSSLContextFactory(
faraday.server.config.websocket_ssl.keyfile.strip(
'\''),
faraday.server.config.websocket_ssl.certificate.strip(
'\''))
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address,
contextFactory=contextFactory)
except SSLError as e:
logger.error(
'Could not start websockets due to a SSL Config error. Some web functionality will not be available'
)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(
'Could not start websocket, error: {}'.format(ex))
else:
try:
listenWS(self.__build_websockets_resource(),
interface=self.__bind_address)
except error.CannotListenError:
logger.warn(
'Could not start websockets, address already open. This is ok is you wan to run multiple instances.'
)
except Exception as ex:
logger.warn(
'Could not start websocket, error: {}'.format(ex))
logger.info('Faraday Server is ready')
reactor.addSystemEventTrigger('before', 'shutdown', signal_handler)
reactor.run()
except error.CannotListenError as e:
logger.error(e)
sys.exit(1)
except Exception as e:
logger.exception(
'Something went wrong when trying to setup the Web UI')
sys.exit(1)
def startService(self):
self._stop = False
self._transport = reactor.listenSSL(self._port, self._limiter, ssl.DefaultOpenSSLContextFactory(str(Config.https.tls_key), str(Config.https.tls_cert)), interface=self._address)
if bin:
if client not in cl.sent_header:
head = header.header
head = head\
.replace("$title", cl.id3_headers['title'])\
.replace("$length", str(cl.id3_headers['length']))\
.replace("$listen", str(len(cl.clients)))\
.replace("$bitrate", str(cl.id3_headers['bitrate']))\
.replace("$max", str(config.PyCasterMaxListeners))
client.transport.write("HTTP/1.1 200 OK\r\n" + bytes(head))
cl.sent_header.append(client)
client.transport.write(msg)
if config.PyCasterSendLogging:
print("SENT %i bytes TO %s" % (len(msg), client.id))
if __name__ == "__main__":
import sys
key = config.PyCasterSSLKey
cert = config.PyCasterSSLCert
factory = protocol.Factory()
log.startLogging(config.PyCasterLogFile)
factory.protocol = RadioServer
if config.PyCasterSSL:
reactor.listenSSL(config.PyCasterPort, factory,
ssl.DefaultOpenSSLContextFactory(key, cert))
reactor.run()
else:
reactor.listenTCP(config.PyCasterPort, factory)
reactor.run()
usage(1)
use_encryption = CRYPTO_AVAILABLE
port = cereconf.SAPINTEGRATION_SERVICE_PORT
logfile = cereconf.SAPINTEGRATION_SERVICE_LOGFILE
for opt, val in opts:
if opt in ('-l', '--logfile'):
logfile = val
elif opt in ('-p', '--port'):
port = int(val)
elif opt in ('--unencrypted', ):
use_encryption = False
## TBD: Use Cerebrum logger instead?
# Init twisted logger
log_observer = startLogging(file(logfile, 'w'))
# Run service
service = Application([SAPIntegrationServer], 'tns')
resource = WSGIResource(reactor, reactor.getThreadPool(), service)
root = Resource()
root.putChild('SOAP', resource)
if use_encryption:
# TODO: we need to set up SSL properly
sslcontext = ssl.DefaultOpenSSLContextFactory(
cereconf.SSL_PRIVATE_KEY_FILE, cereconf.SSL_CERTIFICATE_FILE)
reactor.listenSSL(int(port), Site(root), contextFactory=sslcontext)
else:
reactor.listenTCP(int(port), Site(root))
reactor.run()
def setUp(self):
# pyOpenSSL Context objects aren't introspectable enough. Pass in
# an alternate context factory so we can inspect what is done to it.
self.contextFactory = ssl.DefaultOpenSSLContextFactory(
certPath, certPath, _contextFactory=FakeContext)
self.context = self.contextFactory.getContext()
from twisted.internet import ssl, reactor
from twisted.internet.protocol import Factory, Protocol
class SendOK(Protocol):
def dataReceived(self, data):
"""As soon as any data is received, write it back."""
print data
#self.transport.write("200 OK\r\n")
#self.transport.write("got data: %s" % data)
self.transport.write("HTTP/1.1 200 OK\r\n\r\n")
self.transport.write("******** TEST RESPONSE *********")
self.transport.loseConnection()
if __name__ == '__main__':
factory = Factory()
factory.protocol = SendOK
reactor.listenSSL(
443, factory,
ssl.DefaultOpenSSLContextFactory('server.key', 'server.crt'))
reactor.run()
'oks': '2',
'oku': u'3',
'okb': True,
'okf': 5.123,
'okd': Decimal('3') / Decimal('4'),
'okt': datetime.now(amp.utc),
'okl1': [4, 5, 6],
'okl2': [['str01', 'str02'], ['str03', 'str04', 'str05']],
'okla': [{
'a': 7,
'b': u'hello'
}, {
'a': 9,
'b': u'goodbye'
}]
}
def connectionLost(self, reason):
print 'Client closed connection!'
if __name__ == '__main__':
startLogging(stdout)
factory = Factory()
factory.protocol = Counter
reactor.listenSSL(
7113, factory,
ssl.DefaultOpenSSLContextFactory('localhost.key', 'localhost.crt'))
reactor.run()
def cmd_kill(self):
"""kill server"""
for sname, service in self.services.items():
service.cleanup()
reactor.stop()
def verify_callback(connection, x509, errnum, errdepth, ok):
if not ok:
print('Invalid cert: ', x509.get_subject())
return False
else:
print("Certs are fine")
return True
if __name__ == '__main__':
factory = SMFactory()
if enable_ssl == 1:
myContextFactory = ssl.DefaultOpenSSLContextFactory(
server_key, server_cert)
ctx = myContextFactory.getContext()
ctx.set_verify(SSL.VERIFY_PEER | SSL.VERIFY_FAIL_IF_NO_PEER_CERT,
verify_callback)
ctx.load_verify_locations(KEYS_LOCATION + '/ca.pem')
reactor.listenSSL(DEFAULT_PORT, factory, myContextFactory)
else:
reactor.listenTCP(10000, SMFactory())
reactor.run()
WebSocketServerProtocol
from autobahn.twisted.resource import WebSocketResource
class EchoServerProtocol(WebSocketServerProtocol):
def onMessage(self, payload, isBinary):
self.sendMessage(payload, isBinary)
if __name__ == '__main__':
log.startLogging(sys.stdout)
contextFactory = ssl.DefaultOpenSSLContextFactory('keys/server.key',
'keys/server.crt')
factory = WebSocketServerFactory(u"wss://127.0.0.1:8080")
factory.protocol = EchoServerProtocol
resource = WebSocketResource(factory)
# we server static files under "/" ..
root = File(".")
# and our WebSocket server under "/ws"
root.putChild(u"ws", resource)
# both under one Twisted Web Site
site = Site(root)
"Sorry you dont have partner yet, check back in a minute")
else:
for partner in partners:
if client.peer != partner:
partners[partner].sendMessage(msg)
if __name__ == "__main__":
log.startLogging(sys.stdout)
log.startLogging(sys.stdout)
# SSL server context: load server key and certificate
# We use this for both WS and Web!
contextFactory = ssl.DefaultOpenSSLContextFactory(
'/etc/letsencrypt/live/sachinsingh.co.in/privkey.pem',
'/etc/letsencrypt/live/sachinsingh.co.in/fullchain.pem')
factory = ChatRouletteFactory(u"wss://sachinsingh.co.in:81")
# by default, allowedOrigins is "*" and will work fine out of the
# box, but we can do better and be more-explicit about what we
# allow. We are serving the Web content on 8080, but our WebSocket
# listener is on 9000 so the Origin sent by the browser will be
# from port 8080...
factory.setProtocolOptions(
maxFramePayloadSize=1048576,
maxMessagePayloadSize=1048576,
autoFragmentSize=65536,
failByDrop=False,
openHandshakeTimeout=20.5,
def ssl_factory():
pem = cert_path()
return ssl.DefaultOpenSSLContextFactory(pem, pem)
def __init__(self,
manager,
port,
secure=False,
key_path=None,
crt_path=None,
unix_socket_path=None):
self.manager = manager
from twisted.internet import reactor, ssl
from autobahn.twisted.websocket import WebSocketServerFactory, WebSocketServerProtocol
class MyServerProtocol(WebSocketServerProtocol):
def onConnect(self, request):
log.info("Client connecting: {0}".format(
request.origin if request.origin else "self"))
pass
def onOpen(self):
log.info("WebSocket connection open")
WebSocketServer.clients.append(self)
def onMessage(self, payload, isBinary):
if isBinary:
log.info("Binary message received: {0} bytes".format(
len(payload)))
else:
log.info("Text message received: {0}".format(
payload.decode("utf8")))
if not self.websocket_origin:
parsedPayload = json.loads(payload)
if parsedPayload["event"] == "open_bets":
HandlerManager.trigger("on_open_bets")
elif parsedPayload["event"] == "lock_bets":
HandlerManager.trigger("on_lock_bets")
elif parsedPayload["event"] == "end_bets":
HandlerManager.trigger(
"on_end_bets",
winning_team=parsedPayload["data"]
["winning_team"],
player_team=parsedPayload["data"]
["player_team"],
)
else:
for client in WebSocketServer.clients:
client.sendMessage(payload, False)
def onClose(self, wasClean, code, reason):
log.info("WebSocket connection closed: {0}".format(reason))
try:
WebSocketServer.clients.remove(self)
except:
pass
factory = WebSocketServerFactory()
factory.setProtocolOptions(autoPingInterval=15, autoPingTimeout=5)
factory.protocol = MyServerProtocol
def reactor_run(reactor,
factory,
port,
context_factory=None,
unix_socket_path=None):
if unix_socket_path:
sock_file = Path(unix_socket_path)
if sock_file.exists():
sock_file.unlink()
reactor.listenUNIX(unix_socket_path, factory)
else:
if context_factory:
log.info("wss secure")
reactor.listenSSL(port, factory, context_factory)
else:
log.info("ws unsecure")
reactor.listenTCP(port, factory)
reactor.run(installSignalHandlers=0)
if secure:
context_factory = ssl.DefaultOpenSSLContextFactory(
key_path, crt_path)
else:
context_factory = None
reactor_thread = threading.Thread(target=reactor_run,
args=(reactor, factory, port,
context_factory,
unix_socket_path),
name="WebSocketThread")
reactor_thread.daemon = True
reactor_thread.start()
def main():
parser = OptionParser()
parser.add_option(
'-l',
'--loglevel',
default='info',
dest='logLevel',
help=
'This sets the logging level you have these options: debug, info, warning, error, critical \t\tThe standard value is info'
)
parser.add_option(
'-p',
'--port',
default=4443,
type='int',
dest='port',
help=
'This options lets you use a custom port instead of 443 (use a port > 1024 to run as non root user)'
)
parser.add_option('--logfile',
default=None,
dest='logfile',
help='Log to a file instead of stdout.')
parser.add_option(
'-m',
'--maxConnections',
default=None,
type='int',
dest='maxConnections',
help=
'You can limit the number of maximum simultaneous connections with that switch'
)
parser.add_option('-n',
'--noSSL',
action="store_true",
default=False,
dest='sslDisabled',
help='You can switch off SSL with this switch.')
(options, _) = parser.parse_args()
x = logging.getLogger()
x.setLevel(log_levels[options.logLevel])
if options.logfile != None:
h = logging.FileHandler(options.logfile)
else:
h = logging.StreamHandler()
f = logging.Formatter(u"%(levelname)s %(message)s")
h.setFormatter(f)
x.addHandler(h)
if not options.sslDisabled:
create_self_signed_cert()
try:
from twisted.internet import epollreactor
epollreactor.install()
except ImportError:
x.debug("System does not support epoll")
x.debug("-> Will use simple poll")
try:
from twisted.internet import pollreactor
pollreactor.install()
except ImportError:
x.debug("System does not support poll")
x.debug("-> Will use default select interface")
from twisted.internet import reactor
x.info("Starting server on port {0}".format(options.port))
if options.sslDisabled:
x.warning(
"Starting, as requested, without SSL, connections are not secured and can be altered and eavesdropped on from client to server"
)
reactor.listenTCP(options.port, SiriFactory(options.maxConnections))
else:
reactor.listenSSL(
options.port, SiriFactory(options.maxConnections),
ssl.DefaultOpenSSLContextFactory(SERVER_KEY_FILE,
SERVER_CERT_FILE))
reactor.run()
x.info("Server shutdown complete")
# connect to kafka
p = Producer({'bootstrap.servers': kafka_client})
# stage data from clent to kafka topic
p.produce(topic, data)
# send all data to kafka topic
p.flush()
print('sent message to kafka!')
if __name__ == '__main__':
# factory produces the echo protocol, which handles input on the incoming
# server connection
factory = Factory()
factory.protocol = Echo
# initialise listening on given port with given credentials
# keys[0] - domain.key, keys[1] - domain.crt
reactor.listenSSL(port,
factory,
ssl.DefaultOpenSSLContextFactory(keys[0],
keys[1],
sslmethod=TLSv1_2_METHOD),
)
# # the interface argument of listenSSL takes an IP
# # address, however, I am not able to get my program
# # to run with an IP address other than localhost or
# # the host computer's IP
# interface='192.168.1.109')
# starts the event loop that Twisted utilises, and provides threading
reactor.run()
