class CircuitsWebAdapter(AdapterInterface):
""" circuits.web WSGI server adapter.
"""
def setup(self, server_name, host, port, app_callback):
from circuits.web import BaseServer, Server
from circuits.lib.web.wsgi import Gateway
from circuits.web import Controller
# self._server = BaseServer(port, host)
self._server = Server(port, host)
self._server += Gateway(app_callback)
self._server += Root()
# self._server += Test()
# self._server += eventsub()
# self._server += handler()
def start(self):
self._server.start()
def stop(self):
self._server.stop()
@classmethod
def is_available(cls):
try:
from circuits.web import BaseServer
from circuits.web import Controller
from circuits.lib.web.wsgi import Gateway
return True
except:
return False
class CircuitsWebAdapter(object):
class Root(Controller):
def index(self):
return "circuits"
def eventSub(self):
return "\n"
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 start(self):
self._server.start()
def stop(self):
self._server.stop()
def application(self, environ, start_response):
if environ['SCRIPT_NAME'] == '/':
environ['SCRIPT_NAME'] = ''
environ['PATH_INFO'] = '/' + environ['PATH_INFO']
oldenviron = environ.copy()
path = wsgiref.util.shift_path_info(environ)
return self._tree[path].application(environ, start_response)
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):
Server.__init__(self, (listen, port))
Static(docroot="../html/").register(self)
DartsWSServer().register(self)
DartsServerController().register(self)
Root().register(self)
#Logger().register(Webserver)
WebSockets("/websocket").register(self)
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()
def main():
app = Server(("0.0.0.0", 8000))
Root().register(app)
Static(docroot="static").register(app)
env = Environment(loader=FileSystemLoader("templates"))
JinjaRenderer(env, defaults).register(app)
Sessions().register(app)
# LoginManager().register(app)
app.run()
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()
def setup(self, server_name, host, port, app_callback):
from circuits.web import BaseServer, Server
from circuits.lib.web.wsgi import Gateway
from circuits.web import Controller
# self._server = BaseServer(port, host)
self._server = Server(port, host)
self._server += Gateway(app_callback)
self._server += Root()
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 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 run():
port = os.environ.get("PORT", 8000)
app = Server(("0.0.0.0", int(port)))
Root().register(app)
app.run()
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()
def __init__(self):
Server.__init__(self, PORT) #"localhost", PORT)
self + WebController() + Static(docroot=PATH)
#!/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 __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.server = Server(0).register(self)
Static("/static", DOCROOT, dirlisting=True).register(self)
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 __init__(self):
log("RaspuinoDartMiniServer::__init__")
Server.__init__(self, ("0.0.0.0", 8000))
# Static(docroot=".", defaults=['RaspuinoDartMini.html']).register(self)
RaspuinoDartMiniEcho().register(self)
WebSocketsDispatcher("/websocket").register(self)
.format(hours), (dev_id, ))
resp = curr.fetchall()
logging.info("Query took %s seconds", time.time() - start_t)
except Exception as e:
logging.exception(e)
chart.add_data_series(ChartTypes.spline,
[(t, int(v)) for x, y, t, a, v in resp],
name='Power',
visible=True,
animation=False,
marker={'enabled': False},
color='black')
return SHOW_TEMPLATE.safe_substitute(container=chart.container,
chart=chart.script())
def exit(self):
logging.critical("Exit command recieved")
self.fire(stopped())
self.fire(do_exit())
return "Exiting..."
def do_exit(self):
raise SystemExit(0)
WebUIServer = Server(("0.0.0.0", 10000))
WebUI().register(WebUIServer)
# Gateway({"/foo": foo}).register(WebUIServer)
HTML = """\
<html>
<head>
<title>An example application</title>
</head>
<body>
<h1>This is my sample application</h1>
Put the content here...
<hr>
<a href="/exit">Quit</a>
</body>
</html>
"""
class Root(Controller):
def index(self):
return HTML
def exit(self):
raise SystemExit(0)
app = Server(("0.0.0.0", 8000))
Root().register(app)
app.start()
webbrowser.open("http://127.0.0.1:8000/")
app.join()
HTML = """\
<html>
<head>
<title>An example application</title>
</head>
<body>
<h1>This is my sample application</h1>
Put the content here...
<hr>
<a href="/exit">Quit</a>
</body>
</html>
"""
class Root(Controller):
def index(self):
return HTML
def exit(self):
raise SystemExit(0)
app = Server(("0.0.0.0", 8000))
Root().register(app)
app.start()
webbrowser.open("http://127.0.0.1:8000/")
app.join()
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()
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 __init__(self):
Server.__init__(self, "0.0.0.0:%d" % PORT) #"localhost", PORT)
self + WebController() + Static(docroot=SHOTPATH)
def __init__(self):
Server.__init__(self, "0.0.0.0:%d" % PORT) #"localhost", PORT)
self + WebController() + Static(docroot=SHOTPATH)
class Root(Controller):
def index(self):
"""Request Handler
Our index request handler which simply returns a response containing
the contents of our form to display.
"""
return FORM
def save(self, firstName, lastName):
"""Save Request Handler
Our /save request handler (which our form above points to).
This handler accepts the same arguments as the fields in the
form either as positional arguments or keyword arguments.
We will use the date to pretend we've saved the data and
tell the user what was saved.
"""
return "Data Saved. firstName={0:s} lastName={1:s}".format(
firstName, lastName)
app = Server(("0.0.0.0", 8000))
Root().register(app)
app.run()
def __init__(self):
Server.__init__(self, PORT) #"localhost", PORT)
self + WebController() + Static(docroot=PATH)
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()
def setUp(self):
self.server = (Server((self.HOST, self.PORT)) + Root())
self.server.start()
def init(self, bind, url, channel=channel):
self.client = Client(url)
Server(bind).register(self)
JSONRPC(rpc_channel=self.channel).register(self)
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()
class ACL(Component):
allowed = ["127.0.0.1"]
@handler("request", priority=1.0)
def on_request(self, event, request, response):
"""Filter Requests applying IP based Authorization
Filter any incoming requests at a higher priority than the
default dispatcher and apply IP based Authorization returning
a 403 Forbidden response if the Remote IP Address does not
match the allowed set.
"""
if not request.remote.ip in self.allowed:
event.stop()
return Forbidden(request, response)
class Root(Controller):
def index(self):
return "Hello World!"
app = Server(("0.0.0.0", 8000))
ACL().register(app)
Root().register(app)
app.run()
# return "SQL Error: " + e.args[0]
# conn.close()
# Alternatively you can generate license keys, email users login information
# or setup accounts upon successful payment. The status will always be "Completed" on success.
# Likewise you can revoke user access, if status is "Canceled", or another payment error.
return "Success"
# def lookup(self, id):
# if not id:
# return ierr("No Transaction Provided")
#
# conn = connect('db')
# curs = conn.cursor()
# try:
# # Pulls a record from the database matching the transaction ID
# curs.execute("""SELECT name FROM ipn WHERE txn = ? LIMIT 1""", (id,))
# row = curs.fetchone()
# ret = row[0]
# except sqerr, e:
# ret = ierr(e.args[0])
#
# # The response will either by the name of the buyer, or a SQL error message
# return ret
# Standard TCP method
(Server(("127.0.0.1", 9000)) + Paypal()).run()
# Unix Socket Method - make sure webserver can read and write to the socket file
# (Server(("ipn.sock")) + Paypal()).run()
