def test_multi_servers(manager, watcher):
pytest.importorskip("ssl")
insecure_server = Server(0, channel="insecure")
secure_server = Server(
0,
channel="secure", secure=True, certfile=CERTFILE
)
server = (insecure_server + secure_server).register(manager)
MakeQuiet().register(server)
watcher.wait("ready")
Root().register(server)
f = urlopen(insecure_server.http.base)
s = f.read()
assert s == b"Hello World!"
f = urlopen(secure_server.http.base, context=SSL_CONTEXT)
s = f.read()
assert s == b"Hello World!"
server.unregister()
watcher.wait("unregistered")
def test_unixserver(manager, watcher, tmpfile):
if pytest.PLATFORM == "win32":
pytest.skip("Unsupported Platform")
server = Server(tmpfile).register(manager)
MakeQuiet().register(server)
assert watcher.wait("ready")
Root().register(server)
assert path.basename(server.host) == "test.sock"
try:
from uhttplib import UnixHTTPConnection
client = UnixHTTPConnection(server.http.base)
client.request("GET", "/")
response = client.getresponse()
s = response.read()
assert s == b"Hello World!"
except ImportError:
pass
server.unregister()
watcher.wait("unregistered")
def __init__(self, engine_cls, debug=False, force_snmp_init=True):
super(RedisStateHandler, self).__init__()
self._state_tracker = EngineStateTracker()
logger.info("Initializing websocket server...")
# set up a web socket server
socket_conf = {
"host": os.environ.get("SIMENGINE_SOCKET_HOST"),
"port": int(os.environ.get("SIMENGINE_SOCKET_PORT")),
}
self._server = Server(
(socket_conf["host"], socket_conf["port"])).register(self)
# Worker(process=False).register(self)
Static().register(self._server)
Logger().register(self._server)
if debug:
Debugger(events=False).register(self)
self._ws = WebSocket().register(self._server)
WebSocketsDispatcher("/simengine").register(self._server)
logger.info("Initializing engine...")
self._engine = engine_cls(
force_snmp_init=force_snmp_init).register(self)
self._engine.subscribe_tracker(self._ws)
self._engine.subscribe_tracker(self._state_tracker)
# Use redis pub/sub communication
logger.info("Initializing redis connection...")
self._redis_store = redis.StrictRedis(host="localhost", port=6379)
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 main():
opts, args = parse_options()
bind = parse_bind(opts.bind)
if opts.validate:
application = (Application() + Root())
app = validator(application)
httpd = make_server(bind[0], bind[1], app)
httpd.serve_forever()
raise SystemExit(0)
manager = Manager()
opts.debug and Debugger().register(manager)
Poller = select_poller(opts.poller.lower())
Poller().register(manager)
if opts.server.lower() == "base":
BaseServer(bind).register(manager)
HelloWorld().register(manager)
else:
Server(bind).register(manager)
Root().register(manager)
docroot = os.getcwd() if not args else args[0]
Static(docroot=docroot, dirlisting=True).register(manager)
opts.passwd and Authentication(passwd=opts.passwd).register(manager)
opts.logging and Logger().register(manager)
if opts.profile and hotshot:
profiler = hotshot.Profile(".profile")
profiler.start()
if opts.debug:
print(graph(manager, name="circuits.web"))
print()
print(inspect(manager))
for i in range(opts.jobs):
manager.start(process=True)
manager.run()
if opts.profile and hotshot:
profiler.stop()
profiler.close()
stats = hotshot.stats.load(".profile")
stats.strip_dirs()
stats.sort_stats("time", "calls")
stats.print_stats(20)
def construct_graph(dodebug=False, dograph=False, dogui=False):
"""Preliminary HFOS application Launcher"""
if dodebug:
from circuits import Debugger
server = Server(("0.0.0.0", 8055))
setup_root(server)
Logger().register(server)
hfoslog("[HFOS] Beginning graph assembly.")
HFDebugger().register(server)
app = App().register(server)
# Machineroom().register(app)
navdata = NavData().register(server)
NMEAParser('localhost', 2222).register(navdata)
TileCache().register(server)
Static("/", docroot="/var/lib/hfos/static").register(server)
WebSocketsDispatcher("/websocket").register(server)
clientmanager = ClientManager().register(server)
AlertManager().register(clientmanager)
SchemaManager().register(clientmanager)
ObjectManager().register(clientmanager)
Authenticator().register(clientmanager)
Chat().register(clientmanager)
MapViewManager().register(clientmanager)
LayerManager().register(clientmanager)
RemoteControlManager().register(clientmanager)
WebDemo().register(clientmanager)
Wiki().register(clientmanager)
# CameraManager().register(clientmanager)
# Logger().register(server)
if dodebug:
dbg = Debugger()
dbg.IgnoreEvents.extend(["write", "_write", "streamsuccess"])
# dbg.register(lm)
if dograph:
from circuits.tools import graph
graph(server)
if dogui:
import webbrowser
webbrowser.open("http://127.0.0.1:8055")
hfoslog("[HFOS] Graph assembly done.")
return server
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()
def test_unixserver(manager, watcher, tmpdir):
if pytest.PLATFORM == "win32":
pytest.skip("Unsupported Platform")
sockpath = tmpdir.ensure("test.sock")
socket = str(sockpath)
server = Server(socket).register(manager)
MakeQuiet().register(server)
watcher.wait("ready")
Root().register(server)
assert path.basename(server.host) == "test.sock"
server.unregister()
watcher.wait("unregistered")
def _start_server(self, *args):
self.log("Starting server", args, lvl=warn)
secure = self.certificate is not None
if secure:
self.log("Running SSL server with cert:", self.certificate)
else:
self.log("Running insecure server without SSL!", lvl=warn)
try:
self.server = Server(
(self.host, self.port),
secure=secure,
certfile=self.certificate # ,
# inherit=True
).register(self)
except PermissionError:
self.log('Could not open (privileged?) port, check '
'permissions!', lvl=critical)
def _start_server(self):
"""Run the node local server"""
self.log("Starting server")
secure = self.certificate is not None
if secure:
self.log("Running SSL server with cert:", self.certificate)
else:
self.log(
"Running insecure server without SSL. Do not use without SSL "
"proxy in production!",
lvl=warn,
)
try:
self.server = Server(
(self.host, self.port),
display_banner=False,
secure=secure,
certfile=self.certificate # ,
# inherit=True
).register(self)
except PermissionError as e:
if self.port <= 1024:
self.log(
"Could not open privileged port (%i), check permissions!" %
self.port,
e,
lvl=critical,
)
else:
self.log("Could not open port (%i):" % self.port,
e,
lvl=critical)
except OSError as e:
if e.errno == 98:
self.log("Port (%i) is already opened!" % self.port,
lvl=critical)
else:
self.log("Could not open port (%i):" % self.port,
e,
lvl=critical)
def test_server(manager, watcher):
server = Server(0).register(manager)
MakeQuiet().register(server)
watcher.wait("ready")
Root().register(server)
try:
f = urlopen(server.http.base)
except URLError as e:
if isinstance(e.reason, gaierror):
f = urlopen("http://127.0.0.1:9000")
else:
raise
s = f.read()
assert s == b"Hello World!"
server.unregister()
watcher.wait("unregistered")
def test_secure_server(manager, watcher):
pytest.importorskip("ssl")
server = Server(0, secure=True, certfile=CERTFILE).register(manager)
MakeQuiet().register(server)
watcher.wait("ready")
Root().register(server)
try:
f = urlopen(server.http.base, context=SSL_CONTEXT)
except URLError as e:
if isinstance(e.reason, gaierror):
f = urlopen("http://127.0.0.1:9000")
else:
raise
s = f.read()
assert s == b"Hello World!"
server.unregister()
watcher.wait("unregistered")
def ors_standalone(ctx, api_key, debug, host, port):
from circuits import Manager, Debugger
from circuits.web import Server
set_logfile('/tmp', 'mini')
set_verbosity(5)
app = Manager()
if debug:
debugger = Debugger().register(app)
ors_controller = RESTORSService(api_key=api_key, no_db=True).register(app)
try:
server = Server(
(host, port),
display_banner=False,
secure=False,
).register(app)
except PermissionError as e:
if port <= 1024:
log(
"Could not open privileged port (%i), check permissions!" %
port,
e,
lvl=critical,
)
else:
log("Could not open port (%i):" % port, e, lvl=critical)
except OSError as e:
if e.errno == 98:
log("Port (%i) is already opened!" % port, lvl=critical)
else:
log("Could not open port (%i):" % port, e, lvl=critical)
app.run()
def render_template(name, **args):
return env.get_template(name).render(args)
def get_paste(pid, line_numbers=None):
for paste in db.pastes.find({"paste_id": pid}):
code = paste["paste_content"]
return highlight(code, guess_lexer(code), HtmlFormatter())
class Root(Controller):
def GET(self, paste_id=None):
if paste_id == "about":
return render_template("about.html")
if paste_id == None:
return render_template("index.html")
else:
return render_template("paste.html",
paste_id=paste_id,
paste_content=get_paste(paste_id))
def POST(self, paste_content):
pid = str(uuid4())
db.pastes.insert({"paste_id": pid, "paste_content": paste_content})
return self.redirect("/{0}".format(pid))
(Server(("0.0.0.0", int(os.environ.get('PORT', 5000)))) + Root()).run()
def main():
(Server(("0.0.0.0", 80)) + Root()).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()
return self.redirect("/")
def tag(self, tag=None):
"""Display all documents that have the specified tag"""
return render("tag.html", tag=tag, tag_items=matching_tags(tag))
class Auth(Component):
"""
Auth class, creates http auth to protect the application from
unwanted users, currently no signup/login feature. To add users you
must edit the users dict below
"""
realm = "ToDo App"
users = {"USERNAME HERE": "PASSWORD HERE"}
@handler("request", priority=1.0)
def on_request(self, event, request, response):
if not check_auth(request, response, self.realm, self.users):
event.stop()
return digest_auth(request, response, self.realm, self.users)
# Register Root() and Auth() to app (Server()) and run the app on port 5000
port = int(os.environ.get("PORT", 5000))
app = Server(("0.0.0.0", port))
Root().register(app)
Auth().register(app)
app.run()
form_out = DynamicForm.get_form().render()
return render_template('dynamic.html', form=form_out)
def piecewise(self, *args, **kwargs):
# Generate a regular form via a classmethod to provide easy access to extra
# functionality
form = JsonForm()
# Handle regular submission of the form
if self.request.method == 'POST':
success, out = form.json_validate(kwargs, piecewise=True)
if success:
print "Whoo! We should do some sort of database stuff here..."
return out
else:
out = form.render()
return render_template('piecewise.html', form=out)
app = Server(("0.0.0.0", 5000))
from circuits import Debugger
Debugger().register(app)
Static(docroot=template_path + "../").register(app)
Root().register(app)
app.run()
def init(self, bind, url, channel=channel):
self.client = Client(url)
Server(bind).register(self)
JSONRPC(rpc_channel=self.channel).register(self)
#!/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():
opts, args = parse_options()
if opts.jit and psyco:
psyco.full()
if ":" in opts.bind:
address, port = opts.bind.split(":")
port = int(port)
else:
address, port = opts.bind, 8000
bind = (address, port)
if opts.validate:
application = (wsgi.Application() + Root())
app = validator(application)
httpd = make_server(address, port, app)
httpd.serve_forever()
raise SystemExit, 0
manager = Manager()
if opts.debug:
manager += Debugger()
poller = opts.type.lower()
if poller == "poll":
Poller = Poll
elif poller == "epoll":
if EPoll is None:
print "No epoll support available - defaulting to Select..."
Poller = Select
else:
Poller = EPoll
else:
Poller = Select
if opts.server.lower() == "base":
manager += (BaseServer(bind, poller=Poller) + HelloWorld())
else:
manager += (Server(bind, poller=Poller) + Root())
if opts.profile:
if hotshot:
profiler = hotshot.Profile(".profile")
profiler.start()
if opts.debug:
print graph(manager, name="circuits.web")
print
print inspect(manager)
if opts.mp:
from circuits.core.workers import cpus
for i in xrange(cpus() - 1):
manager.start(process=True)
manager.run()
if opts.profile and hotshot:
profiler.stop()
profiler.close()
stats = hotshot.stats.load(".profile")
stats.strip_dirs()
stats.sort_stats("time", "calls")
stats.print_stats(20)
def __iter__(self):
return self
class Root(Controller):
def index(self, num=None):
print >>sys.stderr, 'info: got connection' # TODO(pts): Where from?
if num is not None:
num = int(num)
next_num = Lprng(num).next()
return ('<a href="/?num=%d">continue with %d</a>\n' %
(next_num, next_num))
else:
return '<a href="/?num=0">start at 0</a><p>Hello, World!\n'
def ProgressReporter(delta_sec):
while True:
sys.stderr.write('.')
coio.sleep(delta_sec)
if __name__ == "__main__":
# Without this line ProgressReporter wouldn't be scheduled, and thus the
# progress dots wouldn't be printed.
patch.patch_circuits()
coio.stackless.tasklet(ProgressReporter)(0.05)
print >>sys.stderr, 'info: will listen on port 6666'
# SUXX: 127.0.1.1
(Server(6666) + Root()).run()
def init(self):
self.closed = False
self.server = Server(0).register(self)
Static("/static", DOCROOT, dirlisting=True).register(self)
def bootstrapJobRunnerComponents(app, jobRunnerComponents):
for jobRunnerComponent in jobRunnerComponents:
jobRunnerComponent.register(app)
def bootstrapGateways(app, gateways):
for gateway in gateways:
gateway.register(app)
def bootstrapDispatchers(app, dispatchers):
for dispatcher in dispatchers:
dispatcher.register(app)
def bootstrapCircuitComponents(app, circuitComponents):
for circuitComponent in circuitComponents:
circuitComponent.register(app)
app = Server((IP_ADDR, PORT))
bootstrapAppComponents(app, BOOTSTRAP_MODULES["appComponents"])
bootstrapJobRunnerComponents(app, BOOTSTRAP_MODULES["jobRunnerComponents"])
bootstrapGateways(app, BOOTSTRAP_MODULES["gateways"])
bootstrapDispatchers(app, BOOTSTRAP_MODULES["dispatchers"])
bootstrapCircuitComponents(app, BOOTSTRAP_MODULES["circuitComponents"])
webbrowser.open('http://localhost:8000')
app.run()
#!/usr/bin/env python
# stdlib
import ssl
from circuits.web import Server, Controller
class Root(Controller):
def GET(self, peer_cert=None):
return "Here's your cert %s" % peer_cert
app = Server(("0.0.0.0", 8443),
ssl=True,
certfile="server-cert.pem",
keyfile="server-key.pem",
ca_certs="ca-chain.pem",
cert_reqs=ssl.CERT_OPTIONAL)
Root().register(app)
app.run()
def done(self):
if self.session('buyer', False):
email_a = self.session['buyer']
return 'success! email has been sent to %s' % (email_a)
else:
return 'error page'
def admin(self, **kwarg):
# show admin page if user is logged in
if self.session('logged_in', False):
return 'todo'
# show login page if user is not logged in
else:
if self.request.method == 'POST':
# password for admin page set here
correctpass = '******'
# check if the password submitted is correct
if kwarg['password'] == correctpass:
# authenticate the user and redirect to admin page
self.session['logged_in'] = True
return self.redirect('/admin')
# display error page if password is not correct
else:
return 'error page'
elif self.request.method == 'GET':
return 'login page'
(Server('0.0.0.0:8000') + Root() + Sessions()).run()
@handler("request", priority=1.0)
def _on_request(self, event, request, response):
if "authorization" in request.headers:
ah = _httpauth.parseAuthorization(request.headers["authorization"])
if ah is None:
event.stop()
return HTTPError(request, response, 400)
username, password = ah["username"], ah["password"]
if check_auth(username, password):
request.login = username
return
response.headers["WWW-Authenticate"] = _httpauth.basicAuth(self.realm)
event.stop()
return Unauthorized(request, response)
class Root(Controller):
def index(self):
return "Hello, {0:s}".format(self.request.login)
app = Server(("0.0.0.0", 8000))
PasswdAuth().register(app)
Root().register(app)
app.run()
#!/usr/bin/env python
from circuits import Debugger
from circuits.web import Controller, Server, Static
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!"
app = Server(("0.0.0.0", 9000))
Debugger().register(app)
Static().register(app)
Root().register(app)
app.run()
#!/usr/bin/env python
from circuits import Debugger
from circuits.web import Controller, Server
class Root(Controller):
def index(self):
return "Hello World!"
app = Server(("0.0.0.0", 8443), secure=True, certfile="cert.pem")
Debugger().register(app)
Root().register(app)
app.run()
def setUp(self):
self.server = (Server((self.HOST, self.PORT)) + Root())
self.server.start()
