def makeService(self, options):
srv = service.MultiService()
s = None
if options["app"]:
app = reflect.namedAny(options["app"])
else:
app = App
# http
s = internet.TCPServer(options["port"], app(options),
interface=options["listen"])
s.setServiceParent(srv)
# https
if options["use-ssl"]:
if ssl_support:
s = internet.SSLServer(options["ssl-port"], app(options),
ssl.DefaultOpenSSLContextFactory(
options["ssl-key"],
options["ssl-cert"]),
interface=options["ssl-listen"])
s.setServiceParent(srv)
else:
print("SSL is not supported. Please install PyOpenSSL.")
if s is None:
print("Nothing to do. Try --help")
sys.exit(1)
return srv
def makeService(config):
if config['logfile']:
logObserver = log.FileAccessLoggingObserver(config['logfile'])
else:
logObserver = log.DefaultCommonAccessLoggingObserver()
if config['root']:
if config['indexes']:
config['root'].indexNames = config['indexes']
root = log.LogWrapperResource(config['root'])
s = Web2Service(logObserver)
site = server.Site(root)
chan = channel.HTTPFactory(site)
if config['https']:
from twisted.internet.ssl import DefaultOpenSSLContextFactory
i = internet.SSLServer(
int(config['https']), chan,
DefaultOpenSSLContextFactory(config['privkey'],
config['certificate']))
i.setServiceParent(s)
strports.service(config['port'], chan).setServiceParent(s)
return s
def makeService(self, options):
if options['data-dir'] != None:
if not os.access(options['data-dir'], os.X_OK | os.W_OK):
raise core.SmapException("Cannot access " +
options['data-dir'])
smapconf.SERVER['DataDir'] = options['data-dir']
inst = loader.load(options['conf'])
# override defaults with command-line args
smapconf.SERVER.update(
dict([(k.lower(), v) for (k, v) in options.iteritems()
if v != None]))
if 'SuggestThreadPool' in smapconf.SERVER:
reactor.suggestThreadPoolSize(
int(smapconf.SERVER['SuggestThreadPool']))
inst.start()
reactor.addSystemEventTrigger('before', 'shutdown', inst.stop)
site = getSite(inst, docroot=smapconf.SERVER['docroot'])
service = MultiService()
# add HTTP and HTTPS servers to the twisted multiservice
if 'port' in smapconf.SERVER:
service.addService(
internet.TCPServer(int(smapconf.SERVER['port']), site))
if 'sslport' in smapconf.SERVER:
service.addService(
internet.SSLServer(int(smapconf.SERVER['sslport']), site,
SslServerContextFactory(smapconf.SERVER)))
return service
def makeService():
s = service.MultiService()
f = protocol.ServerFactory()
f.protocol = ProtocolSwitcher
f.clients = []
f.gameDB = GameDB()
f.db = Database()
h = internet.TCPServer(settings.port, f).setServiceParent(s)
h = internet.SSLServer(
settings.ssl_port, f,
ssl.DefaultOpenSSLContextFactory(
settings.ssl_key, settings.ssl_cert)).setServiceParent(s)
# Debug add some games
# for i in xrange(30):
# game = f.gameDB.create(4, True)
# f.gameDB.updateGame(game['gameId'], {
# "host" : "localhost",
# "port" : 2100,
# "description" : "Test %d" % i,
# "currentPlayers" : 1,
# "maxPlayers" : 3,
# "multiVer" : "None existend test",
# "wzVerMajor" : 4,
# "wzVerMinor" : 11012,
# "isPrivate" : True,
# "modlist" : "",
# "mapname" : "Sk-Rush-T1",
# "hostplayer" : "Test %d" % i,
# })
return s
def get_service(self):
from twisted.application import service, internet
top_service = service.MultiService()
internet.UDPServer(
self.authport, self.auth_protocol,
interface=self.radiusd_host).setServiceParent(top_service)
internet.UDPServer(
self.acctport, self.acct_protocol,
interface=self.radiusd_host).setServiceParent(top_service)
if self.use_ssl:
log.msg('WS SSL Enable!')
from twisted.internet import ssl
sslContext = ssl.DefaultOpenSSLContextFactory(
self.privatekey, self.certificate)
internet.SSLServer(
self.adminport,
self.admin_factory,
contextFactory=sslContext,
interface=self.radiusd_host).setServiceParent(top_service)
else:
log.msg('WS SSL Disable!')
internet.TCPServer(
self.adminport,
self.admin_factory,
interface=self.radiusd_host).setServiceParent(top_service)
return top_service
def startService(self):
"""
This sets up the OpenNSA service and ties together everything in the initialization.
There are a lot of things going on, but none of it it particular deep.
"""
log.msg('OpenNSA service initializing', system='opennsa.setup')
vc = self.vc
topology_sources = [ open(tf) for tf in vc[config.TOPOLOGY_FILE] ]
topology, internal_topology = gole.parseTopology(topology_sources, open(vc[config.NRM_MAP_FILE]) if vc[config.NRM_MAP_FILE] else None )
if vc[config.HOST] is None:
import socket
vc[config.HOST] = socket.getfqdn()
ctx_factory = None
if vc[config.TLS]:
from opennsa import ctxfactory
ctx_factory = ctxfactory.ContextFactory(vc[config.KEY], vc[config.CERTIFICATE], vc[config.CERTIFICATE_DIR], vc[config.VERIFY_CERT])
backend = setupBackend(vc['backend'], vc[config.NETWORK_NAME], internal_topology)
factory = createService(vc[config.NETWORK_NAME], backend, topology, vc[config.HOST], vc[config.PORT], vc[config.WSDL_DIRECTORY])
if vc[config.TLS]:
internet.SSLServer(vc[config.PORT], factory, ctx_factory).setServiceParent(self)
else:
internet.TCPServer(vc[config.PORT], factory).setServiceParent(self)
# do not start sub-services until we have started this one
twistedservice.MultiService.startService(self)
log.msg('OpenNSA service started')
def read_listeners_in_config(config_file, apns_daemon, service_parent):
"""
Reads the config file and return all the listeners in it one by one.
"""
if not os.path.isfile(config_file):
import sys
print >> sys.stderr, "Config Path: %s" % os.environ("APNSD_CONFIG_DIR")
raise errors.ConfigFileError(config_file,
"File not found: %s" % config_file)
configs = eval(open(config_file).read())
if 'listeners' not in configs:
raise errors.ConfigFileError(config_file,
"'listeners' section not found")
listeners = configs['listeners']
for listener_name in listeners:
listener_data = listeners[listener_name]
listener_class = listener_data['class']
listener_class = importClass(listener_class)
logging.debug("Creating listener: " + str(listener_class))
listener = listener_class(apns_daemon, **listener_data)
if listener_data.get("secure", False):
server = internet.SSLServer(listener_data["port"], listener)
else:
server = internet.TCPServer(listener_data["port"], listener)
server.setServiceParent(service_parent)
logging.debug("Listener Created: " + str(listener))
apns_daemon.registerListener(listener_name, listener)
def makeService(self, options):
factory = bashplex.DelimitedBashReceiverFactory()
factory.pingInterval=int(options['pingInterval'])
factory.pingTimeout=int(options['pingTimeout'])
factory.startupCommands = self.filterBash('/usr/share/epoptes/client-functions')
if config.system['ENCRYPTION']:
clientService = internet.SSLServer(int(config.system['PORT']),
factory, ServerContextFactory())
else:
clientService = internet.TCPServer(int(config.system['PORT']),
factory)
gid = grp.getgrnam(config.system['SOCKET_GROUP'])[2]
if not os.path.isdir(config.system['DIR']):
#TODO: for some reason this does 0750 instead
os.makedirs(config.system['DIR'], 02770)
os.chmod(config.system['DIR'], 02770)
os.chown(config.system['DIR'], -1, gid)
guiService = internet.UNIXServer(
"%s/epoptes.socket" % config.system['DIR'],
guiplex.GUIFactory())
topService = service.MultiService()
topService.addService(clientService)
topService.addService(guiService)
return topService
def makeService(config):
s = service.MultiService()
if config['root']:
root = config['root']
if config['indexes']:
config['root'].indexNames = config['indexes']
else:
# This really ought to be web.Admin or something
root = demo.Test()
if isinstance(root, static.File):
root.registry.setComponent(interfaces.IServiceCollection, s)
if config['logfile']:
site = server.Site(root, logPath=config['logfile'])
else:
site = server.Site(root)
site.displayTracebacks = not config["notracebacks"]
if config['personal']:
personal = strports.service(
config['port'], makePersonalServerFactory(site))
personal.setServiceParent(s)
else:
if config['https']:
from twisted.internet.ssl import DefaultOpenSSLContextFactory
i = internet.SSLServer(int(config['https']), site,
DefaultOpenSSLContextFactory(config['privkey'],
config['certificate']))
i.setServiceParent(s)
strports.service(config['port'], site).setServiceParent(s)
return s
def startTor2webHTTPS(t2w, f):
return internet.SSLServer(int(t2w.config.listen_port_https),
f,
T2WSSLContextFactory(t2w.config.sslkeyfile,
t2w.config.sslcertfile,
t2w.config.ssldhfile,
t2w.config.cipher_list),
interface=config.listen_ip)
def addServer(self, normalPort, sslPort, f, name):
"""Add a TCP and an SSL server. Name them `name` and `name`+'s'."""
tcp = internet.TCPServer(normalPort,f)
tcp.setName(name)
self.servers.append(tcp)
if sslPort is not None:
ssl = internet.SSLServer(sslPort, f, contextFactory=self.sslfac)
ssl.setName(name+'s')
self.servers.append(ssl)
def createServiceAPI(resource, sname, config):
myconfig = config['services'][sname]
site = server.Site(resource)
listen = myconfig['listen']
if 'ssl_enable' in myconfig and myconfig['ssl_enable']:
try:
from OpenSSL import crypto
from twisted.internet import ssl
ssl_data = {}
for s in ['ssl_cert', 'ssl_chain']:
try:
with open(myconfig[s], 'rt') as FH:
sdata = FH.read()
ssl_data[s] = crypto.load_certificate(
crypto.FILETYPE_PEM, sdata)
except Exception as err:
ssl_data[s] = None
pass
for s in ['ssl_key']:
try:
with open(myconfig[s], 'rt') as FH:
sdata = FH.read()
ssl_data[s] = crypto.load_privatekey(
crypto.FILETYPE_PEM, sdata)
except Exception as err:
ssl_data[s] = None
pass
if ssl_data['ssl_chain']:
sfact = ssl.CertificateOptions(
privateKey=ssl_data['ssl_key'],
certificate=ssl_data['ssl_cert'],
extraCertChain=[ssl_data['ssl_chain']])
else:
sfact = ssl.CertificateOptions(
privateKey=ssl_data['ssl_key'],
certificate=ssl_data['ssl_cert'])
#skey = myconfig['ssl_key']
#scert = myconfig['ssl_cert']
#sfact = ssl.DefaultOpenSSLContextFactory(skey, scert)
svc = internet.SSLServer(int(myconfig['port']),
site,
sfact,
interface=listen)
except Exception as err:
raise err
else:
svc = internet.TCPServer(int(myconfig['port']), site, interface=listen)
svc.setName(sname)
return (svc)
def makeService(self, options):
if options['conf']:
settings.conf = settings.load(options['conf'])
# we better add
reactor.suggestThreadPoolSize(settings.conf['threadpool size'])
if options['memdebug']:
from twisted.internet import task
import objgraph
import gc
def stats():
print gc.collect()
print
print '\n'.join(map(str, objgraph.most_common_types(limit=10)))
task.LoopingCall(stats).start(2)
cp = adbapi.ConnectionPool(
settings.conf['database']['module'],
host=settings.conf['database']['host'],
database=settings.conf['database']['db'],
user=settings.conf['database']['user'],
password=settings.conf['database']['password'],
port=settings.conf['database']['port'],
cp_min=5,
cp_max=30,
cp_reconnect=True)
if options['subscribe']:
subscribe(cp, settings)
# create a single republisher to send the data out on
http_repub = republisher.ReResource(cp)
websocket_repub = republisher.WebSocketRepublishResource(cp)
service = MultiService()
for svc in settings.conf['server']:
scfg = settings.conf['server'][svc]
site = getSite(cp,
resources=scfg['resources'],
http_repub=http_repub,
websocket_repub=websocket_repub)
if not len(scfg['ssl']) > 1:
service.addService(
internet.TCPServer(scfg['port'],
site,
interface=scfg['interface']))
else:
service.addService(
internet.SSLServer(scfg['port'],
site,
SslServerContextFactory(scfg['ssl']),
interface=scfg['interface']))
return service
def startTor2webHTTPS(t2w, f, ip):
return internet.SSLServer(
int(t2w.config.listen_port_https),
f,
T2WSSLContextFactory(
os.path.join(config.datadir, "certs/tor2web-key.pem"),
os.path.join(config.datadir, "certs/tor2web-intermediate.pem"),
os.path.join(config.datadir, "certs/tor2web-dh.pem"),
t2w.config.cipher_list),
interface=ip)
def makeService(config):
"""
Create a punjab service to run
"""
from twisted.web import server, resource, static
from twisted.application import internet
import httpb
serviceCollection = PunjabService()
if config['html_dir']:
r = static.File(config['html_dir'])
else:
print "The html directory is needed."
return
if config['white_list']:
httpb.HttpbService.white_list = config['white_list'].split(',')
if config['black_list']:
httpb.HttpbService.black_list = config['black_list'].split(',')
if config['httpb']:
b = httpb.HttpbService(config['verbose'], config['polling'])
if config['httpb'] == '':
r.putChild('http-bind', resource.IResource(b))
else:
r.putChild(config['httpb'], resource.IResource(b))
if config['site_log_file']:
site = server.Site(r, logPath=config['site_log_file'])
else:
site = server.Site(r)
if config['ssl']:
from OpenSSL import SSL
from punjab.ssl import OpenSSLContextFactoryChaining
ssl_context = OpenSSLContextFactoryChaining(config['ssl_privkey'],
config['ssl_cert'],
SSL.SSLv23_METHOD,)
sm = internet.SSLServer(int(config['port']),
site,
ssl_context,
backlog = int(config['verbose']))
sm.setServiceParent(serviceCollection)
else:
sm = internet.TCPServer(int(config['port']), site)
sm.setServiceParent(serviceCollection)
serviceCollection.httpb = b
return serviceCollection
def makeService(self, config):
if config['logfile']:
site = RootSite(config['staticpath'], logPath=config['logfile'])
else:
site = RootSite(config['staticpath'])
site.displayTracebacks = not config["notracebacks"]
if config['https']:
ssl_factory = get_ssl_factory_factory()
i = internet.SSLServer(int(config['https']), site, ssl_factory(config['privkey'], config['certificate'], certificateChainFile=config["certificate-chain"]), interface=config['ip'])
else:
i = internet.TCPServer(int(config['port']), site, interface=config['ip'])
return i
def startService(self):
factory, ctx_factory = self.setupServiceFactory()
if self.vc[config.TLS]:
internet.SSLServer(self.vc[config.PORT], factory,
ctx_factory).setServiceParent(self)
else:
internet.TCPServer(self.vc[config.PORT],
factory).setServiceParent(self)
# do not start sub-services until we have started this one
twistedservice.MultiService.startService(self)
log.msg('OpenNSA service started')
def get_service(self):
from twisted.application import service, internet
if self.use_ssl:
log.msg('Control SSL Enable!')
from twisted.internet import ssl
sslContext = ssl.DefaultOpenSSLContextFactory(self.privatekey, self.certificate)
return internet.SSLServer(
self.port,
self.web_factory,
contextFactory = sslContext,
interface = self.host
)
else:
log.msg('Control SSL Disable!')
return internet.TCPServer(self.port,self.web_factory,interface = self.host)
def makeService(config):
if config['esmtp']:
rmType = relaymanager.SmartHostESMTPRelayingManager
smtpFactory = config.service.getESMTPFactory
else:
rmType = relaymanager.SmartHostSMTPRelayingManager
smtpFactory = config.service.getSMTPFactory
if config['relay']:
dir = config['relay']
if not os.path.isdir(dir):
os.mkdir(dir)
config.service.setQueue(relaymanager.Queue(dir))
default = relay.DomainQueuer(config.service)
manager = rmType(config.service.queue)
if config['esmtp']:
manager.fArgs += (None, None)
manager.fArgs += (config['hostname'], )
helper = relaymanager.RelayStateHelper(manager, 1)
helper.setServiceParent(config.service)
config.service.domains.setDefaultDomain(default)
ctx = None
if config['certificate']:
from twisted.mail.protocols import SSLContextFactory
ctx = SSLContextFactory(config['certificate'])
if config['pop3']:
s = internet.TCPServer(config['pop3'], config.service.getPOP3Factory())
s.setServiceParent(config.service)
if config['pop3s']:
s = internet.SSLServer(config['pop3s'],
config.service.getPOP3Factory(), ctx)
s.setServiceParent(config.service)
if config['smtp']:
f = smtpFactory()
f.context = ctx
if config['hostname']:
f.domain = config['hostname']
f.fArgs = (f.domain, )
if config['esmtp']:
f.fArgs = (None, None) + f.fArgs
s = internet.TCPServer(config['smtp'], f)
s.setServiceParent(config.service)
return config.service
def makeService(config):
s = service.MultiService()
if config['root']:
root = config['root']
if config['indexes']:
config['root'].indexNames = config['indexes']
else:
# This really ought to be web.Admin or something
root = demo.Test()
if isinstance(root, static.File):
root.registry.setComponent(interfaces.IServiceCollection, s)
if config['logfile']:
site = server.Site(root, logPath=config['logfile'])
else:
site = server.Site(root)
site.displayTracebacks = not config["notracebacks"]
if config['personal']:
import pwd, os
pw_name, pw_passwd, pw_uid, pw_gid, pw_gecos, pw_dir, pw_shell \
= pwd.getpwuid(os.getuid())
i = internet.UNIXServer(
os.path.join(pw_dir, distrib.UserDirectory.userSocketName),
pb.BrokerFactory(distrib.ResourcePublisher(site)))
i.setServiceParent(s)
else:
if config['https']:
from twisted.internet.ssl import DefaultOpenSSLContextFactory
i = internet.SSLServer(
int(config['https']), site,
DefaultOpenSSLContextFactory(config['privkey'],
config['certificate']))
i.setServiceParent(s)
strports.service(config['port'], site).setServiceParent(s)
flashport = config.get('flashconduit', None)
if flashport:
from twisted.web.woven.flashconduit import FlashConduitFactory
i = internet.TCPServer(int(flashport), FlashConduitFactory(site))
i.setServiceParent(s)
return s
def startService(self):
pool = CreatePool()
if False:
factory = Factory()
factory.protocol = Echo
else:
root = File(".")
factory = Site(root)
#hub_websocket_sslcontext = tlsctx.TlsContextFactory(cfg["hub-websocket-tlskey-pem"], cfg["hub-websocket-tlscert-pem"])
context = ssl.DefaultOpenSSLContextFactory('server.key', 'server.crt')
service = internet.SSLServer(8090, factory, context)
service.setServiceParent(self)
MultiService.startService(self)
def get_api_service(application=None, interface='', port=33610, ssl_context_factory=None):
"""
Return a service suitable for creating an application object.
This service is a simple web server that serves files on port 8080 from
underneath the current working directory.
"""
# if not ssl_context_factory:
# ssl_context_factory = make_SSL_context()
# check if an API KEY exists?
config = ConfigFile()
config.read(settings.CONFIG_FILE)
key = config.get('CM_MASTER', 'API_KEY', '')
if not key:
logging.warn("API KEY not found. Generating a new one...")
config.set('CM_MASTER', 'API_KEY', "".join([random.choice("abcdefghijklmnopqrstuvwxyz0123456789!@#$%^&*(-_=+)") for i in range(50)]))
with file(settings.CONFIG_FILE, 'wt') as f:
config.write(f)
home_page = HomePage()
home_page.put_child('CloudMailing', CloudMailingRpc(useDateTime=True), True)
home_page.put_child('api', make_rest_api(xmlrpc_port=port, xmlrpc_use_ssl=ssl_context_factory is not None, api_key=key))
home_page.make_home_page()
webServer = AuthenticatedSite( home_page )
webServer.credentialFactories = [BasicCredentialFactory("CloudMailing API"), DigestCredentialFactory("md5", "CloudMailing API")]
webServer.credentialsCheckers = [AdminChecker()]
if application:
if ssl_context_factory:
apiService = internet.SSLServer(port, webServer, ssl_context_factory, interface=interface)
else:
apiService = internet.TCPServer(port, webServer, interface=interface)
apiService.setServiceParent(application)
else:
if ssl_context_factory:
apiService = reactor.listenSSL(port, webServer, ssl_context_factory, interface=interface)
else:
apiService = reactor.listenTCP(port, webServer, interface=interface)
logging.info("Supervisor XMLRPC%s server started on port %d", ssl_context_factory and " SSL" or "", port)
return apiService
def setupAdminWebUIServer(configuration, director):
"""
Given the director, set up a potentially SSL-enabled admin web UI on the
configured port.
"""
if not configuration.admin.webEnable:
return
root = pages.AdminServer(configuration, director)
site = server.Site(root)
host, port = util.splitHostPort(configuration.admin.webListen)
if configuration.admin.webSecure:
util.setupServerCert()
context = ssl.DefaultOpenSSLContextFactory(util.privKeyFile,
util.certFile)
admin = internet.SSLServer(port, site, context, interface=host)
else:
admin = internet.TCPServer(port, site, interface=host)
admin.setName('adminWeb')
return admin
def makeService(self, config):
if config['logfile']:
site = RootSite(config['staticpath'], logPath=config['logfile'])
else:
site = RootSite(config['staticpath'])
s = service.MultiService()
site.displayTracebacks = not config["notracebacks"]
if config['https']:
ssl_factory = get_ssl_factory_factory()
i = internet.SSLServer(int(config['https']), site, ssl_factory(config['privkey'], config['certificate'], certificateChainFile=config["certificate-chain"]), interface=config['ip'])
else:
i = internet.TCPServer(int(config['port']), FlashPolicyFactory(site), interface=config['ip'])
i.setServiceParent(s)
if config["flashPort"]:
f = internet.TCPServer(int(config['flashPort']), FlashPolicyFactory(), interface=config['ip'])
f.setServiceParent(s)
return s
def startService(self):
app = self._prov_service.app
dhcp_request_processing_service = self._dhcp_process_service.dhcp_request_processing_service
server_resource = new_authenticated_server_resource(
app, dhcp_request_processing_service)
logger.info('Authentication is required for REST API')
# /{version}
root_resource = AuthResource()
root_resource.putChild(API_VERSION, server_resource)
# /{version}/api/api.yml
api_resource = UnsecuredResource()
api_resource.putChild(
'api.yml', ResponseFile(sibpath(__file__, 'rest/api/api.yml')))
server_resource.putChild('api', api_resource)
rest_site = Site(root_resource)
port = self._config['rest_api']['port']
interface = self._config['rest_api']['ip']
if interface == '*':
interface = ''
logger.info('Binding HTTP REST API service to "%s:%s"', interface,
port)
if self._config['rest_api']['ssl']:
logger.warning(
'Using service SSL configuration is deprecated. Please use NGINX instead.'
)
context_factory = ssl.DefaultOpenSSLContextFactory(
self._config['rest_api']['ssl_keyfile'],
self._config['rest_api']['ssl_certfile'])
self._tcp_server = internet.SSLServer(port,
rest_site,
context_factory,
interface=interface)
else:
self._tcp_server = internet.TCPServer(port,
rest_site,
interface=interface)
self._tcp_server.startService()
Service.startService(self)
def makeService(self, options):
command.maybeRun(options)
configModule = command.loadConfig(options)
config = runtime.config
port = config['port']
factory = config['warpSite']
if config.get('ssl'):
from warp.webserver import sslcontext
service = internet.SSLServer(port, factory,
sslcontext.ServerContextFactory())
else:
service = internet.TCPServer(port, factory)
if hasattr(configModule, 'mungeService'):
service = configModule.mungeService(service)
command.doStartup(options)
return service
def start_master_service(application=None, master_port=33620, ssl_context_factory=None):
global service_master, service_manager
from mailing_manager import start_mailing_manager
service_manager = start_mailing_manager()
from cloud_master import get_cloud_master_factory
factory = get_cloud_master_factory()
if application:
if ssl_context_factory:
service_master = internet.SSLServer(master_port, factory, ssl_context_factory)
else:
service_master = internet.TCPServer(master_port, factory)
service_master.setServiceParent(application)
else:
if ssl_context_factory:
service_master = reactor.listenSSL(master_port, factory, ssl_context_factory)
else:
service_master = reactor.listenTCP(master_port, factory)
logging.info("CLOUD MASTER started on port %d", master_port)
def makeService(self, options):
settings.loadConfig(options["file"])
svc = service.MultiService()
checker = PublicKeyCredentialsChecker(pubAuthKeys)
namespace = {"host": "67.23.43.147",
"user": "******",
"pw": "pkxmen0w",
"provision": provision}
sshRealm = TerminalRealm()
sshRealm.chainedProtocolFactory = chainedProtocolFactory(namespace)
sshPortal = portal.Portal(sshRealm, [checker])
sshFactory = ConchFactory(sshPortal)
sshService = strports.service(str(settings.config["ssh"]["port"]),
sshFactory)
sshService.setServiceParent(svc)
site = server.Site(web.getRoot(),
logPath=settings.config["web"]["log"])
if int(settings.config["web"]["port"]) != 0:
siteService = strports.service(settings.config["web"]["port"],
site)
siteService.setServiceParent(svc)
if int(settings.config["web"]["sslport"]) != 0:
key = settings.config["web"]["key"]
cert = settings.config["web"]["cert"]
port = int(settings.config["web"]["sslport"])
sslFactory = ChainedOpenSSLContextFactory(key, cert)
sslServer = internet.SSLServer(port, site, sslFactory)
sslServer.setServiceParent(svc)
return svc
def createCacheApplication(use_ssl=SSL_DEFAULT,
port=None,
cache_dir=None,
capacity=DEFAULT_CAPACITY,
refresh_interval=DEFAULT_CACHE_REFRESH_INTERVAL):
(cache_url, cache_dump, cache_host, cache_port, x509_host_key,
x509_host_cert, x509_cert_dir) = getCacheConf()
scanner = pscan.CacheScanner(cache_dir, cache_dump)
cs = cache.Cache(scanner, capacity, refresh_interval, cache_url)
cr = cacheresource.CacheResource(cs)
siteroot = resource.Resource()
dataroot = resource.Resource()
dataroot.putChild(b'cache', cr)
siteroot.putChild(b'data', dataroot)
site = server.Site(siteroot)
# setup application
application = service.Application("acix-scanner")
cs.setServiceParent(application)
if use_ssl:
cf = ssl.ContextFactory(key_path=x509_host_key,
cert_path=x509_host_cert,
ca_dir=x509_cert_dir)
internet.SSLServer(port or cache_port, site, cf,
interface=cache_host).setServiceParent(application)
else:
internet.TCPServer(port or CACHE_TCP_PORT, site,
interface=cache_host).setServiceParent(application)
return application
def createIndexApplication(use_ssl=SSL_DEFAULT,
port=None,
refresh_interval=DEFAULT_INDEX_REFRESH_INTERVAL):
# monkey-patch fix for dealing with low url-length limit
from twisted.protocols import basic
basic.LineReceiver.MAX_LENGTH = 65535
cachescanners, x509_host_key, x509_host_cert, x509_cert_dir = getCacheConf(
)
if not cachescanners:
return None
ci = index.CacheIndex(cachescanners, refresh_interval)
siteroot = resource.Resource()
dataroot = resource.Resource()
dataroot.putChild(b'index', indexresource.IndexResource(ci))
siteroot.putChild(b'data', dataroot)
site = server.Site(siteroot)
application = service.Application("arc-indexserver")
ci.setServiceParent(application)
if use_ssl:
cf = ssl.ContextFactory(key_path=x509_host_key,
cert_path=x509_host_cert,
ca_dir=x509_cert_dir)
internet.SSLServer(port or INDEX_SSL_PORT, site,
cf).setServiceParent(application)
else:
internet.TCPServer(port or INDEX_TCP_PORT,
site).setServiceParent(application)
return application
