def makeService(config):
"""
Configure a service for operating a mail server.
The returned service may include POP3 servers, SMTP servers, or both,
depending on the configuration passed in. If there are multiple servers,
they will share all of their non-network state (i.e. the same user accounts
are available on all of them).
@type config: L{Options <usage.Options>}
@param config: Configuration options specifying which servers to include in
the returned service and where they should keep mail data.
@rtype: L{IService <twisted.application.service.IService>} provider
@return: A service which contains the requested mail servers.
"""
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)
if config['pop3']:
f = config.service.getPOP3Factory()
for endpoint in config['pop3']:
svc = internet.StreamServerEndpointService(endpoint, f)
svc.setServiceParent(config.service)
if config['smtp']:
f = smtpFactory()
if config['hostname']:
f.domain = config['hostname']
f.fArgs = (f.domain, )
if config['esmtp']:
f.fArgs = (None, None) + f.fArgs
for endpoint in config['smtp']:
svc = internet.StreamServerEndpointService(endpoint, f)
svc.setServiceParent(config.service)
return config.service
def _setup_relay(self, error, advertise_version=None):
self.sp = service.MultiService()
self.sp.startService()
# need to talk to twisted team about only using unicode in
# endpoints.serverFromString
db = create_channel_db(":memory:")
self._usage_db = create_usage_db(":memory:")
self._rendezvous = make_server(db,
advertise_version=advertise_version,
signal_error=error,
usage_db=self._usage_db)
ep = endpoints.TCP4ServerEndpoint(reactor, 0, interface="127.0.0.1")
site = make_web_server(self._rendezvous, log_requests=False)
# self._lp = yield ep.listen(site)
s = MyInternetService(ep, site)
s.setServiceParent(self.sp)
self.rdv_ws_port = yield s.getPort()
self._relay_server = s
# self._rendezvous = s._rendezvous
self.relayurl = u"ws://127.0.0.1:%d/v1" % self.rdv_ws_port
# ws://127.0.0.1:%d/wormhole-relay/ws
self.transitport = allocate_tcp_port()
ep = endpoints.serverFromString(
reactor, "tcp:%d:interface=127.0.0.1" % self.transitport)
self._transit_server = f = Transit(blur_usage=None,
log_file=None,
usage_db=None)
internet.StreamServerEndpointService(ep, f).setServiceParent(self.sp)
self.transit = u"tcp:127.0.0.1:%d" % self.transitport
def create_endpoint_services(reactor, parent, listen_endpoints, factory):
for listen_endpoint in listen_endpoints:
endpoint = endpoints.serverFromString(reactor,
listen_endpoint.encode('utf-8'))
service = internet.StreamServerEndpointService(endpoint, factory)
# FIXME: Use addService on parent ?
service.setServiceParent(parent)
def __init__(self, basedir, reactor):
service.MultiService.__init__(self)
self._basedir = basedir
self._reactor = reactor
root = Root()
site = server.Site(root)
ep = endpoints.serverFromString(reactor, "tcp:8220")
internet.StreamServerEndpointService(ep, site).setServiceParent(self)
self._jm = journal.JournalManager(self._save_state)
root.putChild(b"", static.Data("root", "text/plain"))
root.putChild(b"list-invitations", Status(self._list_invitations))
root.putChild(b"invite", Action(self._invite)) # {petname:}
root.putChild(b"accept", Action(self._accept)) # {petname:, code:}
self._state_fn = os.path.join(self._basedir, "state.json")
self._state = State.from_filename(self._state_fn)
self._wormholes = {}
for iid, invitation_state in self._state.get_all_invitations().items():
def _dispatch(event, *args, **kwargs):
self._dispatch_wormhole_event(iid, event, *args, **kwargs)
w = wormhole.journaled_from_data(invitation_state["wormhole"],
reactor=self._reactor,
journal=self._jm,
event_handler=self,
event_handler_args=(iid, ))
self._wormholes[iid] = w
w.setServiceParent(self)
def addBouncer(torControlProtocol):
data_dir = os.path.join(torconfig.DataDirectory, 'bouncer')
bouncer_service = internet.StreamServerEndpointService(
getHSEndpoint(data_dir), ooniBouncer)
bouncer_service.setName('bouncer')
multiService.addService(bouncer_service)
bouncer_service.startService()
return bouncer_service
def addCollector(torControlProtocol):
data_dir = os.path.join(torconfig.DataDirectory, 'collector')
collector_service = internet.StreamServerEndpointService(
getHSEndpoint(data_dir), ooniBackend)
collector_service.setName('collector')
multiService.addService(collector_service)
collector_service.startService()
return collector_service
def makeService(self, options):
factory = ProxyFactory(options["proxy-to"])
serviceContainer = MultiService()
for bind in options["bind"]:
endpoint = serverFromString(reactor, bind)
service = internet.StreamServerEndpointService(endpoint, factory)
service.setServiceParent(serviceContainer)
return serviceContainer
def makeService(opt):
outline = Outline(filepath.FilePath(opt['store']))
resource = makeWrapper(outline.app.resource(), opt['username'],
opt['password'])
site = server.Site(resource)
port = endpoints.TCP4ServerEndpoint(reactor,
opt['port'],
interface=opt['interface'])
webService = internet.StreamServerEndpointService(endpoint=port,
factory=site)
return webService
def makeService(config):
root = resource.Resource()
site = server.Site(root)
root.putChild(b"", static.Data(b"SPAKE2 interop server", "text/plain"))
root.putChild(b"0.3", ABS("ve-p03/bin/spake2_interop_python_0_3"))
root.putChild(b"0.7", ABS("ve-p07/bin/spake2_interop_python_0_7"))
ep = endpoints.serverFromString(reactor, config["port"])
s = internet.StreamServerEndpointService(ep, site)
return s
def makeService(opt):
from twisted.internet import reactor
ops_instance = operations.Operations(reactor)
resource = ops_instance.app.resource()
site = server.Site(resource)
ret = taservice.MultiService()
for port in opt.ports:
ep = endpoints.serverFromString(reactor, port)
serv = internet.StreamServerEndpointService(ep, site)
serv.setServiceParent(ret)
return ret
def makeService(self, options):
"""
Construct a TCPServer from a factory defined in myproject.
"""
if hasattr(options, "subOptions"):
# if the "server" subcommand of the "gopher" command doesn't have
# any parameters passed, then subOptions won't be defined, in which
# case we'll need to fall back to the default
self.port = options.subOptions["port"]
factory = server.GopherServerFactory()
return internet.StreamServerEndpointService(self.getEndpoint(),
factory)
def createService(endpoint, role, endpoint_config):
if role == 'bouncer':
factory = OONIBouncer()
elif role == 'collector':
factory = OONICollector()
elif role == 'web_connectivity':
factory = http_helpers.WebConnectivityHelper
else:
raise Exception("unknown service type")
service = internet.StreamServerEndpointService(endpoint, factory)
service.setName("-".join([endpoint_config['type'], role]))
return service
def create_endpoint_services(reactor, parent, listen_endpoints, factory):
for listen_endpoint in listen_endpoints:
# work around http://twistedmatrix.com/trac/ticket/8422
if sys.version_info.major < 3:
endpoint = endpoints.serverFromString(
reactor, listen_endpoint.encode('utf-8'))
else:
endpoint = endpoints.serverFromString(reactor, listen_endpoint)
service = internet.StreamServerEndpointService(endpoint, factory)
# FIXME: Use addService on parent ?
service.setServiceParent(parent)
def makeService(self, options):
"""
Called by Twisted after having parsed the command-line options.
:param options: ``usage.Options`` instance
:return: the server instance
"""
# Configuration is mandatory
if options['config'] is None:
print('You need to specify a configuration file via `twistd ldap-proxy -c config.ini`.')
sys.exit(1)
config = load_config(options['config'])
factory = ProxyServerFactory(config)
endpoint_string = serverFromString(reactor, config['ldap-proxy']['endpoint'])
return internet.StreamServerEndpointService(endpoint_string, factory)
def makeService(self, options):
"""Construct a server using MLLPFactory.
:rtype: :py:class:`twisted.application.internet.StreamServerEndpointService`
"""
from twisted.internet import reactor
from txHL7.mllp import IHL7Receiver, MLLPFactory
receiver_name = options['receiver']
receiver_class = reflect.namedClass(receiver_name)
verifyClass(IHL7Receiver, receiver_class)
factory = MLLPFactory(receiver_class())
endpoint = endpoints.serverFromString(reactor, options['endpoint'])
server = internet.StreamServerEndpointService(endpoint, factory)
server.setName(u"mllp-{0}".format(receiver_name))
return server
def __init__(self, reactor, descriptions, factory):
service.MultiService.__init__(self)
self._descriptions = descriptions
self._factory = factory
self._listeners = []
def recordListener(listener):
self._listeners.append(listener)
return listener
for description in self._descriptions:
endpoint = _NotifyListenEndpointWrapper(
serverFromString(reactor, description))
endpoint.notifyListen().addCallback(recordListener)
internet.StreamServerEndpointService(
endpoint, factory).setServiceParent(self)
def makeService(options):
"""
Generate and return a definition for all the services that this package
needs to run. Will return a 'MultiService' object with two children.
One is a ExampleFactory listening on the configured endpoint, and the
other is an example custom Service that will do some set-up.
"""
from twisted.internet import reactor
debug = options['debug']
f = ExampleFactory(debug=debug)
endpoint = endpoints.serverFromString(reactor, options['endpoint'])
server_service = internet.StreamServerEndpointService(endpoint, f)
server_service.setName('Example Server')
return server_service
def make_plugin(config):
http_config = HttpConfig(config)
root = resource.Resource()
harold = resource.Resource()
root.putChild('harold', harold)
site = server.Site(root)
site.displayTracebacks = False
endpoint = serverFromString(reactor, http_config.endpoint)
service = internet.StreamServerEndpointService(endpoint, site)
plugin = Plugin()
plugin.root = harold
plugin.hmac_secret = http_config.hmac_secret
plugin.add_service(service)
return plugin
def make_plugin(application, app_config):
http_config = config.parse_config(app_config, {
"endpoint": config.String,
"hmac_secret": config.String,
})
root = resource.Resource()
harold = resource.Resource()
root.putChild('harold', harold)
site = server.Site(root)
site.noisy = False
site.displayTracebacks = False
endpoint = serverFromString(reactor, http_config.endpoint)
service = internet.StreamServerEndpointService(endpoint, site)
service.setServiceParent(application)
return HttpPlugin(harold, http_config.hmac_secret)
def makeService(config):
# finger on port 79
s = service.MultiService()
f = FingerService(config["file"])
h = strports.service("tcp:1079", IFingerFactory(f))
h.setServiceParent(s)
# website on port 8000
r = resource.IResource(f)
r.templateDirectory = config["templates"]
site = server.Site(r)
j = strports.service("tcp:8000", site)
j.setServiceParent(s)
# ssl on port 443
# if config.get('ssl'):
# k = strports.service(
# "ssl:port=443:certKey=cert.pem:privateKey=key.pem", site
# )
# k.setServiceParent(s)
# irc fingerbot
if "ircnick" in config:
i = IIRCClientFactory(f)
i.nickname = config["ircnick"]
ircserver = config["ircserver"]
b = internet.ClientService(
endpoints.HostnameEndpoint(reactor, ircserver, 6667), i)
b.setServiceParent(s)
# Pespective Broker on port 8889
if "pbport" in config:
m = internet.StreamServerEndpointService(
endpoints.TCP4ServerEndpoint(reactor, int(config["pbport"])),
pb.PBServerFactory(IPerspectiveFinger(f)),
)
m.setServiceParent(s)
return s
def makeService(self, options):
"""Construct a server using MLLPFactory.
:rtype: :py:class:`twisted.application.internet.StreamServerEndpointService`
"""
from twisted.internet import reactor
from txHL7.mllp import IHL7Receiver, MLLPFactory
receiver_name = options['receiver']
receiver_class = reflect.namedClass(receiver_name)
verifyClass(IHL7Receiver, receiver_class)
factory = MLLPFactory(receiver_class())
multi_service = MultiService()
for port_number in PORTS:
port = "tcp:interface={0}:port={1}".format(
HOST,
port_number,
)
endpoint = endpoints.serverFromString(reactor, port)
server = internet.StreamServerEndpointService(endpoint, factory)
server.setName(u"mllp-{0}-{1}".format(receiver_name, port_number))
multi_service.addService(server)
return multi_service
def _setup_relay(self, error, advertise_version=None):
self.sp = service.MultiService()
self.sp.startService()
self.relayport = allocate_tcp_port()
# need to talk to twisted team about only using unicode in
# endpoints.serverFromString
s = RelayServer("tcp:%d:interface=127.0.0.1" % self.relayport,
advertise_version=advertise_version,
signal_error=error)
s.setServiceParent(self.sp)
self._relay_server = s
self._rendezvous = s._rendezvous
self.relayurl = u"ws://127.0.0.1:%d/v1" % self.relayport
self.rdv_ws_port = self.relayport
# ws://127.0.0.1:%d/wormhole-relay/ws
self.transitport = allocate_tcp_port()
ep = endpoints.serverFromString(reactor,
"tcp:%d:interface=127.0.0.1" %
self.transitport)
self._transit_server = f = Transit(blur_usage=None, log_file=None,
usage_db=None)
internet.StreamServerEndpointService(ep, f).setServiceParent(self.sp)
self.transit = u"tcp:127.0.0.1:%d" % self.transitport
def __init__(self,
rendezvous_web_port,
advertise_version,
db_url=":memory:",
blur_usage=None,
signal_error=None,
stats_file=None,
allow_list=True,
websocket_protocol_options=()):
service.MultiService.__init__(self)
self._blur_usage = blur_usage
self._allow_list = allow_list
self._db_url = db_url
db = get_db(db_url)
welcome = {
# adding .motd will cause all clients to display the message,
# then keep running normally
#"motd": "Welcome to the public relay.\nPlease enjoy this service.",
# adding .error will cause all clients to fail, with this message
#"error": "This server has been disabled, see URL for details.",
}
if advertise_version:
# The primary (python CLI) implementation will emit a message if
# its version does not match this key. If/when we have
# distributions which include older version, but we still expect
# them to be compatible, stop sending this key.
welcome["current_cli_version"] = advertise_version
if signal_error:
welcome["error"] = signal_error
self._rendezvous = Rendezvous(db, welcome, blur_usage,
self._allow_list)
self._rendezvous.setServiceParent(self) # for the pruning timer
root = Root()
wsrf = WebSocketRendezvousFactory(None, self._rendezvous)
_set_options(websocket_protocol_options, wsrf)
root.putChild(b"v1", WebSocketResource(wsrf))
site = PrivacyEnhancedSite(root)
if blur_usage:
site.logRequests = False
r = endpoints.serverFromString(reactor, rendezvous_web_port)
rendezvous_web_service = internet.StreamServerEndpointService(r, site)
rendezvous_web_service.setServiceParent(self)
self._stats_file = stats_file
if self._stats_file and os.path.exists(self._stats_file):
os.unlink(self._stats_file)
# this will be regenerated immediately, but if something goes
# wrong in dump_stats(), it's better to have a missing file than
# a stale one
t = internet.TimerService(EXPIRATION_CHECK_PERIOD, self.timer)
t.setServiceParent(self)
# make some things accessible for tests
self._db = db
self._root = root
self._rendezvous_web_service = rendezvous_web_service
self._rendezvous_websocket = wsrf
def build_server(app, factory, endpoint, name=None):
logger.debug("serve %s on %s", factory, endpoint)
ept = endpoints.serverFromString(reactor, endpoint)
ss = internet.StreamServerEndpointService(ept, factory)
return attach_service(app, ss, name)
def makeService(options):
from twisted.internet import reactor
# rules/game engine
from mock import MagicMock
rules = MagicMock()
rules.workRequirement.return_value = None
rules.energyRequirement.return_value = 0
rules.isAllowed.return_value = None
engine = XatroEngine(rules)
# web
web_app = GameObserver(FilePath(options['web-static-path']))
site = Site(web_app.app.resource())
endpoint = endpoints.serverFromString(reactor, options['web-endpoint'])
web_service = internet.StreamServerEndpointService(endpoint, site)
web_service.setName('Web Observer Service')
# passwords
auth = FileStoredPasswords(options['password-file'])
# world
world = World(web_app.eventReceived, engine, auth)
# make the board
makeBoard(world, options)
# AMP
f = amp.AvatarFactory(world)
endpoint = endpoints.serverFromString(reactor, options['amp-proto-endpoint'])
amp_service = internet.StreamServerEndpointService(endpoint, f)
amp_service.setName('AMP Bot Service')
# line protocol
f = BotFactory(world, {
'move': action.Move,
'charge': action.Charge,
'consume': action.ConsumeEnergy,
'share': action.ShareEnergy,
'look': action.Look,
'shoot': action.Shoot,
'repair': action.Repair,
'tool': action.MakeTool,
'openportal': action.OpenPortal,
'useportal': action.UsePortal,
'squares': action.ListSquares,
'createteam': action.CreateTeam,
'jointeam': action.JoinTeam,
})
endpoint = endpoints.serverFromString(reactor, options['line-proto-endpoint'])
line_service = internet.StreamServerEndpointService(endpoint, f)
line_service.setName('Line-protocol Bot Service')
ms = service.MultiService()
line_service.setServiceParent(ms)
web_service.setServiceParent(ms)
amp_service.setServiceParent(ms)
return ms
self.keepalive.start(30)
def onMessage(self, payload, isBinary):
self.keepalive.reset()
if isBinary:
self.other.transport.write(payload)
def onPong(self, payload):
self.keepalive.reset()
def onClose(self, wasClean, code, reason):
log.msg("closed connection from " + self.peer)
try:
self.keepalive.stop()
except: pass
try: self.other.transport.signalProcess(signal.SIGHUP)
except: pass
if __name__ == "__builtin__":
from twisted.application import service, internet
from twisted.internet import endpoints
application = service.Application("wstty")
internet.StreamServerEndpointService(
endpoints.serverFromString(reactor, ENDPOINT),
websocket.WebSocketServerFactory.forProtocol(WSTTYProtocol)
).setServiceParent(application)
