def connect(self, network): """ connect to the network @ivar network: the name of the network to connect to as used in the config gets the servername and port from config, and then connects to the network. """ f = BotFactory(self.root, self, network) sname = self.config.get("server", "localhost", "main", network) port = int(self.config.get('port', 6667, 'main', network)) bindaddress = self.config.get('bind', None, 'main', network) if bindaddress: bindaddress=(bindaddress, 0) if (self.config.getBool('ssl', False, 'main', network)): s = ssl.ClientContextFactory() serv = internet.SSLClient(host=sname, port=port, factory=f, bindAddress=bindaddress, contextFactory=s) repr = "<IRC Connection with SSL to %s:%s>" serv.__repr__ = lambda: repr % (sname, port) serv.factory=f else: serv = internet.TCPClient(host=sname, port=port, bindAddress=bindaddress, factory=f) serv.__repr__ = lambda: "<IRC Connection to %s:%s>" % (sname, port) serv.factory=f f.service = serv serv.setName(network) serv.parent = self #if the connect is invoced via control-service, #set the network to enabled. if not, its enabled anyway self.config.set('enabled', True, 'main', network) self.addService(serv)
def __init__(self, host, nick, channels, pm_to_nicks=[], port=6667, allowForce=False, categories=None, password=None, notify_events={}, noticeOnChannel=False, showBlameList=True, useRevisions=False, useSSL=False, lostDelay=None, failedDelay=None, useColors=True, allowShutdown=False): base.StatusReceiverMultiService.__init__(self) assert allowForce in (True, False) # TODO: implement others assert allowShutdown in (True, False) # need to stash these so we can detect changes later self.host = host self.port = port self.nick = nick self.channels = channels self.pm_to_nicks = pm_to_nicks self.password = password self.allowForce = allowForce self.useRevisions = useRevisions self.categories = categories self.notify_events = notify_events self.allowShutdown = allowShutdown self.f = IrcStatusFactory(self.nick, self.password, self.channels, self.pm_to_nicks, self.categories, self.notify_events, noticeOnChannel=noticeOnChannel, useRevisions=useRevisions, showBlameList=showBlameList, lostDelay=lostDelay, failedDelay=failedDelay, useColors=useColors, allowShutdown=allowShutdown) if useSSL: # SSL client needs a ClientContextFactory for some SSL mumbo-jumbo if not have_ssl: raise RuntimeError("useSSL requires PyOpenSSL") cf = ssl.ClientContextFactory() c = internet.SSLClient(self.host, self.port, self.f, cf) else: c = internet.TCPClient(self.host, self.port, self.f) c.setServiceParent(self)
def make_plugin(config, http=None): irc_config = IrcConfig(config) dispatcher = Dispatcher() channel_manager = ChannelManager(irc_config.channels, dispatcher) # add the http resources if http: http.root.putChild('message', MessageListener(http, dispatcher)) topic_root = resource.Resource() http.root.putChild('topic', topic_root) topic_root.putChild('set', SetTopicListener(http, dispatcher)) # configure the default irc commands p = IrcPlugin() p.register_command(who) p.register_command(debug) # set up the IRC client irc_factory = IRCBotFactory(p, irc_config, dispatcher, channel_manager) p.config = irc_config p.bot = dispatcher p.channels = channel_manager if irc_config: context_factory = ssl.ClientContextFactory() p.add_service( internet.SSLClient(irc_config.host, irc_config.port, irc_factory, context_factory)) else: p.add_service( internet.TCPClient(irc_config.host, irc_config.port, irc_factory)) return p
def reconfigService(self, host, nick, channels, pm_to_nicks=None, port=6667, allowForce=None, tags=None, password=None, notify_events=None, showBlameList=True, useRevisions=False, useSSL=False, lostDelay=None, failedDelay=None, useColors=True, allowShutdown=None, noticeOnChannel=False, authz=None, **kwargs ): # need to stash these so we can detect changes later self.host = host self.port = port self.nick = nick self.join_channels = channels if pm_to_nicks is None: pm_to_nicks = [] self.pm_to_nicks = pm_to_nicks self.password = password if authz is None: self.authz = {} else: self.authz = authz self.useRevisions = useRevisions self.tags = tags if notify_events is None: notify_events = {} self.notify_events = notify_events self.noticeOnChannel = noticeOnChannel # deprecated... if allowForce is not None: self.authz[('force', 'stop')] = allowForce if allowShutdown is not None: self.authz[('shutdown')] = allowShutdown # ### # This function is only called in case of reconfig with changes # We don't try to be smart here. Just restart the bot if config has # changed. if self.f is not None: self.f.shutdown() self.f = IrcStatusFactory(self.nick, self.password, self.join_channels, self.pm_to_nicks, self.authz, self.tags, self.notify_events, parent=self, noticeOnChannel=noticeOnChannel, useRevisions=useRevisions, showBlameList=showBlameList, lostDelay=lostDelay, failedDelay=failedDelay, useColors=useColors) if useSSL: cf = ssl.ClientContextFactory() c = internet.SSLClient(self.host, self.port, self.f, cf) else: c = internet.TCPClient(self.host, self.port, self.f) c.setServiceParent(self)
def __init__(self, host, nick, channels, pm_to_nicks=[], port=6667, allowForce=False, categories=None, password=None, notify_events={}, noticeOnChannel=False, showBlameList=True, useRevisions=False, useSSL=False, lostDelay=None, failedDelay=None, useColors=True): # XXX replace method - use class in the factory variable StatusReceiverMultiService.__init__(self) assert allowForce in (True, False) self.host = host self.port = port self.nick = nick self.channels = channels self.pm_to_nicks = pm_to_nicks self.password = password self.allowForce = allowForce self.useRevisions = useRevisions self.categories = categories self.notify_events = notify_events self.f = self.factory(self.nick, self.password, self.channels, self.pm_to_nicks, self.categories, self.notify_events, noticeOnChannel=noticeOnChannel, useRevisions=useRevisions, showBlameList=showBlameList, lostDelay=lostDelay, failedDelay=failedDelay, useColors=useColors) if useSSL: if not have_ssl: raise RuntimeError("useSSL requires PyOpenSSL") from twisted.internet import ssl cf = ssl.ClientContextFactory() c = internet.SSLClient(self.host, self.port, self.f, cf) else: c = internet.TCPClient(self.host, self.port, self.f) c.setServiceParent(self)
def connectSSL(self, host, port, factory, ctxFactory, timeout=30, bindAddress=None): s = internet.SSLClient(host, port, factory, ctxFactory, timeout, bindAddress) s.setServiceParent(self.app)
def __init__(self, config, services): self.files = [] self.irc = None self.services = services internet.SSLClient( LOGBOT_LOCATION, LOGBOT_PORT, LogBotFactory(self), ssl.ClientContextFactory()).setServiceParent(services) self.mods = mods.ModManager(self, config) self.mods.handleEvent("LOAD")
def __init__(self, host, nick, channels, port=6667, allowForce=False, categories=None, password=None, notify_events={}, noticeOnChannel=False, showBlameList=True, useRevisions=False, useSSL=False, lostDelay=None, failedDelay=None): base.StatusReceiverMultiService.__init__(self) assert allowForce in (True, False) # TODO: implement others # need to stash these so we can detect changes later self.host = host self.port = port self.nick = nick self.channels = channels self.password = password self.allowForce = allowForce self.useRevisions = useRevisions self.categories = categories self.notify_events = notify_events log.msg('Notify events %s' % notify_events) self.f = IrcStatusFactory(self.nick, self.password, self.channels, self.categories, self.notify_events, noticeOnChannel=noticeOnChannel, useRevisions=useRevisions, showBlameList=showBlameList, lostDelay=lostDelay, failedDelay=failedDelay) # don't set up an actual ClientContextFactory if we're running tests. if self.in_test_harness: return if useSSL: # SSL client needs a ClientContextFactory for some SSL mumbo-jumbo if not have_ssl: raise RuntimeError("useSSL requires PyOpenSSL") cf = ssl.ClientContextFactory() c = internet.SSLClient(self.host, self.port, self.f, cf) else: c = internet.TCPClient(self.host, self.port, self.f) c.setServiceParent(self)
def makeService(self, options): """ Construct the talkbackbot TCP client """ if settings.USE_SSL: bot = internet.SSLClient(settings.HOST, settings.PORT, TalkBackBotFactory(settings), ssl.ClientContextFactory()) else: bot = internet.TCPClient(settings.HOST, settings.PORT, TalkBackBotFactory(settings)) return bot
def __init__(self, host, nick, channels, pm_to_nicks=[], port=6667, allowForce=False, tags=None, password=None, notify_events={}, showBlameList=True, useRevisions=False, useSSL=False, lostDelay=None, failedDelay=None, useColors=True, allowShutdown=False, **kwargs ): base.StatusReceiverMultiService.__init__(self) deprecated_params = kwargs.keys() if deprecated_params: config.error("%s are deprecated" % (",".join(deprecated_params))) if allowForce not in (True, False): config.error("allowForce must be boolean, not %r" % (allowForce,)) if allowShutdown not in (True, False): config.error("allowShutdown must be boolean, not %r" % (allowShutdown,)) # need to stash these so we can detect changes later self.host = host self.port = port self.nick = nick self.channels = channels self.pm_to_nicks = pm_to_nicks self.password = password self.allowForce = allowForce self.useRevisions = useRevisions self.tags = tags self.notify_events = notify_events self.allowShutdown = allowShutdown self.f = IrcStatusFactory(self.nick, self.password, self.channels, self.pm_to_nicks, self.tags, self.notify_events, useRevisions=useRevisions, showBlameList=showBlameList, lostDelay=lostDelay, failedDelay=failedDelay, useColors=useColors, allowShutdown=allowShutdown) if useSSL: # SSL client needs a ClientContextFactory for some SSL mumbo-jumbo if not have_ssl: raise RuntimeError("useSSL requires PyOpenSSL") cf = ssl.ClientContextFactory() c = internet.SSLClient(self.host, self.port, self.f, cf) else: c = internet.TCPClient(self.host, self.port, self.f) c.setServiceParent(self)
def reconfigService(self, host, nick, channels, pm_to_nicks=None, port=6667, allowForce=False, tags=None, password=None, notify_events=None, showBlameList=True, useRevisions=False, useSSL=False, lostDelay=None, failedDelay=None, useColors=True, allowShutdown=False, **kwargs ): # need to stash these so we can detect changes later self.host = host self.port = port self.nick = nick self.channels = channels if pm_to_nicks is None: pm_to_nicks = [] self.pm_to_nicks = pm_to_nicks self.password = password self.allowForce = allowForce self.useRevisions = useRevisions self.tags = tags if notify_events is None: notify_events = {} self.notify_events = notify_events self.allowShutdown = allowShutdown # This function is only called in case of reconfig with changes # We don't try to be smart here. Just restart the bot if config has # changed. if self.f is not None: self.f.shutdown() self.f = IrcStatusFactory(self.nick, self.password, self.channels, self.pm_to_nicks, self.tags, self.notify_events, parent=self, useRevisions=useRevisions, showBlameList=showBlameList, lostDelay=lostDelay, failedDelay=failedDelay, useColors=useColors, allowShutdown=allowShutdown) if useSSL: # SSL client needs a ClientContextFactory for some SSL mumbo-jumbo if not have_ssl: raise RuntimeError("useSSL requires PyOpenSSL") cf = ssl.ClientContextFactory() c = internet.SSLClient(self.host, self.port, self.f, cf) else: c = internet.TCPClient(self.host, self.port, self.f) c.setServiceParent(self)
def connect(self): f = PikaFactory(self.parameters) if self.parameters.ssl: s = ssl.ClientContextFactory() serv = internet.SSLClient(host=self.parameters.host, port=self.parameters.port, factory=f, contextFactory=s) else: serv = internet.TCPClient(host=self.parameters.host, port=self.parameters.port, factory=f) serv.factory = f f.service = serv name = '%s%s:%d' % ('ssl:' if self.parameters.ssl else '', self.parameters.host, self.parameters.port) serv.__repr__ = lambda : '<AMQP Connection to %s>' % name serv.setName(name) serv.parent = self self.addService(serv)
def setServiceParent(self, service): if self.ssl: sslctx = ssl.ClientContextFactory() if service: internet.SSLClient(self.server, self.port, self, sslctx).setServiceParent(service) else: reactor.connectSSL(self.server, self.port, self, sslctx) else: if service: internet.TCPClient(self.server, self.port, self).setServiceParent(service) else: reactor.connectTCP(self.server, self.port, self)
def __init__(self, highscore, config): base.Plugin.__init__(self, highscore, config) self.factory = IrcFactory(highscore, config) hostname = self.config.plugins.irc.get('hostname') assert hostname, 'no irc hostname supplied' port = self.config.plugins.irc.get('port', 6667) if self.config.plugins.irc.get('useSSL'): if not have_ssl: raise RuntimeError("useSSL requires PyOpenSSL") cf = ssl.ClientContextFactory() self.conn = internet.SSLClient(hostname, port, self.factory, cf) else: self.conn = internet.TCPClient(hostname, port, self.factory) self.conn.setServiceParent(self)
def makeService(config): # finger on port 79 msvc = service.MultiService() fix_spec = Spec(config['spec']) fix_service = FixClientService(config) fix_service.setName('txfixclient') fix_service.setServiceParent(msvc) factory = FixClientFactory(fix_service) factory.spec = fix_spec factory.maxDelay = 300 tcp_service = internet.SSLClient(config['hostname'], int(config['port']), factory, ssl.ClientContextFactory()) tcp_service.setServiceParent(msvc) return msvc
def connect(self): """ connect to the network @ivar network: the name of the network to connect to as used in the config gets the servername and port from config, and then connects to the network. """ __spec_file = "otfbot/services/amqp0-8.stripped.rabbitmq.xml" __vhost = self.config.get("vhost", "/", self.name) __user = self.config.get("user", "guest", self.name) __password = self.config.get("password", "guest", self.name) f = AmqpFactory(self.root, self.parent, __spec_file, __vhost, __user, __password) __ssl = self.config.getBool("ssl", False, self.name) __host = self.config.get("host", "localhost", self.name) __port = int(self.config.get("port", 5672, self.name)) if __ssl: s = ssl.ClientContextFactory() serv = internet.SSLClient(host=__host, port=__port, factory=f, contextFactory=s) repr = "<AMQP Connection with SSL to %s:%s>" serv.__repr__ = lambda: repr % (__host, __port) serv.factory = f else: serv = internet.TCPClient(host=__host, port=__port, factory=f) serv.__repr__ = lambda: "<AMQP Connection to %s:%s>" % (__host, __port) serv.factory = f f.service = serv serv.setName("amqp") serv.parent = self print("connecting signals") f.read("otfbot", "otfbot", self.handle_command) self.addService(serv)
def start_satellite_service(application=None, master_ip='localhost', master_port=33620, ssl_context_factory=None): global service_satellite ##Services from cloud_client import get_cloud_client_factory factory = get_cloud_client_factory() log.info('Trying to connect to Master on %s:%d' % (master_ip, master_port)) if application: if ssl_context_factory: service_satellite = internet.SSLClient(master_ip, master_port, factory, ssl_context_factory) else: service_satellite = internet.TCPClient(master_ip, master_port, factory) service_satellite.setServiceParent(application) else: if ssl_context_factory: service_satellite = reactor.connectSSL(master_ip, master_port, factory, ssl_context_factory) else: service_satellite = reactor.connectTCP(master_ip, master_port, factory)
def make_plugin(config, http=None): irc_config = IrcConfig(config) dispatcher = Dispatcher() # configure the default irc commands p = IrcPlugin() p.register_command(who) p.register_command(debug) # set up the IRC client irc_factory = IRCBotFactory(p, irc_config, dispatcher) p.bot = dispatcher if irc_config.use_ssl: context_factory = ssl.ClientContextFactory() p.add_service( internet.SSLClient(irc_config.host, irc_config.port, irc_factory, context_factory)) else: p.add_service( internet.TCPClient(irc_config.host, irc_config.port, irc_factory)) return p
def connect(self): f = PikaFactory(self.parameters) if self.parameters.ssl_options: s = ssl.ClientContextFactory() serv = internet.SSLClient( # pylint: disable=E1101 host=self.parameters.host, port=self.parameters.port, factory=f, contextFactory=s) else: serv = internet.TCPClient( # pylint: disable=E1101 host=self.parameters.host, port=self.parameters.port, factory=f) serv.factory = f f.service = serv # pylint: disable=W0201 name = '%s%s:%d' % ('ssl:' if self.parameters.ssl_options else '', self.parameters.host, self.parameters.port) serv.__repr__ = lambda: '<AMQP Connection to %s>' % name serv.setName(name) serv.setServiceParent(self)
def makeService(options): from twisted.names.client import getResolver resolver = getResolver() # HACK: I want a better resolver than the threaded one, and lack a # non-terrible place to install it. from twisted.internet import reactor if not options['keep-resolver']: # pragma: no cover reactor.installResolver(resolver) # HACK: warn about suboptimal reactor usage if not options['force-select']: # pragma: no cover from twisted.internet import selectreactor if isinstance(reactor, selectreactor.SelectReactor): print('The select reactor is probably a bad idea.') print('Please use a reactor with better support for lots of fds.') print('(-r epoll for example)') print('You can bypass this check using --force-select') print() raise ValueError('unfortunate reactor choice') m = service.MultiService() checkerFactories = plugin.getCheckerFactories() default_user_reason = options['conf'].get('user-reason', '') default_oper_reason = options['conf'].get('oper-reason', '') scansets = {} for name, d in options['conf']['scansets'].items(): scans = [] for args in d['protocols']: poolname = args.pop(0) checkername = args.pop(0) checker = checkerFactories[checkername](*args) scans.append((poolname, checker.check)) user_reason = d.get('user-reason', default_user_reason) oper_reason = d.get('oper-reason', default_oper_reason) scansets[name] = scanner.ScanSet(d['timeout'], scans, user_reason, oper_reason) # XXXX the target_blah passing here is horrible, but I intend to # make this less global in the future anyway, so laaaaaaaaater env = {} for k in [ 'target_ip', 'target_port', 'target_url', 'target_strings', 'max_bytes', 'bind_address' ]: env[k] = options['conf'].get(k) theScanner = scanner.Scanner(reactor, resolver, options['conf']['pools'], scansets, env) for name, net in options['conf'].get('irc', {}).items(): # XXX terrible, see also similar complaints in ircpresence. # Split this up later. factory = ircpresence.Factory( net['nick'], net['channel'], password=net.get('pass'), opername=net.get('opername', net['nick']), operpass=net.get('operpass'), operkey=net.get('operkey'), opermode=net.get('opermode'), away=net.get('away'), connregex=net.get('connregex'), scanner=theScanner, masks=options['conf'].get('masks', {}), actions=net.get('actions'), onconnectmsgs=net.get('onconnectmsgs', ()), verbose=options['irc-log'], flood_exempt=net.get('flood_exempt', False), username=net.get('username'), cache_time=net.get("scan-cache-time", 120), cache_size=net.get("scan-cache-size", 1_000_000)) if net.get('ssl', False): ctxf = ssl.ClientContextFactory() serv = internet.SSLClient(net['host'], net['port'], factory, ctxf) else: serv = internet.TCPClient(net['host'], net['port'], factory) serv.setName(name) serv.setServiceParent(m) return m
from janecore.ircbot.service import JaneIRCService, AnsibleService from janecore.ircbot.ansible.factory import AnsibleFactory from config import config parent_service = service.MultiService() # TODO: add service controls via janecore.service #jane_service = JaneIRCService() #jane_service.setServiceParent(parent_service) factory = JaneIRCClientFactory(config["ircUserName"], config["ircNick"], config["ircPassword"], config["ircDefaultChannels"]) if config["ircServerSSL"]: ssl_context_factory = ssl.ClientContextFactory() irc_client_service = internet.SSLClient(config["ircServer"], config["ircPort"], factory, ssl_context_factory) else: irc_client_server = internet.TCPClient(config["ircServer"], config["ircPort"], factory) irc_client_service.setServiceParent(parent_service) application = service.Application("Jane") parent_service.setServiceParent(application) #ansible_service = AnsibileService() #ansible_service = setServiceParent(parent_service) if config["ansibleEnabled"] and config["ansibleSSL"]: ansible_factory = AnsibleFactory() ctx = ssl.DefaultOpenSSLContextFactory(config["ansibleSSLKey"], config["ansibleSSLCert"])
def makeService(options): # primary setup application = service.Application(meta.display_name) services = service.IServiceCollection(application) # setup message server serverFactory = ServerFactory() serverFactory.protocol = Listener serverFactory.publisher = PublisherFactory() msgServer = internet.TCPServer(config.listener.port, serverFactory) msgServer.setName(config.listener.servicename) msgServer.setServiceParent(services) # setup IRC message client if config.irc.sslEnabled: msgService = internet.SSLClient(config.irc.server, config.irc.port, serverFactory.publisher, ClientContextFactory()) else: msgService = internet.TCPClient(config.irc.server, config.irc.port, serverFactory.publisher) msgService.setName(config.irc.servicename) msgService.setServiceParent(services) # setup IRC log client logger = LoggerFactory(config.irc.server, config.log.channels) logService = internet.TCPClient(config.irc.server, config.irc.port, logger) logService.setName(config.log.servicename) logService.setServiceParent(services) # setuplog rotator rotService = internet.TimerService(config.log.rotate.checkInterval, logger.rotateLogs, logService) rotService.setName(config.log.rotate.servicename) rotService.setServiceParent(services) # setup log file web server webroot = static.File(config.log.http.docRoot) if config.log.http.vhostEnabled: vResource = vhost.VHostMonsterResource() webroot.putChild('vhost', vResource) if config.log.http.auth == 'basic': guarded = auth.guardResourceWithBasicAuth(webroot, config.log.http.realm, config.log.http.users) site = server.Site(guarded) else: site = server.Site(webroot) webserver = internet.TCPServer(config.log.http.port, site) webserver.setName(config.log.http.servicename) webserver.setServiceParent(services) # setup ssh access to a Python shell interpreterType = dreamssh_const.PYTHON sshFactory = getShellFactory(interpreterType, app=application, services=services) sshserver = internet.TCPServer(config.ssh.port, sshFactory) sshserver.setName(config.ssh.servicename) sshserver.setServiceParent(services) return services
def makeService(self, options): """ Create an instance of PyTIBot """ config = YamlConfig(path=fs.config_file(options["config"])) if not (config["Connection"] and all([ config["Connection"].get(option, False) for option in mandatory_settings ])): raise EnvironmentError("Reading config file failed, mandatory" " fields not set!\nPlease reconfigure") mService = MultiService() # irc client ircserver = config["Connection"]["server"] ircsslport = config["Connection"].get("sslport", None) ircport = config["Connection"].get("port", None) ircbotfactory = PyTIBotFactory(config) if ircsslport: irc_cl = internet.SSLClient(ircserver, ircsslport, ircbotfactory, ssl.ClientContextFactory()) elif ircport: irc_cl = internet.TCPClient(ircserver, ircport, ircbotfactory) else: raise EnvironmentError("Neither sslport nor port are given for " "the irc connection!\nPlease reconfigure") irc_cl.setServiceParent(mService) # manhole for debugging if config["Manhole"]: telnetPort = config.Manhole.get("telnetport", None) if telnetPort: telnetPort = "tcp:{}".format(telnetPort) sshPort = config.Manhole.get("sshport", None) sshKeyDir = config.Manhole.get("sshKeyDir", "<USER DATA DIR>") sshKeyName = config.Manhole.get("sshKeyName", "server.key") sshKeySize = config.Manhole.get("sshKeySize", 4096) if sshPort: sshPort = "ssl:{}".format(sshPort) options = { 'namespace': { 'get_bot': ircbotfactory.get_bot }, 'passwd': os.path.join(fs.adirs.user_config_dir, 'manhole_cred'), 'sshPort': sshPort, 'sshKeyDir': sshKeyDir, 'sshKeyName': sshKeyName, 'sshKeySize': sshKeySize, 'telnetPort': telnetPort } tn_sv = manhole_tap.makeService(options) tn_sv.setServiceParent(mService) if (config["HTTPLogServer"] and ("port" in config["HTTPLogServer"] or "sshport" in config["HTTPLogServer"])): channels = config["HTTPLogServer"]["channels"] if not isinstance(channels, list): channels = [channels] if len(channels) == 1: title = config["HTTPLogServer"].get("title", "PyTIBot Log Server") search_pagelen = config["HTTPLogServer"].get( "search_pagelen", 5) indexer_procs = config["HTTPLogServer"].get("indexer_procs", 1) root = LogPage(channels[0], log.get_channellog_dir(config), title, search_pagelen, indexer_procs, singlechannel=True) else: root = BasePage(config) httpfactory = Site(root) port = config["HTTPLogServer"].get("port", None) if port: http_sv = internet.TCPServer(port, httpfactory) http_sv.setServiceParent(mService) sslport = config["HTTPLogServer"].get("sslport", None) privkey = config["HTTPLogServer"].get("privkey", None) cert = config["HTTPLogServer"].get("certificate", None) if sslport and privkey and cert: sslContext = ssl.DefaultOpenSSLContextFactory(privkey, cert) https_sv = internet.SSLServer(sslport, httpfactory, sslContext) https_sv.setServiceParent(mService) return mService