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