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
