def setUp(): if len(sys.argv) > 1 and sys.argv[1] == 'debug': log.startLogging(sys.stdout) debug = True else: debug = False try: import autobahn import twisted except ImportError: sys.exit("Install all dependencies") root = Resource() # root.putChild(constants.WEB_DYNAMIC_BRANCH, resource) from autobahn.twisted.resource import WebSocketResource, HTTPChannelHixie76Aware from twisted.web.server import Site factory = BroadcastServerFactory("ws://127.0.0.1:8888", debug=debug, debugCodePaths=debug) #если используется proxy #factory.proxy={'host': '192.168.200.105', 'port': '8088'} factory.protocol = BroadcastServerProtocol factory.setProtocolOptions(allowHixie76=True) ws_resource = WebSocketResource(factory) root.putChild("ws", ws_resource) site = Site(root) site.protocol = HTTPChannelHixie76Aware listenWS(factory) reactor.run()
def gen_site(): env = Environment(loader=PackageLoader('web', 'html')) web = Resource() web.putChild('', Index(env)) web.putChild('json', Json()) web.putChild('static', static.File('./html')) return Site(web)
def run_twisted(apps, port, static_dir='.'): """Twisted wrapper for the rpclib.server.wsgi.Application Takes a list of tuples containing application, url pairs, and a port to to listen to. """ if static_dir != None: static_dir = os.path.abspath(static_dir) logging.info("registering static folder %r on /" % static_dir) root = twisted.web.static.File(static_dir) else: root = Resource() for app, url in apps: resource = WSGIResource(reactor, reactor, app) logging.info("registering %r on /%s" % (app, url)) root.putChild(url, resource) site = twisted.web.server.Site(root) reactor.listenTCP(port, site) logging.info("listening on: 0.0.0.0:%d" % port) return reactor.run()
def test_posted(self): root = Resource() collector = Collector() root.putChild(b"foo", collector) from twisted.internet import reactor while True: try: port = reactor.listenTCP(0, Site(root)) except: pass else: self.addCleanup(port.stopListening) port_number = port.getHost().port break fluentd_url = URL( scheme="http", host="127.0.0.1", port=port_number, path=["foo"], ) agent = Agent(reactor) destination = FluentdDestination(agent, fluentd_url) destination({"hello": "world"}) def check(): self.assertEquals(collector.collected, [b'json={"hello": "world"}']) return deferLater(reactor, 0.1, check)
def __init__(self, config, port=None): super(SchedulerServer, self).__init__(config) self.setupJobQueue(config) self.setupIdentityQueue(config) self.setupMySQL(config) # HTTP interface resource = Resource() self.function_resource = Resource() resource.putChild("function", self.function_resource) if port is None: port = config["scheduler_server_port"] self.site_port = reactor.listenTCP(port, server.Site(resource)) self.identity_enabled = config.get("identity_enabled", False) # Logging, etc self.expose(self.removeFromJobsHeap) self.expose(self.addToJobsHeap) self.expose(self.addToIdentityHeap) self.expose(self.removeFromIdentityHeap) self.expose(self.enqueueJobUUID) # setup manhole manhole_namespace = { 'service': self, 'globals': globals(), } reactor.listenTCP(config["manhole_scheduler_port"], self.getManholeFactory(manhole_namespace, admin=config["manhole_password"]))
def _testRender(self, uri, expectedURI): """ Check that a request pointing at C{uri} produce a new proxy connection, with the path of this request pointing at C{expectedURI}. """ root = Resource() reactor = MemoryReactor() resource = ReverseProxyResource("127.0.0.1", 1234, "/path", reactor) root.putChild("index", resource) site = Site(root) transport = StringTransportWithDisconnection() channel = site.buildProtocol(None) channel.makeConnection(transport) # Clear the timeout if the tests failed self.addCleanup(channel.connectionLost, None) channel.dataReceived("GET %s HTTP/1.1\r\nAccept: text/html\r\n\r\n" % (uri,)) # Check that one connection has been created, to the good host/port self.assertEquals(len(reactor.tcpClients), 1) self.assertEquals(reactor.tcpClients[0][0], "127.0.0.1") self.assertEquals(reactor.tcpClients[0][1], 1234) # Check the factory passed to the connect, and its given path factory = reactor.tcpClients[0][2] self.assertIsInstance(factory, ProxyClientFactory) self.assertEquals(factory.rest, expectedURI) self.assertEquals(factory.headers["host"], "127.0.0.1:1234")
def __init__(self): root = Resource() ## downloads server -- client grabs patch info from here root.putChild('u', VirtualFile('webRoot/downloads/u')) ## MOST OF THE BELOW DONT WORK SO ARE COMMENTED OUT ## redalert3pc.sake.gamespy.com sakeStorageServer = Resource() sakeStorageServer.putChild('StorageServer.asmx', StorageServer()) #root.putChild('SakeStorageServer', sakeStorageServer) ## redalert3pc.auth.pubsvs.gamespy.com -- used to auth before reporting results authService = Resource() authService.putChild('AuthService.asmx', AuthService()) #root.putChild('AuthService', authService) ## redalert3pc.comp.pubsvs.gamespy.com -- used to report match results compSvc = Resource() compSvc.putChild('competitionservice.asmx', CompetitionService()) #compSvc.putChild('CompetitionService.asmx', CompetitionService()) root.putChild('competitionservice', compSvc) #root.putChild('CompetitionService', compSvc) ## TODO: psweb.gamespy.com -- SOAP service that serves Clan-related requests ## TODO: redalert3services.gamespy.com -- HTTP GET requests that serve rank icons ## /GetPlayerRankIcon.aspx?gp=fgErop[sap9faZeJJELRac__&pid=<pid of player> retrieves that player's rank icon ## /GetPlayerLadderRatings.aspx?gp=fgErop[sap9faZeJJELRac__ retrieves CSV of ladder ratings Site.__init__(self, root)
def __init__(self): Resource.__init__(self) Loggable.__init__(self) log = Resource() log.putChild("client", LogClientResource()) self.putChild("log", log)
def create_web_service(trompet, config): "Creates the web service. Returns a tuple (service, site)." site = Resource() trompet.web = site site.putChild("", Root()) service = internet.TCPServer(config["web"]["port"], server.Site(site)) service.setServiceParent(trompet)
def test(): import sys from twisted.internet import reactor from twisted.python.log import startLogging from twisted.web.server import Site startLogging(sys.stderr) properties = { 'playlist-entry': [ {'stream-url': 'http://example.com/iphone/low/stream.m3u8', 'bitrate': 100000}, {'stream-url': 'http://example.com/iphone/medium/stream.m3u8', 'bitrate': 200000}, {'stream-url': 'http://example.com/iphone/high/stream.m3u8', 'bitrate': 400000}, ]} root = Resource() mount_point = Resource() playlist = PlaylistResource(properties['playlist-entry']) root.putChild('test', mount_point) mount_point.putChild('main.m3u8', playlist) site = Site(root) reactor.listenTCP(8080, site) reactor.run()
def __init__(self, irc): ''' Initialize the twisted web server with the proper ports and URI values. ''' callbacks.Plugin.__init__(self, irc) if not reactor: self.irc.error('Twisted is not installed.') root = Resource() pathmaps = self.registryValue('pathmaps') path_dict = {} for i in range(0, len(pathmaps), 2): path_dict[pathmaps[i]] = pathmaps[i+1] for uri, channel in path_dict.items(): post_page = PostPage(irc) post_page.set_channel(channel) root.putChild(uri, post_page) factory = Site(root) reactor.listenTCP(self.registryValue('port'), factory)
def __init__(self, config): Resource.__init__(self) self._triggerid = reactor.addSystemEventTrigger('before', 'shutdown', self.shutdownEvent) # Create Envisalink client connection self._envisalinkClientFactory = EnvisalinkClientFactory(config) self._envisaconnect = reactor.connectTCP(config.ENVISALINKHOST, config.ENVISALINKPORT, self._envisalinkClientFactory) # Store config self._config = config root = Resource() rootFilePath = sys.path[0] + os.sep + 'ext' root.putChild('app', File(rootFilePath)) root.putChild('img', File(rootFilePath)) root.putChild('api', self) factory = Site(root) # conditionally import twisted ssl to help avoid unwanted depdencies and import issues on some systems if config.LISTENTYPE.lower() == "tcp": self._port = reactor.listenTCP(config.LISTENPORT, factory) elif config.LISTENTYPE.lower() == "ssl": from twisted.internet import ssl self._port = reactor.listenSSL(config.LISTENPORT, factory, ssl.DefaultOpenSSLContextFactory(config.KEYFILE, config.CERTFILE)) else: logging.warning("AlarmServer listen type %s unknown, server not started.", config.LISTENTYPE)
def startService(self): app = self._prov_service.app dhcp_request_processing_service = self._dhcp_process_service.dhcp_request_processing_service if self._config['general.rest_authentication']: credentials = (self._config['general.rest_username'], self._config['general.rest_password']) server_resource = new_restricted_server_resource(app, dhcp_request_processing_service, credentials) logger.info('Authentication is required for REST API') else: server_resource = new_server_resource(app, dhcp_request_processing_service) logger.warning('No authentication is required for REST API') root_resource = Resource() root_resource.putChild('provd', server_resource) rest_site = Site(root_resource) port = self._config['general.rest_port'] interface = self._config['general.rest_ip'] if interface == '*': interface = '' logger.info('Binding HTTP REST API service to "%s:%s"', interface, port) if self._config['general.rest_ssl']: logger.info('SSL enabled for REST API') context_factory = ssl.DefaultOpenSSLContextFactory(self._config['general.rest_ssl_keyfile'], self._config['general.rest_ssl_certfile']) self._tcp_server = internet.SSLServer(port, rest_site, context_factory, interface=interface) else: self._tcp_server = internet.TCPServer(port, rest_site, interface=interface) self._tcp_server.startService() Service.startService(self)
def setUp(self): super(FlockerDeployTests, self).setUp() ca_set, _ = get_credential_sets() self.certificate_path = FilePath(self.mktemp()) self.certificate_path.makedirs() ca_set.copy_to(self.certificate_path, user=True) self.persistence_service = ConfigurationPersistenceService( reactor, FilePath(self.mktemp())) self.persistence_service.startService() self.cluster_state_service = ClusterStateService(reactor) self.cluster_state_service.startService() self.cluster_state_service.apply_changes([ NodeState(uuid=uuid4(), hostname=ip) for ip in COMPLEX_DEPLOYMENT_YAML[u"nodes"].keys() ]) self.addCleanup(self.cluster_state_service.stopService) self.addCleanup(self.persistence_service.stopService) app = ConfigurationAPIUserV1(self.persistence_service, self.cluster_state_service).app api_root = Resource() api_root.putChild('v1', app.resource()) # Simplest possible TLS context that presents correct control # service certificate; no need to validate flocker-deploy here. self.port = reactor.listenSSL( 0, Site(api_root), DefaultOpenSSLContextFactory( ca_set.path.child(b"control-127.0.0.1.key").path, ca_set.path.child(b"control-127.0.0.1.crt").path), interface="127.0.0.1") self.addCleanup(self.port.stopListening) self.port_number = self.port.getHost().port
def start_server(port, destport): revproxy = ReverseProxyResource("127.0.0.1", destport, "/blobs") resource = Resource() resource.putChild("", DummyResource()) resource.putChild("blobs", revproxy) site = Site(resource) reactor.listenTCP(port, site)
def run_server(fd=None, port=None, procs=None, verbose=False): if args.verbose: log.startLogging(stdout) environ['SOLEDAD_LOG_TO_STDOUT'] = '1' config = get_config() path = config["blobs_path"] if not port: port = int(config["blobs_port"]) root = Resource() root.putChild('blobs', BlobsResource("filesystem", path)) factory = Site(root) if fd is None: # Create a new listening port and several other # processes to help out. if procs is None: procs = cpu_count() log.msg('A total of %d processes will listen on port %d.' % (procs, port)) port = reactor.listenTCP(port, factory) for i in range(procs - 1): reactor.spawnProcess( None, executable, [executable, __file__, str(port.fileno())], childFDs={0: 0, 1: 1, 2: 2, port.fileno(): port.fileno()}, env=environ) else: # Another process created the port, just start listening on it. log.msg('Adopting file descriptor %d...' % fd) port = reactor.adoptStreamPort(fd, AF_INET, factory) reactor.run()
def get_provider_factory(): """ Instantiates a Site that serves the resources that we expect from a valid provider. Listens on: * port 8000 for http connections * port 8443 for https connections :rparam: factory for a site :rtype: Site instance """ root = Data("", "") root.putChild("", root) root.putChild("provider.json", FileModified( os.path.join(_here, "test_provider.json"))) config = Resource() config.putChild( "eip-service.json", FileModified( os.path.join(_here, "eip-service.json"))) apiv1 = Resource() apiv1.putChild("config", config) apiv1.putChild("sessions", API_Sessions()) apiv1.putChild("users", FakeUsers(None)) apiv1.putChild("cert", FileModified( os.path.join(_here, 'openvpn.pem'))) root.putChild("1", apiv1) factory = Site(root) return factory
def _put_plugin_resources(client_resource): # Plugin resources and plugin info load_list_css = [] load_list_js = [] mode_table = {} plugin_resources = Resource() client_resource.putChild('plugins', plugin_resources) for resource_def in getPlugins(IClientResourceDef, shinysdr.plugins): # Add the plugin's resource to static serving plugin_resources.putChild(resource_def.key, resource_def.resource) plugin_resource_url = '/client/plugins/' + urllib.quote(resource_def.key, safe='') + '/' # Tell the client to load the plugins # TODO constrain path values to be relative (not on a different origin, to not leak urls) if resource_def.load_css_path is not None: load_list_css.append(plugin_resource_url + resource_def.load_cs_path) if resource_def.load_js_path is not None: # TODO constrain value to be in the directory load_list_js.append(plugin_resource_url + resource_def.load_js_path) for mode_def in get_modes(): mode_table[mode_def.mode] = { u'info_enum_row': mode_def.info.to_json(), u'can_transmit': mode_def.mod_class is not None } # Client gets info about plugins through this resource client_resource.putChild('plugin-index.json', static.Data(serialize({ u'css': load_list_css, u'js': load_list_js, u'modes': mode_table, }).encode('utf-8'), 'application/json'))
def bravo_site(services): # extract worlds and non-world services only once at startup worlds = {} other_services = {} for name, service in services.iteritems(): factory = service.args[1] if isinstance(factory, BravoFactory): worlds[factory.name] = factory else: # XXX: do we really need those ? other_services[name] = factory # add site root root = Resource() root.putChild('', BravoResource(BravoRootElement(worlds, other_services))) # add world sub pages and related plugins for world, factory in worlds.iteritems(): # Discover parameterized plugins. plugins = retrieve_plugins(IWorldResource, parameters={"factory": factory}) # add sub page child = BravoResource(BravoWorldElement(factory, plugins), False) root.putChild(world, child) # add plugins for name, resource in plugins.iteritems(): # add plugin page child.putChild(name, resource) # create site site = Site(root) return site
def start_test_site(port_no=0): root = Resource() root.putChild("", DemoIndex()) root.putChild("item", DemoPageGetter()) factory = Site(root) port = reactor.listenTCP(port_no, factory, interface="127.0.0.1") return port
def __init__(self,service_config, hwios_config): self.hwios_config = hwios_config self.config = service_config root = Resource() root.putChild("tiles",TileService(os.path.join(self.config.location,self.config.get('map','tilepath')))) site = server.Site(root) site.displayTracebacks = False self.config.tilepath = os.path.join(self.config.location,'tiles') self.tiler = Tiler(self.config) self.get_client_settings() #override hwios general ssl setting if self.hwios_config.has_option('general','ssl'): from twisted.internet import ssl from hwios.core.connection import ServerContextFactory self.__service = SSLServer(self.config.getint('service', 'port'),site,ServerContextFactory()) else: if self.config.getboolean('service','ssl'): from twisted.internet import ssl from hwios.core.connection import ServerContextFactory self.client_settings['ssl'] = True self.__service = SSLServer(self.config.getint('service', 'port'),site,ServerContextFactory()) else: self.client_settings['ssl'] = False self.__service = TCPServer(self.config.getint('service','port'),site,100,self.config.get('service','listen'))
def create_api_service(persistence_service, cluster_state_service, endpoint, context_factory, clock=reactor): """ Create a Twisted Service that serves the API on the given endpoint. :param ConfigurationPersistenceService persistence_service: Service for retrieving and setting desired configuration. :param ClusterStateService cluster_state_service: Service that knows about the current state of the cluster. :param endpoint: Twisted endpoint to listen on. :param context_factory: TLS context factory. :param IReactorTime clock: The clock to use for time. By default global reactor. :return: Service that will listen on the endpoint using HTTP API server. """ api_root = Resource() user = ConfigurationAPIUserV1(persistence_service, cluster_state_service, clock) api_root.putChild('v1', user.app.resource()) api_root._v1_user = user # For unit testing purposes, alas return StreamServerEndpointService( endpoint, TLSMemoryBIOFactory( context_factory, False, Site(api_root) ) )
def build_resource(): root = Resource() for key, val in RESOURCE_MAPPING.iteritems(): root.putChild(key, val) return root
def main(): #config par défaut puis parsing des args TIMEOUT = 3600 # timeout des joueurs (60s en temps normal suffisent,3600 pourle debug) LOG_CONF = 'log.cfg' # Fichier de configuration du log CHECK_AUTO = False # Interdire les auto-échanges MASTER_CODE = '{0:x}'.format(random.getrandbits(64)) # Master code aléatoire for arg in sys.argv[1:]: var = arg.split('=') if len(var) == 2: if var[0]=='timeout' and var[1].isdigit: TIMEOUT = int(var[1]) elif var[0]=='log_conf': LOG_CONF=var[1] elif var[0]=='check_auto' and var[1] in ['true','false']: CHECK_AUTO = ('true'==var[1]) elif var[0]=='master_code': MASTER_CODE = var[1] else: print "Argument Invalide !", arg else: print "Argument Invalide !", arg # Lancement du serveur à la page index.php et sur le port 80 (fixé par le jeu) root = Resource() root.putChild("index.php", Serveur(TIMEOUT,LOG_CONF,CHECK_AUTO,MASTER_CODE)) factory = Site(root) reactor.listenTCP(80, factory) reactor.run()
def __init__(self, config, port=None): super(IdentityServer, self).__init__(config) self.plugin_mapping = config["plugin_mapping"] self.setupMySQL(config) self.setupIdentityQueue(config) self.cassandra_cf_identity = config["cassandra_cf_identity"] self.cassandra_cf_connections = config["cassandra_cf_connections"] self.cassandra_cf_recommendations = config["cassandra_cf_recommendations"] self.cassandra_cf_reverse_recommendations = config["cassandra_cf_reverse_recommendations"] self.cassandra_client = CassandraClusterPool( config["cassandra_servers"], keyspace=config["cassandra_keyspace"], pool_size=len(config["cassandra_servers"]) * 2) self.cassandra_client.startService() resource = Resource() self.function_resource = Resource() resource.putChild("function", self.function_resource) if port is None: port = config["identity_server_port"] self.site_port = reactor.listenTCP(port, server.Site(resource)) self.expose(self.updateConnections) self.expose(self.updateAllConnections) self.expose(self.updateAllIdentities) self.expose(self.getRecommendations) self.expose(self.getReverseRecommendations) self.expose(self.updateIdentity) # setup manhole manhole_namespace = { 'service': self, 'globals': globals(), } reactor.listenTCP(config["manhole_identity_port"], self.getManholeFactory(manhole_namespace, admin=config["manhole_password"]))
class XMLRPCService(server.Site): def __init__(self, port=None): self._port = port or get_random_port() self._addrs = [] self._root = Resource() self._root.putChild('XMLRPC', XMLRPCResource(self._root)) server.Site.__init__(self, self._root) def log(self, request): log.info('%s http://localhost:%d%s' % (request.method, self._port, request.uri)) @property def port(self): return self._port def serve(self): log.info('Listening on port %d' % (self._port, )) reactor.listenTCP(self._port, self) def is_active(self): return len(self._addrs) def stop(self): self._service.stopFactory()
def main(): root = Resource() root.putChild("test", TestPage(redis_pool, mysql_pool)) factory = Site(root) reactor.listenTCP(8880, factory) reactor.run()
def run_web_server(): root = Resource() root.putChild("cmd", restful_cmd.Cmd()) factory = Site(root) reactor.listenTCP(Config.REST_LISTEN_PORT, factory) reactor.run()
def _put_plugin_resources(wcommon, client_resource): """Plugin-defined resources and client-configuration.""" load_list_css = [] load_list_js = [] mode_table = {} plugin_resources = Resource() client_resource.putChild('plugins', plugin_resources) for resource_def in getPlugins(_IClientResourceDef, shinysdr.plugins): # Add the plugin's resource to static serving plugin_resources.putChild(resource_def.key, resource_def.resource) plugin_resource_url = '/client/plugins/' + urllib.parse.quote(resource_def.key, safe='') + '/' # Tell the client to load the plugins # TODO constrain path values to be relative (not on a different origin, to not leak urls) if resource_def.load_css_path is not None: load_list_css.append(plugin_resource_url + resource_def.load_cs_path) if resource_def.load_js_path is not None: # TODO constrain value to be in the directory load_list_js.append(plugin_resource_url + resource_def.load_js_path) for mode_def in get_modes(): mode_table[mode_def.mode] = { u'info_enum_row': mode_def.info.to_json(), u'can_transmit': mode_def.mod_class is not None } plugin_index = { 'css': load_list_css, 'js': load_list_js, 'modes': mode_table, } client_resource.putChild('client-configuration', ClientConfigurationResource(wcommon, plugin_index))
def create_root(config): from scrapy import log from scrapy.settings import CrawlerSettings from slyd.crawlerspec import (CrawlerSpecManager, create_crawler_spec_resource) from slyd.bot import create_bot_resource import slyd.settings from slyd.projects import ProjectsResource root = Resource() root.putChild("static", File(config['docroot'])) crawler_settings = CrawlerSettings(settings_module=slyd.settings) spec_manager = CrawlerSpecManager(crawler_settings) # add project management at /projects projects = ProjectsResource(crawler_settings) root.putChild('projects', projects) # add crawler at /projects/PROJECT_ID/bot log.msg("Slybot specs loading from %s/[PROJECT]" % spec_manager.basedir, level=log.DEBUG) projects.putChild("bot", create_bot_resource(spec_manager)) # add spec at /projects/PROJECT_ID/spec spec = create_crawler_spec_resource(spec_manager) projects.putChild("spec", spec) return root
def main(args): register_stack_trace_dump() burninate_gc_collector() config_environ() try_remove_old_prom_file(args.log + "/gpu_exporter.prom") try_remove_old_prom_file(args.log + "/job_exporter.prom") try_remove_old_prom_file(args.log + "/docker.prom") try_remove_old_prom_file(args.log + "/time.prom") try_remove_old_prom_file(args.log + "/configured_gpu.prom") configured_gpu_counter.set(get_gpu_count("/gpu-config/gpu-configuration.json")) decay_time = datetime.timedelta(seconds=args.interval * 2) # used to exchange gpu info between GpuCollector and ContainerCollector gpu_info_ref = collector.AtomicRef(decay_time) # used to exchange docker stats info between ContainerCollector and ZombieCollector stats_info_ref = collector.AtomicRef(decay_time) # used to exchange zombie info between GpuCollector and ZombieCollector zombie_info_ref = collector.AtomicRef(decay_time) interval = args.interval # Because all collector except container_collector will spent little time in calling # external command to get metrics, so they need to sleep 30s to align with prometheus # scrape interval. The 99th latency of container_collector loop is around 20s, so it # should only sleep 10s to adapt to scrape interval collector_args = [ ("docker_daemon_collector", interval, decay_time, collector.DockerCollector), ("gpu_collector", interval, decay_time, collector.GpuCollector, gpu_info_ref, zombie_info_ref, args.threshold), ("container_collector", max(0, interval - 18), decay_time, collector.ContainerCollector, gpu_info_ref, stats_info_ref, args.interface), ("zombie_collector", interval, decay_time, collector.ZombieCollector, stats_info_ref, zombie_info_ref), ("process_collector", interval, decay_time, collector.ProcessCollector), ] refs = list(map(lambda x: collector.make_collector(*x), collector_args)) REGISTRY.register(CustomCollector(refs)) root = Resource() root.putChild(b"metrics", MetricsResource()) root.putChild(b"healthz", HealthResource()) factory = Site(root) reactor.listenTCP(int(args.port), factory) reactor.run()
async def start_listening(self) -> None: from synapse.handlers import acme_issuing_service # Configure logging for txacme, if you need to debug # from eliot import add_destinations # from eliot.twisted import TwistedDestination # # add_destinations(TwistedDestination()) well_known = Resource() self._issuer = acme_issuing_service.create_issuing_service( self.reactor, acme_url=self.hs.config.acme_url, account_key_file=self.hs.config.acme_account_key_file, well_known_resource=well_known, ) responder_resource = Resource() responder_resource.putChild(b".well-known", well_known) responder_resource.putChild(b"check", static.Data(b"OK", b"text/plain")) srv = server.Site(responder_resource) bind_addresses = self.hs.config.acme_bind_addresses for host in bind_addresses: logger.info("Listening for ACME requests on %s:%i", host, self.hs.config.acme_port) try: self.reactor.listenTCP(self.hs.config.acme_port, srv, backlog=50, interface=host) except twisted.internet.error.CannotListenError as e: check_bind_error(e, host, bind_addresses) # Make sure we are registered to the ACME server. There's no public API # for this, it is usually triggered by startService, but since we don't # want it to control where we save the certificates, we have to reach in # and trigger the registration machinery ourselves. self._issuer._registered = False try: await self._issuer._ensure_registered() except Exception: logger.error(ACME_REGISTER_FAIL_ERROR) raise
def prometheus_exporter(reactor, port_string): """ Create an ``IService`` that exposes Prometheus metrics from this process on an HTTP server on the given port. """ parent = MultiService() root = Resource() root.putChild(b"metrics", MetricsResource()) StreamServerEndpointService( serverFromString(reactor, port_string), Site(root), ).setServiceParent(parent) _ExtraMetrics().setServiceParent(parent) return parent
def test_lose_connection(self): """ We log the URI correctly redacted when we lose the connection. """ class HangingResource(Resource): """ A Resource that strategically hangs, as if it were processing an answer. """ def render(self, request): return NOT_DONE_YET # Set up a logging handler that we can inspect afterwards output = StringIO() handler = logging.StreamHandler(output) logger.addHandler(handler) old_level = logger.level logger.setLevel(10) self.addCleanup(logger.setLevel, old_level) self.addCleanup(logger.removeHandler, handler) # Make a resource and a Site, the resource will hang and allow us to # time out the request while it's 'processing' base_resource = Resource() base_resource.putChild(b'', HangingResource()) site = SynapseSite("test", "site_tag", {}, base_resource, "1.0") server = site.buildProtocol(None) client = AccumulatingProtocol() client.makeConnection(FakeTransport(server, self.reactor)) server.makeConnection(FakeTransport(client, self.reactor)) # Send a request with an access token that will get redacted server.dataReceived(b"GET /?access_token=bar HTTP/1.0\r\n\r\n") self.pump() # Lose the connection e = Failure(Exception("Failed123")) server.connectionLost(e) handler.flush() # Our access token is redacted and the failure reason is logged. self.assertIn("/?access_token=<redacted>", output.getvalue()) self.assertIn("Failed123", output.getvalue())
def start_server(): root = Resource() root.putChild('launch', Launch()) root.putChild('start_mission', StartMission()) root.putChild('cancel_mission', CancelMission()) root.putChild('rtl', RTL()) factory = Site(root) endpoint = endpoints.TCP4ServerEndpoint(reactor, 8000) endpoint.listen(factory) reactor.run()
def test_start_responding(self): """ Calling ``start_responding`` makes an appropriate resource available. """ token = b'BWYcfxzmOha7-7LoxziqPZIUr99BCz3BfbN9kzSFnrU' challenge = challenges.HTTP01(token=token) response = challenge.response(RSA_KEY_512) responder = HTTP01Responder() challenge_resource = Resource() challenge_resource.putChild(b'acme-challenge', responder.resource) root = Resource() root.putChild(b'.well-known', challenge_resource) client = StubTreq(root) encoded_token = challenge.encode('token') challenge_url = URL( host=u'example.com', path=[u'.well-known', u'acme-challenge', encoded_token]).asText() # We got page not found while the challenge is not yet active. result = yield client.get(challenge_url) self.assertEqual(404, result.code) # Once we enable the response. responder.start_responding(u'example.com', challenge, response) result = yield client.get(challenge_url) self.assertEqual(200, result.code) self.assertEqual(['text/plain'], result.headers.getRawHeaders('content-type')) result = yield result.content() self.assertEqual(response.key_authorization.encode('utf-8'), result) # Starting twice before stopping doesn't break things responder.start_responding(u'example.com', challenge, response) result = yield client.get(challenge_url) self.assertEqual(200, result.code) yield responder.stop_responding(u'example.com', challenge, response) result = yield client.get(challenge_url) self.assertEqual(404, result.code)
def __init__(self, bridge, port, homeserver_url, homeserver_domain, botname, token_as, token_hs, debug=False): self.bridge = bridge self.homeserver_url = homeserver_url self.homeserver_domain = homeserver_domain self.token_as = token_as self.token_hs = token_hs if botname[0] == '@': botname = botname[1:] if ':' in botname: botname, domain = botname.split(':', 1) if domain != homeserver_domain: raise ValueError("Bot domain doesn't match homeserver") self.bot_username = botname self.bot_fullname = '@%s:%s' % (botname, homeserver_domain) # Create virtual user for bot if not self.bridge.virtualuser_exists('gitter'): log.info("Creating user gitter") d = self.matrix_request('POST', '_matrix/client/r0/register', { 'type': 'm.login.application_service', 'username': '******' }) self.bridge.add_virtualuser('gitter') d.addErrback( Errback( log, "Error creating user 'gitter' for the " "bridge; usage over federated rooms " "might not work correctly")) root = Resource() root.putChild('transactions', Transaction(self)) root.putChild('users', Users(self)) site = Site(root) site.displayTracebacks = debug site.logRequest = True reactor.listenTCP(port, site)
def main(): parser = argparse.ArgumentParser(description='VMWare metrics exporter for Prometheus') parser.add_argument('-c', '--config', dest='config_file', default='config.yml', help="configuration file") parser.add_argument('-p', '--port', dest='port', type=int, default=9272, help="HTTP port to expose metrics") args = parser.parse_args() # Start up the server to expose the metrics. root = Resource() root.putChild(b'metrics', VMWareMetricsResource(args)) root.putChild(b'healthz', VMWareMetricsResource(args)) factory = Site(root) print("Starting web server on port {}".format(args.port)) reactor.listenTCP(args.port, factory) reactor.run()
def start(self, component): """ @type component: L{HTTPFileStreamer} """ if not isinstance(component, HTTPFileStreamer): raise ComponentStartError( "A MultibitratePlug %s must be plugged into a " " HTTPFileStreamer component, not a %s" % ( self, component.__class__.__name__)) log.debug('multibitrate', 'Attaching to %r' % (component, )) props = self.args['properties'] resource = Resource() playlist = PlaylistResource(props.get('playlist-entry', []), props.get('target-bitrate', None)) resource.putChild(props.get('playlist-name', 'main.m3u8'), playlist) component.setRootResource(resource)
def __init__(self, sydent): self.sydent = sydent root = Resource() matrix = Resource() identity = Resource() root.putChild('_matrix', matrix) matrix.putChild('identity', identity) replicate = Resource() replV1 = Resource() identity.putChild('replicate', replicate) replicate.putChild('v1', replV1) replV1.putChild('push', self.sydent.servlets.replicationPush) self.factory = Site(root)
def setUp(self): super(TestHangmanWorker, self).setUp() root = Resource() # data is elephant with a UTF-8 encoded BOM # it is a sad elephant (as seen in the wild) root.putChild("word", Data('\xef\xbb\xbfelephant\r\n', 'text/html')) site_factory = Site(root) self.webserver = yield reactor.listenTCP(0, site_factory) addr = self.webserver.getHost() random_word_url = "http://%s:%s/word" % (addr.host, addr.port) self.worker = yield self.get_application({ 'worker_name': 'test_hangman', 'random_word_url': random_word_url, }) self.worker.r_server = FakeRedis()
def create_api_service(persistence_service, cluster_state_service, endpoint): """ Create a Twisted Service that serves the API on the given endpoint. :param ConfigurationPersistenceService persistence_service: Service for retrieving and setting desired configuration. :param ClusterStateService cluster_state_service: Service that knows about the current state of the cluster. :param endpoint: Twisted endpoint to listen on. :return: Service that will listen on the endpoint using HTTP API server. """ api_root = Resource() user = ConfigurationAPIUserV1(persistence_service, cluster_state_service) api_root.putChild('v1', user.app.resource()) api_root._v1_user = user # For unit testing purposes, alas return StreamServerEndpointService(endpoint, Site(api_root))
def __init__(self, sydent: "Sydent") -> None: self.sydent = sydent root = Resource() matrix = Resource() identity = Resource() root.putChild(b"_matrix", matrix) matrix.putChild(b"identity", identity) replicate = Resource() replV1 = Resource() identity.putChild(b"replicate", replicate) replicate.putChild(b"v1", replV1) replV1.putChild(b"push", self.sydent.servlets.replicationPush) self.factory = Site(root) self.factory.displayTracebacks = False
def serve(port, video_path, vtt_data, interface='', chunked=False, transcode_bitrate=None): if transcode_bitrate: video = ChunkedPipe(get_transcoder(video_path, transcode_bitrate)) elif chunked: video = ChunkedFile(video_path, defaultType=DEFAULT_MIME) else: video = File(video_path, defaultType=DEFAULT_MIME) root = Resource() root.putChild(SUB_PATH.encode('utf-8'), Data(vtt_data, 'text/vtt')) root.putChild(VIDEO_PATH.encode('utf-8'), video) endpoint = endpoints.TCP4ServerEndpoint(reactor, port, interface=interface) endpoint.listen(Site(root, requestFactory=CORSRequest)) reactor.run()
class WebServer(object): __metaclass__ = Singleton def __init__(self): self.base = Resource() self.base.putChild('', RootResource()) self.site = Site(self.base, logPath=os.devnull) self.site.noisy = False self.listener = None @property def url(self): return self.__dict__.get('url', '') def register_resource(self, path, resource): self.base.putChild(path, resource) def start(self): interface = WebServerConfig.local_ip port = WebServerConfig.local_port cert_path = WebServerConfig.certificate.normalized if WebServerConfig.certificate else None if cert_path is not None: if not os.path.isfile(cert_path): log.error('Certificate file %s could not be found' % cert_path) return try: ssl_context = DefaultOpenSSLContextFactory(cert_path, cert_path) except Exception: log.exception('Creating SSL context') log.err() return self.listener = reactor.listenSSL(port, self.site, ssl_context, backlog=511, interface=interface) scheme = 'https' else: self.listener = reactor.listenTCP(port, self.site, backlog=511, interface=interface) scheme = 'http' port = self.listener.getHost().port self.__dict__['url'] = '%s://%s:%d' % (scheme, WebServerConfig.hostname or interface.normalized, port) log.msg('Web server listening for requests on: %s' % self.url) def stop(self): if self.listener is not None: self.listener.stopListening()
class Server: def __init__(self, ip, port): self.ip = ip self.port = port self.root = Resource() def start(self): reactor.listenTCP(self.port, Site(self.root)) server = threading.Thread( target=reactor.run, kwargs={"installSignalHandlers": False}) server.start() def stop(self): if reactor.running: #reactor.callWhenRunning(reactor.stop) reactor.stop() def add_entry(self, key, path): self.root.putChild(key.encode("utf-8"), Resource()) if os.path.exists(path): file_name = os.path.basename(path) entity = File(os.path.abspath(path)) else: # assume we have a remote file parts = urllib.parse.urlparse(path) if parts.netloc == "www.youtube.com": v = pafy.new(path) match = v.getbest() file_name = v.videoid # match.title entity = Proxy(match.url) else: file_name = parts.path[1:] # remove initial '/' entity = Proxy(path) self.root.children[key.encode("utf-8")].putChild( file_name.encode("utf-8"), entity) return {key: "http://{0}:{1}/{2}/{3}".format( self.ip, self.port, key, file_name)}
def check_tls_config(self, ca_key, ca_cert, get_kubernetes): """ Verify that a TLS server configured with the given key and certificate and the Kubernetes client returned by ``get_kubernetes`` can negotiate a TLS connection. """ # Set up an HTTPS server that requires the certificate chain from the # configuration file. This, because there's no way to pry inside a # Context and inspect its state nor any easy way to make Agent talk # over an in-memory transport. from twisted.internet import reactor endpoint = SSL4ServerEndpoint( reactor, 0, CertificateOptions( privateKey=ca_key.original, certificate=ca_cert.original, trustRoot=trustRootFromCertificates([ca_cert]), ), ) root = Resource() root.putChild(b"", Data(b"success", "text/plain")) # Construct the Kubernetes client objects with a Redirectable reactor. # This is necessary because the URL we pass to the Agent we get needs # to agree with the configuration file that was already written (or it # won't select the right client certificate). Just one of the many # reasons it would be better if we didn't have to do real networking # here. redirectable = Redirectable(reactor) client = get_kubernetes(redirectable).client() agent = client.agent d = endpoint.listen(Site(root)) def listening(port): self.addCleanup(port.stopListening) redirectable.set_redirect(port.getHost().host, port.getHost().port) url = b"https://127.0.0.1:8443/" return agent.request(b"GET", url) d.addCallback(listening) return d
def run_twisted_wsgi(): from twisted.internet import reactor from twisted.web.server import Site from twisted.web.wsgi import WSGIResource from twisted.web.static import File from twisted.internet import endpoints from twisted.web.resource import Resource from twisted.web import server, static top_resource = Resource() resource = WSGIResource(reactor, reactor.getThreadPool(), app) top_resource.putChild(b'app', resource) top_resource.putChild(b'files', static.File(dir)) site = Site(top_resource) reactor.listenTCP(80, site) reactor.run(**reactor_args)
def start_server(files, serve_ip, serve_port=9000): # import sys # log.startLogging(sys.stdout) files_index, files_serve, files_urls = set_files( files, serve_ip, serve_port) root = Resource() for file_key, (file_name, file_path, file_dir) in files_index.items(): root.putChild(file_key.encode("utf-8"), Resource()) root.children[file_key.encode("utf-8")].putChild( file_name.encode("utf-8"), File(file_path)) reactor.listenTCP(serve_port, Site(root)) threading.Thread( target=reactor.run, kwargs={"installSignalHandlers": False}).start() return files_urls
def StartEnclaveService(config, enclave): try: http_port = config['EnclaveService']['HttpPort'] http_host = config['EnclaveService']['Host'] storage_url = config['StorageService']['URL'] worker_threads = config['EnclaveService'].get('WorkerThreads', 8) reactor_threads = config['EnclaveService'].get('ReactorThreads', 8) except KeyError as ke: logger.error('missing configuration for %s', str(ke)) sys.exit(-1) logger.info('enclave service started on %s:%s', http_host, http_port) logger.info('verifying_key: %s', enclave.verifying_key) logger.info('encryption_key: %s', enclave.encryption_key) logger.info('enclave_id: %s', enclave.enclave_id) logger.info('storage service: %s', storage_url) thread_pool = ThreadPool(minthreads=1, maxthreads=worker_threads) thread_pool.start() reactor.addSystemEventTrigger('before', 'shutdown', thread_pool.stop) root = Resource() root.putChild( b'info', WSGIResource(reactor, thread_pool, AppWrapperMiddleware(InfoApp(enclave, storage_url)))) root.putChild( b'initialize', WSGIResource(reactor, thread_pool, AppWrapperMiddleware(InitializeApp(enclave)))) root.putChild( b'invoke', WSGIResource(reactor, thread_pool, AppWrapperMiddleware(InvokeApp(enclave)))) root.putChild( b'verify', WSGIResource(reactor, thread_pool, AppWrapperMiddleware(VerifyApp(enclave)))) site = Site(root, timeout=60) site.displayTracebacks = True reactor.suggestThreadPoolSize(reactor_threads) signal.signal(signal.SIGQUIT, __shutdown__) signal.signal(signal.SIGTERM, __shutdown__) endpoint = TCP4ServerEndpoint(reactor, http_port, backlog=32, interface=http_host) endpoint.listen(site)
class JsonAPIResourceTests(unittest.TestCase): """Tests for :class:`bridgedb.distributors.moat.server.JsonAPIResource`.""" def setUp(self): self.pagename = b'' self.resource = server.JsonAPIResource() self.root = Resource() self.root.putChild(self.pagename, self.resource) def test_getClientIP(self): request = DummyRequest([self.pagename]) request.method = b'GET' self.resource.getClientIP(request) def test_formatDataForResponse(self): request = DummyRequest([self.pagename]) request.method = b'GET' data = { 'data': { 'version': 'wow', 'dinosaurs': 'cool', 'triceratops': 'awesome', 'velociraptors': 'terrifying', } } rendered = self.resource.formatDataForResponse(data, request) self.assertTrue(rendered) self.assertTrue(request.responseHeaders.hasHeader('content-type')) self.assertTrue(request.responseHeaders.hasHeader('server')) self.assertEqual(request.responseHeaders.getRawHeaders('content-type'), ['application/vnd.api+json']) def test_formatDataForResponse_no_data(self): request = DummyRequest([self.pagename]) request.method = b'GET' rendered = self.resource.formatDataForResponse(None, request) self.assertEqual(rendered, b'')
def makeAgentService(store): """ Returns a service which will process GatewayAMPCommands, using a socket file descripter acquired by launchd @param store: an already opened store @returns: service """ from twisted.internet import reactor sockets = launchActivateSocket("AgentSocket") fd = sockets[0] family = socket.AF_INET endpoint = AdoptedStreamServerEndpoint(reactor, fd, family) directory = store.directoryService() def becameInactive(): log.warn("Agent inactive; shutting down") reactor.stop() from twistedcaldav.config import config inactivityDetector = InactivityDetector( reactor, config.AgentInactivityTimeoutSeconds, becameInactive) root = Resource() root.putChild("gateway", AgentGatewayResource(store, directory, inactivityDetector)) # We need this service to be able to return com.apple.calendarserver, # so tell it not to suppress system accounts. directory = OpenDirectoryDirectoryService("/Local/Default", suppressSystemRecords=False) portal = Portal(AgentRealm(root, [u"com.apple.calendarserver"]), [HTTPDigestCredentialChecker(directory)]) credentialFactory = NoQOPDigestCredentialFactory("md5", "/Local/Default") wrapper = HTTPAuthSessionWrapper(portal, [credentialFactory]) site = Site(wrapper) return StreamServerEndpointService(endpoint, site)
def test_staticChildPathType(self): """ Test that passing the wrong type to putChild results in a warning, and a failure in Python 3 """ resource = Resource() child = Resource() sibling = Resource() resource.putChild("foo", child) warnings = self.flushWarnings([self.test_staticChildPathType]) self.assertEqual(len(warnings), 1) self.assertIn("Path segment must be bytes", warnings[0]["message"]) # We expect an error here because "foo" != b"foo" on Python 3+ self.assertIsInstance( resource.getChildWithDefault(b"foo", DummyRequest([])), ErrorPage) resource.putChild(None, sibling) warnings = self.flushWarnings([self.test_staticChildPathType]) self.assertEqual(len(warnings), 1) self.assertIn("Path segment must be bytes", warnings[0]["message"])
def main(reactor, duration): global interface concurrency = 10 root = Resource() root.putChild(b'', Data(b"Hello, world", "text/plain")) interface += 1 interface %= 255 port = reactor.listenTCP( 0, Site(root), backlog=128, interface='127.0.0.%d' % (interface,)) agent = Agent(reactor) client = Client(reactor, port.getHost().host, port.getHost().port, agent) d = client.run(concurrency, duration) def cleanup(passthrough): d = port.stopListening() d.addCallback(lambda ignored: passthrough) return d d.addBoth(cleanup) return d
def __init__(self, port=80): self.port = port root = Resource() root.putChild("", Redirect("generate")) root.putChild("generate", GeneratorPage()) root.putChild("manage", ManagePage()) root.putChild("download", DownloadPage()) wrapped = EncodingResourceWrapper(root, [GzipEncoderFactory()]) site = server.Site(wrapped) self.service = internet.TCPServer(self.port, site) return None
def run(self): """ TODO """ root = Resource() # TODO: add error counter root.putChild(b'metrics', MetricsResource()) factory = Site(root) reactor.listenTCP(self._prometheus_port, factory, interface='0.0.0.0') self.log.info('Start listen Prometheus (port: {prometheus_port})', prometheus_port=self._prometheus_port) reactor.listenUDP( self._gateway_port, ReceiveMetricProtocol(log=self.log, metrics=self._metrics) ) self.log.info( 'Start listen udp gateway (port: {gateway_port})', gateway_port=self._gateway_port ) reactor.run()
def init_http_server(app, ip, port, route, static_path=None): # reactor.listenTCP(port, BaseHTTPFactory(entity), interface=ip) print ip, port, route flask_site = WSGIResource(reactor, reactor.getThreadPool(), app) root = Resource() root.putChild(route, flask_site) if static_path: root.putChild('static', File(static_path)) # site_example = ReverseProxyResource('www.example.com', 80, ''.encode('utf-8')) # root.putChild('example1', site_example) # site_example = ReverseProxyResource('www.example.com', 80, '/') # root.putChild('example', site_example) reactor.listenTCP(port, Site(root), interface=ip) pass
def main(): if args.verbose: log.startLogging(sys.stdout) root = Resource() root.putChild(b"web", File("./web")) root.putChild(b"scripts", File("./scripts")) root.putChild(b"styles", File("./styles")) root.putChild(b"data", DataFetching(args.database)) factory = Site(root) endpoint = endpoints.TCP4ServerEndpoint(reactor, args.port) endpoint.listen(factory) reactor.run()
def test_response(self, code, message, headers, body): """ ``MemoryAgent.request`` returns a ``Deferred`` which fires with an ``IResponse`` provider containing the response code, message, headers, and body generated by the ``IResource`` to which the request was dispatched. """ player = Player(code, message, headers, body) root = Resource() root.putChild("", player) agent = MemoryAgent(root) response = self.successResultOf(agent.request(b"GET", b"/", Headers())) self.expectThat(response, Provides(IResponse)) self.expectThat(response.code, Equals(code)) self.expectThat(response.phrase, Equals(message)) self.expectThat(response.headers, Equals(headers)) self.expectThat(response.length, Equals(len(body))) self.expectThat(self.successResultOf(readBody(response)), Equals(body))
class CustomErrorHandlingResourceTests(unittest.TestCase): """Tests for :class:`bridgedb.distributors.moat.server.CustomErrorHandlingResource`.""" def setUp(self): self.pagename = b'' self.resource = server.CustomErrorHandlingResource() self.root = Resource() self.root.putChild(self.pagename, self.resource) def test_getChild(self): request = DummyRequest(['foo']) request.method = b'GET' response_resource = self.resource.getChild('/foo', request) self.assertTrue(response_resource) self.assertIsInstance(response_resource, server.JsonAPIErrorResource) response = response_resource.render(request) detail = json.loads(response)['errors'][0]['detail'] self.assertIn('does not implement GET http://dummy/', detail)