Processes the delayed requests that did not have
any data to return last time around.
"""
# run through delayed requests
for request in self.delayed_requests:
reqkey = request.path.split("/")[-1]
for postkey in self.incoming_posts:
binpostkey = bin(int(postkey, 16))[2:]
if binpostkey[:len(reqkey)] == reqkey:
try:
ret = messages.find_one({"_id": ObjectId(postkey)})
request.write(ret.get("message").encode("UTF-8"))
request.finish()
except:
# Connection was lost
print 'connection lost before complete.'
finally:
# Remove request from list
self.delayed_requests.remove(request)
self.incoming_posts = []
website = server.Site(WebResource(kserver))
webserver = internet.TCPServer(8080, website)
webserver.setServiceParent(application)
# To test, you can set with:
# $> curl --data "hi there" http://localhost:8080/one
# and get with:
# $> curl http://localhost:8080/one
# Start telnet game connections
from evennia.server.portal import telnet
for interface in TELNET_INTERFACES:
ifacestr = ""
if interface not in ('0.0.0.0', '::') or len(TELNET_INTERFACES) > 1:
ifacestr = "-%s" % interface
for port in TELNET_PORTS:
pstring = "%s:%s" % (ifacestr, port)
factory = protocol.ServerFactory()
factory.protocol = telnet.TelnetProtocol
factory.sessionhandler = PORTAL_SESSIONS
telnet_service = internet.TCPServer(port,
factory,
interface=interface)
telnet_service.setName('EvenniaTelnet%s' % pstring)
PORTAL.services.addService(telnet_service)
print(' telnet%s: %s' % (ifacestr, port))
if SSL_ENABLED:
# Start SSL game connection (requires PyOpenSSL).
from evennia.server.portal import ssl
for interface in SSL_INTERFACES:
ifacestr = ""
if interface not in ('0.0.0.0', '::') or len(SSL_INTERFACES) > 1:
def makeService(self, options):
"""
Construct a TCPServer from a factory defined in Cowrie.
"""
if os.name == 'posix' and os.getuid() == 0:
print('ERROR: You must not run cowrie as root!')
sys.exit(1)
cfg = readConfigFile(options["config"])
topService = service.MultiService()
application = service.Application('cowrie')
topService.setServiceParent(application)
factory = cowrie.ssh.transport.HoneyPotSSHFactory(cfg)
factory.portal = portal.Portal(core.realm.HoneyPotRealm(cfg))
factory.portal.registerChecker(
core.checkers.HoneypotPublicKeyChecker())
factory.portal.registerChecker(
core.checkers.HoneypotPasswordChecker(cfg))
if cfg.has_option('honeypot', 'auth_none_enabled') and \
cfg.get('honeypot', 'auth_none_enabled').lower() in \
('yes', 'true', 'on'):
factory.portal.registerChecker(
core.checkers.HoneypotNoneChecker())
if cfg.has_option('ssh', 'listen_addr'):
listen_ssh_addr = cfg.get('ssh', 'listen_addr')
elif cfg.has_option('honeypot', 'listen_addr'):
listen_ssh_addr = cfg.get('honeypot', 'listen_addr')
else:
listen_ssh_addr = '0.0.0.0'
# Preference: 1, option, 2, config, 3, default of 2222
if options['port'] != 0:
listen_ssh_port = int(options["port"])
elif cfg.has_option('ssh', 'listen_port'):
listen_ssh_port = int(cfg.get('ssh', 'listen_port'))
elif cfg.has_option('honeypot', 'listen_port'):
listen_ssh_port = int(cfg.get('honeypot', 'listen_port'))
else:
listen_ssh_port = 2222
for i in listen_ssh_addr.split():
svc = internet.TCPServer(listen_ssh_port, factory, interface=i)
# FIXME: Use addService on topService ?
svc.setServiceParent(topService)
if cfg.has_option('telnet', 'enabled') and \
cfg.get('telnet', 'enabled').lower() in \
('yes', 'true', 'on'):
if cfg.has_option('telnet', 'listen_addr'):
listen_telnet_addr = cfg.get('telnet', 'listen_addr')
else:
listen_telnet_addr = '0.0.0.0'
# Preference: 1, config, 2, default of 2223
if cfg.has_option('telnet', 'listen_port'):
listen_telnet_port = int(cfg.get('telnet', 'listen_port'))
else:
listen_telnet_port = 2223
f = cowrie.telnet.transport.HoneyPotTelnetFactory(cfg)
f.portal = portal.Portal(core.realm.HoneyPotRealm(cfg))
f.portal.registerChecker(core.checkers.HoneypotPasswordChecker(cfg))
if cfg.has_option('honeypot', 'auth_none_enabled') and \
cfg.get('honeypot', 'auth_none_enabled').lower() in \
('yes', 'true', 'on'):
f.portal.registerChecker(core.checkers.HoneypotNoneChecker())
for i in listen_telnet_addr.split():
tsvc = internet.TCPServer(listen_telnet_port, f, interface=i)
# FIXME: Use addService on topService ?
tsvc.setServiceParent(topService)
if cfg.has_option('honeypot', 'interact_enabled') and \
cfg.get('honeypot', 'interact_enabled').lower() in \
('yes', 'true', 'on'):
iport = int(cfg.get('honeypot', 'interact_port'))
# FIXME this doesn't support checking both Telnet and SSH sessions
from cowrie.core import interact
svc = internet.TCPServer(iport,
interact.makeInteractFactory(factory), interface='127.0.0.1')
# FIXME: Use addService on topService ?
svc.setServiceParent(topService)
return topService
def run_siptrackd_twisted(listen_port, ssl_port,
ssl_private_key, ssl_certificate, storage, reload_interval,
searcher):
log.msg('Creating object store')
object_store = siptrackdlib.ObjectStore(storage, searcher = searcher)
session_handler = sessions.SessionHandler()
log.msg('Creating rpc interface')
siptrackd_rpc = SiptrackdRPC(object_store, session_handler)
xmlrpc.addIntrospection(siptrackd_rpc)
view_rpc = view.ViewRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('view', view_rpc)
view_tree_rpc = view.ViewTreeRPC(object_store, session_handler)
view_rpc.putSubHandler('tree', view_tree_rpc)
counter_rpc = counter.CounterRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('counter', counter_rpc)
counter_loop_rpc = counter.CounterLoopRPC(object_store, session_handler)
counter_rpc.putSubHandler('loop', counter_loop_rpc)
user_rpc = user.UserRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('user', user_rpc)
user_local_rpc = user.UserLocalRPC(object_store, session_handler)
user_rpc.putSubHandler('local', user_local_rpc)
user_ldap_rpc = user.UserLDAPRPC(object_store, session_handler)
user_rpc.putSubHandler('ldap', user_ldap_rpc)
user_active_directory_rpc = user.UserActiveDirectoryRPC(object_store, session_handler)
user_rpc.putSubHandler('activedirectory', user_active_directory_rpc)
user_rpc.putSubHandler('ad', user_active_directory_rpc)
user_manager_rpc = user.UserManagerRPC(object_store, session_handler)
user_rpc.putSubHandler('manager', user_manager_rpc)
user_manager_local_rpc = user.UserManagerLocalRPC(object_store, session_handler)
user_manager_rpc.putSubHandler('local', user_manager_local_rpc)
user_manager_ldap_rpc = user.UserManagerLDAPRPC(object_store, session_handler)
user_manager_rpc.putSubHandler('ldap', user_manager_ldap_rpc)
user_manager_active_directory_rpc = user.UserManagerActiveDirectoryRPC(object_store, session_handler)
user_manager_rpc.putSubHandler('activedirectory', user_manager_active_directory_rpc)
user_manager_rpc.putSubHandler('ad', user_manager_active_directory_rpc)
user_group_rpc = user.UserGroupRPC(object_store, session_handler)
user_rpc.putSubHandler('group', user_group_rpc)
user_group_ldap_rpc = user.UserGroupLDAPRPC(object_store, session_handler)
user_group_rpc.putSubHandler('ldap', user_group_ldap_rpc)
user_group_active_directory_rpc = user.UserGroupActiveDirectoryRPC(object_store, session_handler)
user_group_rpc.putSubHandler('activedirectory', user_group_active_directory_rpc)
user_group_rpc.putSubHandler('ad', user_group_active_directory_rpc)
device_rpc = device.DeviceRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('device', device_rpc)
device_tree_rpc = device.DeviceTreeRPC(object_store, session_handler)
device_rpc.putSubHandler('tree', device_tree_rpc)
device_category_rpc = device.DeviceCategoryRPC(object_store, session_handler)
device_rpc.putSubHandler('category', device_category_rpc)
device_config_rpc = deviceconfig.DeviceConfigRPC(object_store, session_handler)
device_rpc.putSubHandler('config', device_config_rpc)
device_config_template_rpc = deviceconfig.DeviceConfigTemplateRPC(object_store, session_handler)
device_config_rpc.putSubHandler('template', device_config_template_rpc)
password_rpc = password.PasswordRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('password', password_rpc)
password_key_rpc = password.PasswordKeyRPC(object_store, session_handler)
password_rpc.putSubHandler('key', password_key_rpc)
password_tree_rpc = password.PasswordTreeRPC(object_store, session_handler)
password_rpc.putSubHandler('tree', password_tree_rpc)
password_category_rpc = password.PasswordCategoryRPC(object_store, session_handler)
password_rpc.putSubHandler('category', password_category_rpc)
sub_key_rpc = password.SubKeyRPC(object_store, session_handler)
password_rpc.putSubHandler('subkey', sub_key_rpc)
network_rpc = network.NetworkRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('network', network_rpc)
network_tree_rpc = network.NetworkTreeRPC(object_store, session_handler)
network_rpc.putSubHandler('tree', network_tree_rpc)
network_ipv4_rpc = network.NetworkIPV4RPC(object_store, session_handler)
network_rpc.putSubHandler('ipv4', network_ipv4_rpc)
network_range_rpc = network.NetworkRangeRPC(object_store, session_handler)
network_rpc.putSubHandler('range', network_range_rpc)
network_range_ipv4_rpc = network.NetworkRangeIPV4RPC(object_store, session_handler)
network_range_rpc.putSubHandler('ipv4', network_range_ipv4_rpc)
network_ipv6_rpc = network.NetworkIPV6RPC(object_store, session_handler)
network_rpc.putSubHandler('ipv6', network_ipv6_rpc)
network_range_ipv6_rpc = network.NetworkRangeIPV6RPC(object_store, session_handler)
network_range_rpc.putSubHandler('ipv6', network_range_ipv6_rpc)
container_rpc = container.ContainerRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('container', container_rpc)
container_tree_rpc = container.ContainerTreeRPC(object_store, session_handler)
container_rpc.putSubHandler('tree', container_tree_rpc)
attribute_rpc = attribute.AttributeRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('attribute', attribute_rpc)
versioned_attribute_rpc = attribute.VersionedAttributeRPC(object_store, session_handler)
attribute_rpc.putSubHandler('versioned', versioned_attribute_rpc)
encrypted_attribute_rpc = attribute.EncryptedAttributeRPC(
object_store,
session_handler
)
attribute_rpc.putSubHandler(
'encrypted',
encrypted_attribute_rpc
)
template_rpc = template.TemplateRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('template', template_rpc)
device_template_rpc = template.DeviceTemplateRPC(object_store,
session_handler)
template_rpc.putSubHandler('device', device_template_rpc)
network_template_rpc = template.NetworkTemplateRPC(object_store,
session_handler)
template_rpc.putSubHandler('network', network_template_rpc)
template_rule_rpc = template.TemplateRuleRPC(object_store, session_handler)
template_rpc.putSubHandler('rule', template_rule_rpc)
template_rule_password_rpc = template.TemplateRulePasswordRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('password', template_rule_password_rpc)
template_rule_assign_network_rpc = template.TemplateRuleAssignNetworkRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('assign_network', template_rule_assign_network_rpc)
template_rule_subdevice_rpc = template.TemplateRuleSubdeviceRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('subdevice', template_rule_subdevice_rpc)
template_rule_text_rpc = template.TemplateRuleTextRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('text', template_rule_text_rpc)
template_rule_fixed_rpc = template.TemplateRuleFixedRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('fixed', template_rule_fixed_rpc)
template_rule_regmatch_rpc = template.TemplateRuleRegmatchRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('regmatch', template_rule_regmatch_rpc)
template_rule_bool_rpc = template.TemplateRuleBoolRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('bool', template_rule_bool_rpc)
template_rule_int_rpc = template.TemplateRuleIntRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('int', template_rule_int_rpc)
template_rule_delete_attribute_rpc = template.TemplateRuleDeleteAttributeRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('delete_attribute', template_rule_delete_attribute_rpc)
template_rule_flush_nodes_rpc = template.TemplateRuleFlushNodesRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('flush_nodes', template_rule_flush_nodes_rpc)
template_rule_flush_associations_rpc = template.TemplateRuleFlushAssociationsRPC(object_store, session_handler)
template_rule_rpc.putSubHandler('flush_associations', template_rule_flush_associations_rpc)
config_rpc = config.ConfigRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('config', config_rpc)
config_network_autoassign_rpc = config.ConfigNetworkAutoassignRPC(object_store, session_handler)
config_rpc.putSubHandler('network_autoassign', config_network_autoassign_rpc)
config_value_rpc = config.ConfigValueRPC(object_store, session_handler)
config_rpc.putSubHandler('value', config_value_rpc)
simple_rpc = simple.SimpleRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('simple', simple_rpc)
permission_rpc = permission.PermissionRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('permission', permission_rpc)
command_rpc = event.CommandRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('command', command_rpc)
command_queue_rpc = event.CommandQueueRPC(object_store, session_handler)
command_rpc.putSubHandler('queue', command_queue_rpc)
event_rpc = event.EventRPC(object_store, session_handler)
siptrackd_rpc.putSubHandler('event', event_rpc)
event_trigger_rpc = event.EventTriggerRPC(object_store, session_handler)
event_rpc.putSubHandler('trigger', event_trigger_rpc)
event_trigger_rule_rpc = event.EventTriggerRuleRPC(object_store, session_handler)
event_trigger_rpc.putSubHandler('rule', event_trigger_rule_rpc)
event_trigger_rule_python_rpc = event.EventTriggerRulePythonRPC(object_store, session_handler)
event_trigger_rule_rpc.putSubHandler('python', event_trigger_rule_python_rpc)
root_service = service.MultiService()
if listen_port:
siptrackd_xmlrpc_service = internet.TCPServer(listen_port,
server.Site(siptrackd_rpc))
siptrackd_xmlrpc_service.setServiceParent(root_service)
if ssl_port:
ssl_context = SiptrackOpenSSLContextFactory(ssl_private_key,
ssl_certificate)
siptrackd_ssl_xmlrpc_service = internet.SSLServer(ssl_port,
server.Site(siptrackd_rpc), ssl_context)
siptrackd_ssl_xmlrpc_service.setServiceParent(root_service)
application = service.Application('siptrackd')
root_service.setServiceParent(application)
reactor.callWhenRunning(siptrackd_twisted_init, object_store, application)
if reload_interval:
reactor.callLater(reload_interval, object_store_reloader, session_handler, object_store, reload_interval)
reactor.run()
log.msg('Shutting down siptrackd server.')
return 0
from twisted.protocols import basic
class MyChat(basic.LineReceiver):
def connectionMade(self):
print("Got new client!")
self.factory.clients.append(self)
def connectionLost(self, reason):
print("Lost a client!")
self.factory.clients.remove(self)
def lineReceived(self, line):
print("received", repr(line))
for c in self.factory.clients:
c.message(line)
def message(self, message):
self.transport.write(message + b"\n")
from twisted.internet import protocol
from twisted.application import service, internet
factory = protocol.ServerFactory()
factory.protocol = MyChat
factory.clients = []
application = service.Application("chatserver")
internet.TCPServer(1025, factory).setServiceParent(application)
LoggingHandler(),
pushTokenHandler,
pushNotificationSender,
# HexdumpHandler(sys.stdout),
]
APPLE_PUSH_IPS = ('17.172.232.218', '17.172.232.59', '17.172.232.134',
'17.172.232.135', '17.172.232.145', '17.172.232.216',
'17.172.232.142', '17.172.232.212')
factory = InterceptServerFactory(
hosts=APPLE_PUSH_IPS,
port=5223,
serverCert=SERVER_CERT_PATH,
clientCertDir=CLIENT_CERT_DIR,
caCertChain=CA_CERT_CHAIN_PATH,
serverChain=APPLE_CERT_CHAIN_PATH,
dispatchHandlers=DISPATCH_HANDLERS,
)
contextFactory = factory.getServerContextFactory()
application = service.Application('i4d-push')
serviceCollection = service.IServiceCollection(application)
internet.SSLServer(5223, factory, contextFactory) \
.setServiceParent(serviceCollection)
internet.TCPServer(1234,
pb.PBServerFactory(pushNotificationSender),
interface='127.0.0.1') \
.setServiceParent(serviceCollection)
def getContext(self):
"""
Create an SSL context.
This is a sample implementation that loads a certificate from a file
called 'server.pem'.
"""
ctx = SSL.Context(SSL.SSLv23_METHOD)
ctx.use_certificate_file('server.pem')
ctx.use_privatekey_file('server.pem')
return ctx
application = service.Application('finger', uid=1, gid=1)
f = FingerService('/etc/users')
serviceCollection = service.IServiceCollection(application)
f.setServiceParent(serviceCollection)
internet.TCPServer(79, IFingerFactory(f)
).setServiceParent(serviceCollection)
site = server.Site(resource.IResource(f))
internet.TCPServer(8000, site
).setServiceParent(serviceCollection)
internet.SSLServer(443, site, ServerContextFactory()
).setServiceParent(serviceCollection)
i = IIRCClientFactory(f)
i.nickname = 'fingerbot'
internet.TCPClient('irc.freenode.org', 6667, i
).setServiceParent(serviceCollection)
internet.TCPServer(8889, pb.PBServerFactory(IPerspectiveFinger(f))
).setServiceParent(serviceCollection)
def getService(self):
return internet.TCPServer(self.port, self)
def listenTCP(self, port, factory, backlog=50, interface=''):
s = internet.TCPServer(port, factory, backlog, interface)
s.privileged = 1
s.setServiceParent(self.app)
def run(self):
internet.TCPServer(self.__port,
ServiceFactory()).setServiceParent(self.__app)
handlers = [
(r"/api/user", AddUserHandler),
(r"/api/auth", LoginHandler),
(r"/api/admin", AddAdminHandler),
(r"/api/movies", AddMovieHandler),
(r"/api/movie_list", MovieListHandler),
(r"/(.*)", cyclone.web.StaticFileHandler, {
"path": "static"
}),
]
settings = dict(
cookie_secret="43oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
login_url="/static/login.html",
template_path=os.path.join(os.path.dirname(__file__), "static"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
#ToDo: This has to be enabled for production system. Currently
#disabling it as it is creating issue with REST Clients
#xsrf_cookies=True,
xsrf_cookies=False,
autoescape=None,
)
cyclone.web.Application.__init__(self, handlers, **settings)
application = service.Application("GoFynd Project")
webapp = WebApplication(application)
server = internet.TCPServer(8888, webapp, interface="0.0.0.0")
server.setServiceParent(application)
#observer = log.PythonLoggingObserver(filename=filename)
#application.setComponent(ILogObserver, observer.emit)
for section in config.sections():
log.msg("Loading config section: %s" % section)
sslctx = None
if config.get(section, 'proto') == 'ssl':
sslctx = ServerContextFactory(config.get(section, 'crtfile'),
config.get(section, 'keyfile'),
config.get(section, 'cafile'))
clientopts = {
"host": config.get(section, 'host'),
"port": config.getint(section, 'port'),
"timeout": config.getint(section, 'timeout'),
"sslctx": sslctx,
"keepalive_interval": config.getint(section, 'keepalive_interval'),
}
s = internet.TCPServer(
config.getint(section, 'listen_port'),
server.EPPProxyServerFactory(
clientopts,
max_clients=config.getint(section, 'max_clients'),
max_retries=config.getint(section, 'max_retries')),
interface=config.get(section, 'listen_host'))
s.setServiceParent(serviceCollection)
#! /usr/bin/python
from twisted.application import service, internet
from twisted.internet import reactor
from twisted.spread import pb
import cache_classes
class Receiver(pb.Root):
def remote_takePond(self, pond):
self.pond = pond
print "got pond:", pond # a DuckPondCache
self.remote_checkDucks()
def remote_checkDucks(self):
print "[%d] ducks: " % self.pond.count(), self.pond.getDucks()
def remote_ignorePond(self):
# stop watching the pond
print "dropping pond"
# gc causes __del__ causes 'decache' msg causes stoppedObserving
self.pond = None
def remote_shutdown(self):
reactor.stop()
application = service.Application("copy_receiver")
internet.TCPServer(8800, pb.PBServerFactory(Receiver())).setServiceParent(
service.IServiceCollection(application))
def createSGASServer(config_file=DEFAULT_CONFIG_FILE, no_authz=False, port=None):
log = messages.Messages()
cfg = config.readConfig(config_file)
# check for whitelist and fail if it is there
# a bit harsh, but the config needs to be updated for the system to work
if config.HOSTNAME_CHECK_WHITELIST in cfg.options(config.SERVER_BLOCK):
raise ConfigurationError('Whitelist no longer supported, use "insert:all" in sgas.authz')
# some friendly messages from your service configuration
if config.HOSTKEY in cfg.options(config.SERVER_BLOCK):
log.msg('Option "hostkey" can be removed from config file (no longer used)', system='sgas.Setup')
if config.HOSTCERT in cfg.options(config.SERVER_BLOCK):
log.msg('Option "hostcert" can be removed from config file (no longer used)', system='sgas.Setup')
if config.CERTDIR in cfg.options(config.SERVER_BLOCK):
log.msg('Option "certdir" can be removed from config file (no longer used)', system='sgas.Setup')
if config.REVERSE_PROXY in cfg.options(config.SERVER_BLOCK):
log.msg('Option "reverse_proxy" can be removed from config file (no longer used)', system='sgas.Setup')
# check depth
try:
check_depth = cfg.getint(config.SERVER_BLOCK, config.HOSTNAME_CHECK_DEPTH)
except ValueError: # in case casting goes wrong
raise ConfigurationError('Configured check depth is invalid')
# authz
if no_authz:
from test import utils
authorizer = utils.FakeAuthorizer()
else:
authorizer = engine.AuthorizationEngine(check_depth, cfg.get(config.SERVER_BLOCK, config.AUTHZ_FILE))
# database
db_url = cfg.get(config.SERVER_BLOCK, config.DB)
if db_url.startswith('http'):
raise ConfigurationError('CouchDB no longer supported. Please upgrade to PostgreSQL')
db = pgdatabase.PostgreSQLDatabase(db_url)
# hs.setServiceParent(db)
# http site
site = createSite(cfg, log, db, authorizer)
# load generic services
loadServices(cfg,log,db)
# read auth file.
authorizer.initAuthzFile()
# application
application = service.Application("sgas")
log.setServiceParent(application)
db.setServiceParent(application)
internet.TCPServer(port or DEFAULT_PORT, site, interface='localhost').setServiceParent(application)
log.msg('SGAS %s twistd application created, starting server.' % __version__, system='sgas.Setup')
return application
127.0.0.1 example.com
Then visit http://example.com/ with a web browser and compare the results to
visiting http://localhost/.
"""
from twisted.web import vhost, static, script, server
from twisted.application import internet, service
default = static.Data(b"", "text/html")
# Setting up vhost resource.
default.putChild(b"vhost", vhost.VHostMonsterResource())
resource = vhost.NameVirtualHost()
resource.default = default
# Here we use /var/www/html/ as our root diretory for the web server, you can
# change it to whatever directory you want.
root = static.File("/var/www/html/")
root.processors = {".rpy": script.ResourceScript}
# addHost binds domain name example.com to our root resource.
resource.addHost("example.com", root)
# Setup Twisted Application.
site = server.Site(resource)
application = service.Application("vhost")
sc = service.IServiceCollection(application)
# Only the processes owned by the root user can listen @ port 80, change the
# port number here if you don't want to run it as root.
i = internet.TCPServer(80, site)
i.setServiceParent(sc)
def makeService(self, options):
"""
Construct a TCPServer from a factory defined in myproject.
"""
return internet.TCPServer(int(options["port"]),
Site(HookahResource.setup()))
def getWebService(user, host_name, address, port, provider, strip_subdomain,
auth):
proxySite = server.Site(
LocalTunnelReverseProxy(user, host_name, address, provider,
strip_subdomain, auth))
return internet.TCPServer(port, proxySite)
INFO_DICT[
"lockdown_mode"] = ' LOCKDOWN_MODE active: Only local connections.'
if AMP_ENABLED:
# The AMP protocol handles the communication between
# the portal and the mud server. Only reason to ever deactivate
# it would be during testing and debugging.
from evennia.server.portal import amp_server
INFO_DICT["amp"] = 'amp: %s' % AMP_PORT
factory = amp_server.AMPServerFactory(PORTAL)
amp_service = internet.TCPServer(AMP_PORT,
factory,
interface=AMP_INTERFACE)
amp_service.setName("PortalAMPServer")
PORTAL.services.addService(amp_service)
# We group all the various services under the same twisted app.
# These will gradually be started as they are initialized below.
if TELNET_ENABLED:
# Start telnet game connections
from evennia.server.portal import telnet
for interface in TELNET_INTERFACES:
ifacestr = ""
def makeService(self, options):
return internet.TCPServer(options["port"],
myapp.Application(options["redis-host"], int(options["redis-port"]),
int(options["redis-pool"]), int(options["redis-db"])),
interface=options["listen"])
def webservice(config, dnsserver):
root = RootResource(config, dnsserver)
site = CallsignSite(root)
return internet.TCPServer(config['www_port'], site)
application = service.Application('oonibackend')
multiService = service.MultiService()
if config.helpers['ssl'].port:
print "Starting SSL helper on %s" % config.helpers['ssl'].port
ssl_helper = internet.SSLServer(int(config.helpers['ssl'].port),
http_helpers.HTTPReturnJSONHeadersHelper(),
ssl_helpers.SSLContext(config))
multiService.addService(ssl_helper)
ssl_helper.startService()
# Start the DNS Server related services
if config.helpers['dns'].tcp_port:
print "Starting TCP DNS Helper on %s" % config.helpers['dns'].tcp_port
tcp_dns_helper = internet.TCPServer(int(config.helpers['dns'].tcp_port),
dns_helpers.DNSTestHelper())
multiService.addService(tcp_dns_helper)
tcp_dns_helper.startService()
if config.helpers['dns'].udp_port:
print "Starting UDP DNS Helper on %s" % config.helpers['dns'].udp_port
udp_dns_factory = dns.DNSDatagramProtocol(dns_helpers.DNSTestHelper())
udp_dns_helper = internet.UDPServer(int(config.helpers['dns'].udp_port),
udp_dns_factory)
multiService.addService(udp_dns_helper)
udp_dns_helper.startService()
if config.helpers['dns_discovery'].udp_port:
print("Starting UDP DNS Discovery Helper on %s" %
config.helpers['dns_discovery'].udp_port)
udp_dns_discovery = internet.UDPServer(
# Twisted Application Framework setup:
application = service.Application('twisted-django')
# WSGI container for Django, combine it with twisted.web.Resource:
# XXX this is the only 'ugly' part: see the 'getChild' method in twresource.Root
# The MultiService allows to start Django and Twisted server as a daemon.
multi = service.MultiService()
pool = threadpool.ThreadPool()
tps = ThreadPoolService(pool)
tps.setServiceParent(multi)
resource = wsgi.WSGIResource(reactor, tps.pool, WSGIHandler())
root = twresource.Root(resource)
# Servce Django media files off of /media:
mediasrc = static.File(os.path.join(os.path.abspath("."),
"mydjangosite/media"))
staticsrc = static.File(
os.path.join(os.path.abspath("."), "mydjangosite/static"))
root.putChild("media", mediasrc)
root.putChild("static", staticsrc)
# The cool part! Add in pure Twisted Web Resouce in the mix
# This 'pure twisted' code could be using twisted's XMPP functionality, etc:
root.putChild("google", twresource.GoogleResource())
# Serve it up:
main_site = server.Site(root)
internet.TCPServer(PORT, main_site).setServiceParent(multi)
multi.setServiceParent(application)
def makeService(options):
"""
Makes a new swftp-sftp service. The only option is the config file
location. See CONFIG_DEFAULTS for list of configuration options.
"""
from twisted.cred.portal import Portal
from swftp.realm import SwftpRealm
from swftp.auth import SwiftBasedAuthDB
from swftp.utils import (log_runtime_info, GLOBAL_METRICS,
parse_key_value_config)
c = get_config(options['config_file'], options)
smtp_service = service.MultiService()
# ensure timezone is GMT
os.environ['TZ'] = 'GMT'
time.tzset()
print('Starting SwFTP-smtp %s' % VERSION)
authdb = SwiftBasedAuthDB(
c.get('smtp', 'auth_url'),
global_max_concurrency=c.getint('smtp', 'num_persistent_connections'),
max_concurrency=c.getint('smtp', 'num_connections_per_session'),
timeout=c.getint('smtp', 'connection_timeout'),
extra_headers=parse_key_value_config(c.get('smtp', 'extra_headers')),
verbose=c.getboolean('smtp', 'verbose'),
rewrite_scheme=c.get('smtp', 'rewrite_storage_scheme'),
rewrite_netloc=c.get('smtp', 'rewrite_storage_netloc'),
)
rabbitmq_hosts = c.get('rabbitmq', 'rabbitmq_hosts')
rabbitmq_cluster = RabbitClusterClient([RabbitReplica(host, port) \
for host, port in [(h,int(p)) for h,p in [r.split(':') \
for r in rabbitmq_hosts.split(',')]]], \
c.get('rabbitmq', 'username'), \
c.get('rabbitmq', 'password')) \
if rabbitmq_hosts else None
queue_name = c.get('smtp', 'queue_name')
swift_username = c.get('smtp', 'swift_username')
swift_password = c.get('smtp', 'swift_password')
def swift_connect():
d = authdb.requestAvatarId(
UsernamePassword(swift_username, swift_password))
def cb(connection):
return connection
def errback(failure):
log.err("Swift connection failed: %s" % failure.type)
raise SMTPServerError(451, "Internal server error")
d.addCallbacks(cb, errback)
return d
@defer.inlineCallbacks
def prepare_path():
swift_conn = yield swift_connect()
swift_filesystem = SwiftFileSystem(swift_conn)
try:
yield swift_filesystem.get_container_listing('smtp', '/')
except swift.NotFound:
yield swift_filesystem.makeDirectory('/smtp/')
defer.returnValue(None)
prepare_path()
smtp_factory = SwftpSMTPFactory(swift_connect, rabbitmq_cluster,\
queue_name)
signal.signal(signal.SIGUSR1, log_runtime_info)
signal.signal(signal.SIGUSR2, log_runtime_info)
internet.TCPServer(c.getint('smtp', 'port'),
smtp_factory,
interface=c.get('smtp',
'host')).setServiceParent(smtp_service)
return smtp_service
log.debug('Saving configuration file')
self.config.save()
if self.socket:
d = self.socket.stopListening()
self.socket = None
else:
d = defer.Deferred()
d.callback(False)
return d
def shutdown(self, *args):
self.stop()
if self.daemon and reactor.running:
reactor.stop()
def _migrate_config_1_to_2(self, config):
config['language'] = CONFIG_DEFAULTS['language']
return config
if __name__ == '__builtin__':
deluge_web = DelugeWeb()
application = service.Application('DelugeWeb')
sc = service.IServiceCollection(application)
i = internet.TCPServer(deluge_web.port, deluge_web.site)
i.setServiceParent(sc)
elif __name__ == '__main__':
deluge_web = DelugeWeb()
deluge_web.start()
#!/usr/bin/python2.7
from twisted.application import internet, service
from twisted.web import server, resource
from twisted.python.log import ILogObserver, FileLogObserver
from twisted.python.logfile import DailyLogFile
from twisted.internet import reactor
from health_salone.src.server import RequestFactory
from health_salone.src import config
ProfilerService = internet.TCPServer(config.WEB_PORT, RequestFactory())
ProfilerService.setName('sms-listener')
application = service.Application('sms-listener')
ProfilerService.setServiceParent(application)
logfile = DailyLogFile(config.LOGS['WEB'], config.LOGS['LOCATION'])
application.setComponent(ILogObserver, FileLogObserver(logfile).emit)
reactor.suggestThreadPoolSize(config.WEB_THREADS)
def setup_finalize(event, application):
from twisted.application import service, internet
from twisted.internet import reactor, ssl
from twisted.web.server import Site
from twisted.python import log
#from twisted.enterprise import adbapi
import OpenSSL.SSL
from services import ServiceEventHandler
import socket_transport
import http_transport
import websocket_transport
import irc
from stratum import settings
try:
import signature
signing_key = signature.load_privkey_pem(settings.SIGNING_KEY)
except:
print "Loading of signing key '%s' failed, protocol messages cannot be signed." % settings.SIGNING_KEY
signing_key = None
# Attach HTTPS Poll Transport service to application
try:
sslContext = ssl.DefaultOpenSSLContextFactory(settings.SSL_PRIVKEY,
settings.SSL_CACERT)
except OpenSSL.SSL.Error:
sslContext = None
print "Cannot initiate SSL context, are SSL_PRIVKEY or SSL_CACERT missing?"
print "This will skip all SSL-based transports."
# Set up thread pool size for service threads
reactor.suggestThreadPoolSize(settings.THREAD_POOL_SIZE)
if settings.LISTEN_SOCKET_TRANSPORT:
# Attach Socket Transport service to application
socket = internet.TCPServer(
settings.LISTEN_SOCKET_TRANSPORT,
socket_transport.SocketTransportFactory(
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler,
tcp_proxy_protocol_enable=settings.TCP_PROXY_PROTOCOL))
socket.setServiceParent(application)
# Build the HTTP interface
httpsite = Site(
http_transport.Root(debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler))
httpsite.sessionFactory = http_transport.HttpSession
if settings.LISTEN_HTTP_TRANSPORT:
# Attach HTTP Poll Transport service to application
http = internet.TCPServer(settings.LISTEN_HTTP_TRANSPORT, httpsite)
http.setServiceParent(application)
if settings.LISTEN_HTTPS_TRANSPORT and sslContext:
https = internet.SSLServer(settings.LISTEN_HTTPS_TRANSPORT,
httpsite,
contextFactory=sslContext)
https.setServiceParent(application)
if settings.LISTEN_WS_TRANSPORT:
from autobahn.twisted.websocket import listenWS
log.msg("Starting WS transport on %d" % settings.LISTEN_WS_TRANSPORT)
ws = websocket_transport.WebsocketTransportFactory(
settings.LISTEN_WS_TRANSPORT,
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler)
listenWS(ws)
if settings.LISTEN_WSS_TRANSPORT and sslContext:
from autobahn.twisted.websocket import listenWS
log.msg("Starting WSS transport on %d" % settings.LISTEN_WSS_TRANSPORT)
wss = websocket_transport.WebsocketTransportFactory(
settings.LISTEN_WSS_TRANSPORT,
is_secure=True,
debug=settings.DEBUG,
signing_key=signing_key,
signing_id=settings.SIGNING_ID,
event_handler=ServiceEventHandler)
listenWS(wss, contextFactory=sslContext)
if settings.IRC_NICK:
reactor.connectTCP(
settings.IRC_SERVER, settings.IRC_PORT,
irc.IrcLurkerFactory(settings.IRC_ROOM, settings.IRC_NICK,
settings.IRC_HOSTNAME))
return event
def _constructApplication(self):
application = service.Application('Athena Livetest')
site = appserver.NevowSite(runner.TestFrameworkRoot(self.suite))
internet.TCPServer(self['port'], site).setServiceParent(application)
return application
def makeService(self, options):
""" Construct a TCPServer from a factory. """
factory = make_factory()
return internet.TCPServer(int(options['port']), factory)
def setServiceParent(self, service):
self.service = service
if service:
internet.TCPServer(self.port, self).setServiceParent(service)
else:
reactor.listenTCP(self.port, self)
def makeService(config):
# Check for parameters...
if config["config"] == None:
print "Configuration file (-c, --config) is a REQUIRED parameter. Configuration aborted."
sys.exit(-1)
cfg = ConfigParser.ConfigParser()
cfg.read(config["config"])
if not cfg.has_section(config["jid"]):
print "Section " + config[
"jid"] + " not found in configuration file. Aborting."
sys.exit(-1)
for o in ['rhost', 'rport', 'secret', 'proxyips']:
if cfg.has_option(config["jid"], o):
config[o] = cfg.get(config["jid"], o)
else:
print "Required option " + o + " not found in configuration file. Aborting."
sys.exit(-1)
try:
int(config["rport"], 10)
except ValueError:
print "Invalid router port (rport) provided."
sys.exit(-1)
# Split and parse the addresses to ensure they are valid
addresses = config["proxyips"].split(",")
validAddresses = []
for a in addresses:
try:
ip = None
port = 7777
if ":" in a:
ip, port = a.split(":")
else:
ip = a
socket.inet_pton(socket.AF_INET, ip)
validAddresses.append((ip, int(port)))
except socket.error:
print "Warning! Not using invalid proxy network address: ", a
# No valid addresses, no proxy65
if len(validAddresses) < 1:
print "0 Proxy Network Addresses (proxyips) found. Configuration aborted."
sys.exit(-1)
c = component.buildServiceManager(config["jid"], config["secret"],
("tcp:%s:%s" %
(config["rhost"], config["rport"])))
proxySvc = Service(config)
proxySvc.setServiceParent(c)
# Construct a multi service to hold all the listening
# services -- the main proxy65.Service object will then
# just use that to control when the system should be
# listening
listeners = service.MultiService()
for (ip, port) in validAddresses:
listener = internet.TCPServer(port, proxySvc, interface=ip)
listener.setServiceParent(listeners)
# Set the proxy services listeners variable with the
# new multiservice
proxySvc.listeners = listeners
proxySvc.activeAddresses = validAddresses
return c
