def webapp(request, manager, watcher):
webapp = WebApp().register(manager)
assert watcher.wait("ready")
if hasattr(request.module, "application"):
from circuits.web.wsgi import Gateway
application = getattr(request.module, "application")
Gateway({"/": application}).register(webapp)
assert watcher.wait("registered")
Root = getattr(request.module, "Root", None)
if Root is not None:
Root().register(webapp)
assert watcher.wait("registered")
def finalizer():
webapp.fire(close())
assert watcher.wait("closed")
webapp.unregister()
assert watcher.wait("unregistered")
request.addfinalizer(finalizer)
return webapp
def webapp(request):
webapp = WebApp()
if hasattr(request.module, "application"):
from circuits.web.wsgi import Gateway
application = getattr(request.module, "application")
Gateway({"/": application}).register(webapp)
Root = getattr(request.module, "Root", None)
if Root is not None:
Root().register(webapp)
if request.config.option.verbose:
Debugger().register(webapp)
waiter = pytest.WaitEvent(webapp, "ready")
webapp.start()
assert waiter.wait()
def finalizer():
webapp.fire(close(), webapp.server)
webapp.stop()
request.addfinalizer(finalizer)
return webapp
def setup(self, host, port, app_callback):
self._server = Server((host, port))
self._server += Gateway(app_callback)
self._server += self.Root()
sfile = StaticFile('test.flac',
'/mnt/nas/Anastacia/Anastacia/03 Time.flac')
self._tree = {}
self._tree[sfile.name] = sfile
def test(apps):
server = Server(0)
Gateway(apps).register(server)
waiter = pytest.WaitEvent(server, "ready")
server.start()
waiter.wait()
f = urlopen(server.http.base)
s = f.read()
assert s == b"Hello World!"
f = urlopen("{0:s}/foobar/".format(server.http.base))
s = f.read()
assert s == b"FooBar!"
server.stop()
#!/usr/bin/env python
from circuits.web.wsgi import Gateway
from circuits.web import Controller, Server
def foo(environ, start_response):
start_response("200 OK", [("Content-Type", "text/plain")])
return ["Foo!"]
class Root(Controller):
"""App Rot"""
def index(self):
return "Hello World!"
app = Server(("0.0.0.0", 10000))
Root().register(app)
Gateway({"/foo": foo}).register(app)
app.run()
def main():
config = Config()
manager = Manager()
if config.get("debug"):
manager += Debugger(
events=config.get("verbose"),
file=config.get("errorlog"),
)
environ = Environment(config)
SignalHandler(environ).register(environ)
manager += environ
if config.get("sock") is not None:
bind = config.get("sock")
elif ":" in config.get("bind"):
address, port = config.get("bind").split(":")
bind = (
address,
int(port),
)
else:
bind = (
config.get("bind"),
config.get("port"),
)
server = (Server(bind) + Sessions() + Root(environ) +
CacheControl(environ) + ErrorHandler(environ))
if MemoryMonitor is not None:
MemoryMonitor(channel="/memory").register(server)
if not config.get("disable-logging"):
server += Logger(file=config.get("accesslog", sys.stdout))
if not config.get("disable-static"):
server += Static(docroot=os.path.join(config.get("theme"), "htdocs"))
if not config.get("disable-hgweb"):
baseui = ui()
baseui.setconfig("web", "prefix", "/+hg")
baseui.setconfig("web", "style", "gitweb")
baseui.setconfig("web", "allow_push", "*")
baseui.setconfig("web", "push_ssl", False)
baseui.setconfig("web", "allow_archive", ["bz2", "gz", "zip"])
baseui.setconfig("web", "description", config.get("description"))
server += Gateway({
"/+hg":
hgweb(environ.storage.repo_path, config.get("name"), baseui)
})
if not config.get("disable-compression"):
server += Compression(environ)
if config.get("daemon"):
manager += Daemon(config.get("pidfile"))
server.register(manager)
manager.run()
class Root(Controller):
def index(self):
"""Index Request Handler
Controller(s) expose implicitly methods as request handlers.
Request Handlers can still be customized by using the ``@expose``
decorator. For example exposing as a different path.
"""
return "Hello World! (wsgi)"
# Create singleton application
wsgi_adapter = None
if not wsgi_adapter:
application = Manager(channel="app")
Debugger().register(application)
dispatcher = Dispatcher(channel="app").register(application)
Root().register(dispatcher)
wsgi_adapter = WSGIApplication(channel="app").register(application)
Thread(target=application.run).start()
if __name__ == '__main__':
server = Server(("0.0.0.0", 8888))
Gateway({"/": wsgi_adapter}).register(server)
server.run()
else:
wsgi_adapter