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)
