python-cyclone-1.1/ 0000755 0001750 0001750 00000000000 12124336260 013351 5 ustar lunar lunar python-cyclone-1.1/MANIFEST.in 0000644 0001750 0001750 00000000153 12124336260 015106 0 ustar lunar lunar include cyclone/appskel_default.zip
include cyclone/appskel_foreman.zip
include cyclone/appskel_signup.zip
python-cyclone-1.1/setup.py 0000644 0001750 0001750 00000006554 12124336260 015075 0 ustar lunar lunar #!/usr/bin/env python
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import platform
from distutils import log
from distutils.version import LooseVersion
from distutils.version import StrictVersion
requires = ["twisted"]
# Avoid installation problems on old RedHat distributions (ex. CentOS 5)
# http://stackoverflow.com/questions/7340784/easy-install-pyopenssl-error
py_version = platform.python_version()
if LooseVersion(py_version) < StrictVersion('2.6'):
distname, version, _id = platform.dist()
else:
distname, version, _id = platform.linux_distribution()
is_redhat = distname in ["CentOS", "redhat"]
if is_redhat and version and StrictVersion(version) < StrictVersion('6.0'):
requires.append("pyopenssl==0.12")
else:
requires.append("pyopenssl")
# PyPy and setuptools don't get along too well, yet.
if sys.subversion[0].lower().startswith("pypy"):
import distutils.core
setup = distutils.core.setup
extra = dict(requires=requires)
else:
import setuptools
setup = setuptools.setup
extra = dict(install_requires=requires)
try:
from setuptools.command import egg_info
egg_info.write_toplevel_names
except (ImportError, AttributeError):
pass
else:
"""
'twisted' should not occur in the top_level.txt file as this
triggers a bug in pip that removes all of twisted when a package
with a twisted plugin is removed.
"""
def _top_level_package(name):
return name.split('.', 1)[0]
def _hacked_write_toplevel_names(cmd, basename, filename):
pkgs = dict.fromkeys(
[_top_level_package(k)
for k in cmd.distribution.iter_distribution_names()
if _top_level_package(k) != "twisted"
]
)
cmd.write_file("top-level names", filename, '\n'.join(pkgs) + '\n')
egg_info.write_toplevel_names = _hacked_write_toplevel_names
setup(
name="cyclone",
version="1.1",
author="fiorix",
author_email="fiorix@gmail.com",
url="http://cyclone.io/",
license="http://www.apache.org/licenses/LICENSE-2.0",
description="Non-blocking web server. "
"A facebook's Tornado on top of Twisted.",
keywords="python non-blocking web server twisted facebook tornado",
packages=["cyclone", "twisted.plugins"],
package_data={"twisted": ["plugins/cyclone_plugin.py"],
"cyclone": ["appskel_default.zip",
"appskel_foreman.zip",
"appskel_signup.zip"]},
scripts=["scripts/cyclone"],
**extra
)
try:
from twisted.plugin import IPlugin, getPlugins
list(getPlugins(IPlugin))
except Exception, e:
log.warn("*** Failed to update Twisted plugin cache. ***")
log.warn(str(e))
python-cyclone-1.1/.gitignore 0000644 0001750 0001750 00000000110 12124336260 015331 0 ustar lunar lunar *.swp
*.pyc
*.so
*~
build
dist
cyclone.egg-info
dropin.cache
*DS_Store*
python-cyclone-1.1/demos/ 0000755 0001750 0001750 00000000000 12124336260 014460 5 ustar lunar lunar python-cyclone-1.1/demos/bottle/ 0000755 0001750 0001750 00000000000 12124336260 015751 5 ustar lunar lunar python-cyclone-1.1/demos/bottle/xmlrpc_client.py 0000644 0001750 0001750 00000001411 12124336260 021163 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import xmlrpclib
srv = xmlrpclib.Server("http://localhost:8888/xmlrpc")
print "echo:", srv.echo("hello world!")
python-cyclone-1.1/demos/bottle/README 0000644 0001750 0001750 00000001422 12124336260 016630 0 ustar lunar lunar This is a complete cyclone.bottle demo.
For a basic hello world, check out the helloworld_bottle.py demo.
The idea is to show how easy it is to create simple bottle-like apps, and
still capture all the functionality such as database support, setting
a parent class (the BaseHandler) for your request handlers and integrating with
other types of handlers such as XmlRPC and WebSocket.
The authentication mechanism is similar to the one used in
httpauthdemo_redis.py and require that the "cyclone:user" key exists in redis.
Basically, run the redis server and use the redis client to set up a fake
user account:
$ redis-cli set cyclone:root 123
Then authenticate yourself at http://localhost:8888 as root/123.
XmlRPC functionality can be tested by executing the xmlrpc_client.py.
python-cyclone-1.1/demos/bottle/bottledemo.py 0000755 0001750 0001750 00000007230 12124336260 020466 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.escape
import cyclone.redis
import cyclone.sqlite
import cyclone.util
import cyclone.web
import cyclone.websocket
import cyclone.xmlrpc
from cyclone.bottle import run, route
from twisted.internet import defer
from twisted.python import log
class BaseHandler(cyclone.web.RequestHandler):
@property
def redisdb(self):
return self.settings.db_handlers.redis
def get_current_user(self):
print "Getting user cookie"
return self.get_secure_cookie("user")
@route("/")
def index(cli):
cli.write('sign in')
@route("/auth/login")
def auth_login_page(cli):
cli.write("""
""")
@route("/auth/login", method="post")
@defer.inlineCallbacks
def auth_login(cli):
usr = cli.get_argument("usr")
pwd = cli.get_argument("pwd")
try:
redis_pwd = yield cli.redisdb.get("cyclone:%s" % usr)
except Exception, e:
log.msg("Redis failed to get('cyclone:%s'): %s" % (usr, str(e)))
raise cyclone.web.HTTPError(503) # Service Unavailable
if pwd != str(redis_pwd):
cli.write("Invalid user or password. "
'try again')
else:
cli.set_secure_cookie("user", usr)
cli.redirect(cli.get_argument("next", "/private"))
@route("/auth/logout")
@cyclone.web.authenticated
def auth_logout(cli):
cli.clear_cookie("user")
cli.redirect("/")
@route("/private")
@cyclone.web.authenticated
def private(cli):
cli.write("Hi, %s " % cli.current_user)
cli.write("""logout""")
class WebSocketHandler(cyclone.websocket.WebSocketHandler):
def connectionMade(self, *args, **kwargs):
print "connection made:", args, kwargs
def messageReceived(self, message):
self.sendMessage("echo: %s" % message)
def connectionLost(self, why):
print "connection lost:", why
class XmlrpcHandler(cyclone.xmlrpc.XmlrpcRequestHandler):
allowNone = True
def xmlrpc_echo(self, text):
return text
try:
raise Exception("COMMENT_THIS_LINE_AND_LOG_TO_DAILY_FILE")
from twisted.python.logfile import DailyLogFile
logFile = DailyLogFile.fromFullPath("server.log")
print("Logging to daily log file: server.log")
except Exception, e:
import sys
logFile = sys.stdout
run(host="127.0.0.1", port=8888,
log=logFile,
debug=True,
static_path="./static",
template_path="./template",
locale_path="./locale",
login_url="/auth/login",
cookie_secret="32oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
base_handler=BaseHandler,
db_handlers=cyclone.util.ObjectDict(
#sqlite=cyclone.sqlite.InlineSQLite(":memory:"),
redis=cyclone.redis.lazyConnectionPool(),
),
more_handlers=[
(r"/websocket", WebSocketHandler),
(r"/xmlrpc", XmlrpcHandler),
])
python-cyclone-1.1/demos/chat/ 0000755 0001750 0001750 00000000000 12124336260 015377 5 ustar lunar lunar python-cyclone-1.1/demos/chat/chatdemo.py 0000755 0001750 0001750 00000011204 12124336260 017536 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import cyclone.web
import cyclone.auth
import cyclone.escape
from twisted.python import log
from twisted.internet import reactor
import os.path
import uuid
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", MainHandler),
(r"/auth/login", AuthLoginHandler),
(r"/auth/logout", AuthLogoutHandler),
(r"/a/message/new", MessageNewHandler),
(r"/a/message/updates", MessageUpdatesHandler),
]
settings = dict(
cookie_secret="43oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
login_url="/auth/login",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=True,
autoescape=None,
)
cyclone.web.Application.__init__(self, handlers, **settings)
class BaseHandler(cyclone.web.RequestHandler):
def get_current_user(self):
user_json = self.get_secure_cookie("user")
if not user_json:
return None
return cyclone.escape.json_decode(user_json)
class MainHandler(BaseHandler):
@cyclone.web.authenticated
def get(self):
self.render("index.html", messages=MessageMixin.cache)
class MessageMixin(object):
waiters = []
cache = []
cache_size = 200
def wait_for_messages(self, callback, cursor=None):
cls = MessageMixin
if cursor:
index = 0
for i in xrange(len(cls.cache)):
index = len(cls.cache) - i - 1
if cls.cache[index]["id"] == cursor:
break
recent = cls.cache[index + 1:]
if recent:
callback(recent)
return
cls.waiters.append(callback)
def new_messages(self, messages):
cls = MessageMixin
log.msg("Sending new message to %r listeners" % len(cls.waiters))
for callback in cls.waiters:
try:
callback(messages)
except:
log.err()
cls.waiters = []
cls.cache.extend(messages)
if len(cls.cache) > self.cache_size:
cls.cache = cls.cache[-self.cache_size:]
class MessageNewHandler(BaseHandler, MessageMixin):
@cyclone.web.authenticated
def post(self):
message = {
"id": str(uuid.uuid4()),
"from": self.current_user["first_name"],
"body": self.get_argument("body"),
}
message["html"] = self.render_string("message.html", message=message)
if self.get_argument("next", None):
self.redirect(self.get_argument("next"))
else:
self.write(message)
self.new_messages([message])
class MessageUpdatesHandler(BaseHandler, MessageMixin):
@cyclone.web.authenticated
@cyclone.web.asynchronous
def post(self):
cursor = self.get_argument("cursor", None)
self.wait_for_messages(self.on_new_messages, cursor=cursor)
def on_new_messages(self, messages):
# Closed client connection
#if self.request.connection.stream.closed():
#return
self.finish(dict(messages=messages))
class AuthLoginHandler(BaseHandler, cyclone.auth.GoogleMixin):
@cyclone.web.asynchronous
def get(self):
if self.get_argument("openid.mode", None):
self.get_authenticated_user(self._on_auth)
return
self.authenticate_redirect(ax_attrs=["name"])
def _on_auth(self, user):
if not user:
raise cyclone.web.HTTPError(500, "Google auth failed")
self.set_secure_cookie("user", cyclone.escape.json_encode(user))
self.redirect("/")
class AuthLogoutHandler(BaseHandler):
def get(self):
self.clear_cookie("user")
self.write("You are now logged out")
def main():
reactor.listenTCP(8888, Application())
reactor.run()
if __name__ == "__main__":
log.startLogging(sys.stdout)
main()
python-cyclone-1.1/demos/chat/templates/ 0000755 0001750 0001750 00000000000 12124336260 017375 5 ustar lunar lunar python-cyclone-1.1/demos/chat/templates/index.html 0000644 0001750 0001750 00000002415 12124336260 021374 0 ustar lunar lunar
Tornado Chat Demo
python-cyclone-1.1/demos/chat/static/ 0000755 0001750 0001750 00000000000 12124336260 016666 5 ustar lunar lunar python-cyclone-1.1/demos/chat/static/chat.js 0000644 0001750 0001750 00000007201 12124336260 020143 0 ustar lunar lunar // Copyright 2009 FriendFeed
//
// Licensed under the Apache License, Version 2.0 (the "License"); you may
// not use this file except in compliance with the License. You may obtain
// a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
// WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
// License for the specific language governing permissions and limitations
// under the License.
$(document).ready(function() {
if (!window.console) window.console = {};
if (!window.console.log) window.console.log = function() {};
$("#messageform").live("submit", function() {
newMessage($(this));
return false;
});
$("#messageform").live("keypress", function(e) {
if (e.keyCode == 13) {
newMessage($(this));
return false;
}
});
$("#message").select();
updater.poll();
});
function newMessage(form) {
var message = form.formToDict();
var disabled = form.find("input[type=submit]");
disabled.disable();
$.postJSON("/a/message/new", message, function(response) {
updater.showMessage(response);
if (message.id) {
form.parent().remove();
} else {
form.find("input[type=text]").val("").select();
disabled.enable();
}
});
}
function getCookie(name) {
var r = document.cookie.match("\\b" + name + "=([^;]*)\\b");
return r ? r[1] : undefined;
}
jQuery.postJSON = function(url, args, callback) {
args._xsrf = getCookie("_xsrf");
$.ajax({url: url, data: $.param(args), dataType: "text", type: "POST",
success: function(response) {
if (callback) callback(eval("(" + response + ")"));
}, error: function(response) {
console.log("ERROR:", response)
}});
};
jQuery.fn.formToDict = function() {
var fields = this.serializeArray();
var json = {}
for (var i = 0; i < fields.length; i++) {
json[fields[i].name] = fields[i].value;
}
if (json.next) delete json.next;
return json;
};
jQuery.fn.disable = function() {
this.enable(false);
return this;
};
jQuery.fn.enable = function(opt_enable) {
if (arguments.length && !opt_enable) {
this.attr("disabled", "disabled");
} else {
this.removeAttr("disabled");
}
return this;
};
var updater = {
errorSleepTime: 500,
cursor: null,
poll: function() {
var args = {"_xsrf": getCookie("_xsrf")};
if (updater.cursor) args.cursor = updater.cursor;
$.ajax({url: "/a/message/updates", type: "POST", dataType: "text",
data: $.param(args), success: updater.onSuccess,
error: updater.onError});
},
onSuccess: function(response) {
try {
updater.newMessages(eval("(" + response + ")"));
} catch (e) {
updater.onError();
return;
}
updater.errorSleepTime = 500;
window.setTimeout(updater.poll, 0);
},
onError: function(response) {
updater.errorSleepTime *= 2;
console.log("Poll error; sleeping for", updater.errorSleepTime, "ms");
window.setTimeout(updater.poll, updater.errorSleepTime);
},
newMessages: function(response) {
if (!response.messages) return;
updater.cursor = response.cursor;
var messages = response.messages;
updater.cursor = messages[messages.length - 1].id;
console.log(messages.length, "new messages, cursor:", updater.cursor);
for (var i = 0; i < messages.length; i++) {
updater.showMessage(messages[i]);
}
},
showMessage: function(message) {
var existing = $("#m" + message.id);
if (existing.length > 0) return;
var node = $(message.html);
node.hide();
$("#inbox").append(node);
node.slideDown();
}
};
python-cyclone-1.1/demos/chat/static/chat.css 0000644 0001750 0001750 00000001735 12124336260 020325 0 ustar lunar lunar /*
* Copyright 2009 FriendFeed
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
body {
background: white;
margin: 10px;
}
body,
input {
font-family: sans-serif;
font-size: 10pt;
color: black;
}
table {
border-collapse: collapse;
border: 0;
}
td {
border: 0;
padding: 0;
}
#body {
position: absolute;
bottom: 10px;
left: 10px;
}
#input {
margin-top: 0.5em;
}
#inbox .message {
padding-top: 0.25em;
}
#nav {
float: right;
z-index: 99;
}
python-cyclone-1.1/demos/httpauth/ 0000755 0001750 0001750 00000000000 12124336260 016321 5 ustar lunar lunar python-cyclone-1.1/demos/httpauth/httpauthdemo_redis.py 0000755 0001750 0001750 00000005607 12124336260 022602 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import base64
import functools
import sys
import cyclone.redis
import cyclone.web
from twisted.python import log
from twisted.internet import defer, reactor
class Application(cyclone.web.Application):
def __init__(self):
# Defaults to localhost:6379, dbid=0
redisdb = cyclone.redis.lazyConnectionPool()
handlers = [
(r"/", IndexHandler, dict(redisdb=redisdb)),
]
cyclone.web.Application.__init__(self, handlers, debug=True)
def HTTPBasic(method):
@defer.inlineCallbacks
@functools.wraps(method)
def wrapper(self, *args, **kwargs):
msg = None
if "Authorization" in self.request.headers:
auth_type, data = self.request.headers["Authorization"].split()
try:
assert auth_type == "Basic"
usr, pwd = base64.b64decode(data).split(":", 1)
redis_pwd = yield self.redisdb.get("cyclone:%s" % usr)
assert pwd == str(redis_pwd) # it may come back as an int!
except AssertionError:
msg = "Authentication failed"
except cyclone.redis.ConnectionError, e:
# There's nothing we can do here. Just wait for the
# connection to resume.
log.msg("Redis is unavailable: %s" % e)
raise cyclone.web.HTTPError(503) # Service Unavailable
else:
msg = "Authentication required"
if msg:
raise cyclone.web.HTTPAuthenticationRequired(
log_message=msg, auth_type="Basic", realm="DEMO")
else:
self._current_user = usr
yield defer.maybeDeferred(method, self, *args, **kwargs)
return wrapper
class IndexHandler(cyclone.web.RequestHandler):
def initialize(self, redisdb):
self.redisdb = redisdb
@HTTPBasic
def get(self):
self.write("Hi, %s." % self._current_user)
def main():
log.startLogging(sys.stdout)
log.msg(">>>> Set the password from command line: "
"redis-cli set cyclone:root 123")
log.msg(">>>> Then authenticate as root/123 from the browser")
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/httpauth/README 0000644 0001750 0001750 00000002643 12124336260 017206 0 ustar lunar lunar HTTP Basic Authentication
httpauthdemo.py:
A very simple, pretty much useless example.
The idea is to show how to build a decorator to request valid credentials,
and send HTTP "401 Unauthorized" when necessary.
httpauthdemo_redis.py:
This is more of a real-world example, authenticating against a database,
in this case, redis. You can easily port it to standard RDBMs such as
MySQL, PostgreSQL and others, using twisted.enterprise.adbapi.
Again, it does so via the decorator, which extract credentials from Redis
and compare them against what people typed on their browser.
If you run this example without a redis-server, it will always return HTTP
503 "Service Unavailable" due to lack of communication with the database
backend. Once you start redis, it will automatically connect to it.
Make sure you create a user in redis to test the authentication system.
From the command line, run:
$ redis-cli set cyclone:root 123
Then point your browser to http://localhost:8888 and authenticate as root/123.
httpauthdemo_mongo.py:
Same as the above, but for the MongoDB database.
Make sure you have txredis installed, otherwise go grab it from GitHub:
https://github.com/fiorix/mongo-async-python-driver
Create a new user:
curl -D - -d "username=root&password=123" http://localhost:8888/createuser
Then point your browser to http://localhost:8888 and authenticate as root/123.
Have fun!
python-cyclone-1.1/demos/httpauth/httpauthdemo_mongo.py 0000755 0001750 0001750 00000006643 12124336260 022614 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import base64
import functools
import sys
import cyclone.redis
import cyclone.web
from twisted.python import log
from twisted.internet import defer, reactor
try:
import txmongo
except ImportError:
print("You need txmongo: "
"https://github.com/fiorix/mongo-async-python-driver")
sys.exit(1)
class Application(cyclone.web.Application):
def __init__(self):
mongodb = txmongo.lazyMongoConnectionPool()
handlers = [
(r"/", IndexHandler, dict(mongodb=mongodb)),
(r"/createuser", CreateUserHandler, dict(mongodb=mongodb)),
]
cyclone.web.Application.__init__(self, handlers, debug=True)
def HTTPBasic(method):
@defer.inlineCallbacks
@functools.wraps(method)
def wrapper(self, *args, **kwargs):
try:
auth_type, auth_data = \
self.request.headers["Authorization"].split()
assert auth_type == "Basic"
usr, pwd = base64.b64decode(auth_data).split(":", 1)
except:
raise cyclone.web.HTTPAuthenticationRequired
try:
# search for user under the "cyclonedb.users" collection
response = yield self.mongodb.cyclonedb.users.find_one(
{"usr": usr, "pwd": pwd}, fields=["usr"])
mongo_usr = response.get("usr")
except Exception, e:
log.msg("MongoDB failed to find(): %s" % str(e))
raise cyclone.web.HTTPError(503) # Service Unavailable
if usr != mongo_usr:
raise cyclone.web.HTTPAuthenticationRequired
else:
self._current_user = usr
defer.returnValue(method(self, *args, **kwargs))
return wrapper
class IndexHandler(cyclone.web.RequestHandler):
def initialize(self, mongodb):
self.mongodb = mongodb
@HTTPBasic
def get(self):
self.write("Hi, %s." % self._current_user)
class CreateUserHandler(cyclone.web.RequestHandler):
def initialize(self, mongodb):
self.mongodb = mongodb
@defer.inlineCallbacks
def post(self):
usr = self.get_argument("username")
pwd = self.get_argument("password")
try:
# create user under the "cyclonedb.users" collection
ObjId = yield self.mongodb.cyclonedb.users.update(
{"usr": usr}, {"usr": usr, "pwd": pwd},
upsert=True, safe=True)
except Exception, e:
log.msg("MongoDB failed to upsert(): %s" % str(e))
raise cyclone.web.HTTPError(503) # Service Unavailable
self.write("User created. ObjId=%s\r\n" % ObjId)
def main():
log.startLogging(sys.stdout)
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/httpauth/httpauthdemo.py 0000755 0001750 0001750 00000004163 12124336260 021410 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import base64
import functools
import sys
import cyclone.web
from twisted.python import log
from twisted.internet import reactor
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", IndexHandler),
]
cyclone.web.Application.__init__(self, handlers, debug=True)
def HTTPBasic(method):
@functools.wraps(method)
def wrapper(self, *args, **kwargs):
msg = None
if "Authorization" in self.request.headers:
auth_type, data = self.request.headers["Authorization"].split()
try:
assert auth_type == "Basic"
usr, pwd = base64.b64decode(data).split(":", 1)
assert usr == "root@localhost"
assert pwd == "123"
except AssertionError:
msg = "Authentication failed"
else:
msg = "Authentication required"
if msg:
raise cyclone.web.HTTPAuthenticationRequired(
log_message=msg, auth_type="Basic", realm="DEMO")
else:
self._current_user = usr
return method(self, *args, **kwargs)
return wrapper
class IndexHandler(cyclone.web.RequestHandler):
@HTTPBasic
def get(self):
self.write("Hi, %s." % self._current_user)
def main():
log.startLogging(sys.stdout)
reactor.listenTCP(8888, Application(), interface="0.0.0.0")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/sse/ 0000755 0001750 0001750 00000000000 12124336260 015252 5 ustar lunar lunar python-cyclone-1.1/demos/sse/ssedemo.py 0000755 0001750 0001750 00000005321 12124336260 017267 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import cyclone.sse
import cyclone.web
from twisted.internet import protocol
from twisted.internet import reactor
from twisted.protocols import telnet
from twisted.python import log
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", cyclone.web.RedirectHandler, {"url": "/static/index.html"}),
(r"/live", LiveHandler),
]
settings = dict(
debug=True,
static_path="./static",
template_path="./template",
)
cyclone.web.Application.__init__(self, handlers, **settings)
class StarWarsMixin(object):
mbuffer = ""
waiters = []
def subscribe(self, client):
StarWarsMixin.waiters.append(client)
def unsubscribe(self, client):
StarWarsMixin.waiters.remove(client)
def broadcast(self, message):
cls = StarWarsMixin
chunks = (self.mbuffer + message.replace("\x1b[J", "")).split("\x1b[H")
self.mbuffer = ""
for chunk in chunks:
if len(chunk) == 985:
chunk = chunk.replace("\r\n", " ")
log.msg("Sending new message to %r listeners" % \
len(cls.waiters))
for client in cls.waiters:
try:
client.sendEvent(chunk)
except:
log.err()
else:
self.mbuffer = chunk
class LiveHandler(cyclone.sse.SSEHandler, StarWarsMixin):
def bind(self):
self.subscribe(self)
def unbind(self):
self.unsubscribe(self)
class BlinkenlightsProtocol(telnet.Telnet, StarWarsMixin):
def dataReceived(self, data):
self.broadcast(data)
def main():
log.startLogging(sys.stdout)
blinkenlights = protocol.ReconnectingClientFactory()
blinkenlights.protocol = BlinkenlightsProtocol
reactor.connectTCP("towel.blinkenlights.nl", 23, blinkenlights)
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/sse/README 0000644 0001750 0001750 00000000612 12124336260 016131 0 ustar lunar lunar Server Sent Events Demo
SSE is a mechanism akin to comet but with fine grained control over the data. You can name events, send structured and partial data and set the proper timeout.
To understand better, check http://www.html5rocks.com/en/tutorials/eventsource/basics/
The client side gets really simple than controlling a COMET resource using js, by using the window.EventSource object.
python-cyclone-1.1/demos/sse/static/ 0000755 0001750 0001750 00000000000 12124336260 016541 5 ustar lunar lunar python-cyclone-1.1/demos/sse/static/index.html 0000644 0001750 0001750 00000001273 12124336260 020541 0 ustar lunar lunar
Episode IV Live from towel.blinkenlights.nl
python-cyclone-1.1/demos/websocket/ 0000755 0001750 0001750 00000000000 12124336260 016446 5 ustar lunar lunar python-cyclone-1.1/demos/websocket/chat/ 0000755 0001750 0001750 00000000000 12124336260 017365 5 ustar lunar lunar python-cyclone-1.1/demos/websocket/chat/chatdemo.py 0000755 0001750 0001750 00000010572 12124336260 021533 0 ustar lunar lunar #!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Simplified chat demo for websockets.
Authentication, error handling, etc are left as an exercise for the reader :)
"""
import os.path
import uuid
import sys
import time
from collections import defaultdict
from twisted.python import log
from twisted.internet import reactor, task
import cyclone.escape
import cyclone.web
import cyclone.websocket
class Application(cyclone.web.Application):
def __init__(self):
stats = Stats()
handlers = [
(r"/", MainHandler, dict(stats=stats)),
(r"/stats", StatsPageHandler),
(r"/statssocket", StatsSocketHandler, dict(stats=stats)),
(r"/chatsocket", ChatSocketHandler, dict(stats=stats)),
]
settings = dict(
cookie_secret="43oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=True,
autoescape=None,
)
cyclone.web.Application.__init__(self, handlers, **settings)
class MainHandler(cyclone.web.RequestHandler):
def initialize(self, stats):
self.stats = stats
def get(self):
self.stats.newVisit()
self.render("index.html", messages=ChatSocketHandler.cache)
class ChatSocketHandler(cyclone.websocket.WebSocketHandler):
waiters = set()
cache = []
cache_size = 200
def initialize(self, stats):
self.stats = stats
def connectionMade(self):
ChatSocketHandler.waiters.add(self)
self.stats.newChatter()
def connectionLost(self, reason):
ChatSocketHandler.waiters.remove(self)
self.stats.lostChatter()
@classmethod
def update_cache(cls, chat):
cls.cache.append(chat)
if len(cls.cache) > cls.cache_size:
cls.cache = cls.cache[-cls.cache_size:]
@classmethod
def send_updates(cls, chat):
log.msg("sending message to %d waiters" % len(cls.waiters))
for waiter in cls.waiters:
try:
waiter.sendMessage(chat)
except Exception, e:
log.err("Error sending message. %s" % str(e))
def messageReceived(self, message):
log.msg("got message %s" % message)
parsed = cyclone.escape.json_decode(message)
chat = {
"id": str(uuid.uuid4()),
"body": parsed["body"],
}
chat["html"] = self.render_string("message.html", message=chat)
ChatSocketHandler.update_cache(chat)
ChatSocketHandler.send_updates(chat)
class StatsSocketHandler(cyclone.websocket.WebSocketHandler):
def initialize(self, stats):
self.stats = stats
self._updater = task.LoopingCall(self._sendData)
def connectionMade(self):
self._updater.start(2)
def connectionLost(self, reason):
self._updater.stop()
def _sendData(self):
data = dict(visits=self.stats.todaysVisits(),
chatters=self.stats.chatters)
self.sendMessage(cyclone.escape.json_encode(data))
class Stats(object):
def __init__(self):
self.visits = defaultdict(int)
self.chatters = 0
def todaysVisits(self):
today = time.localtime()
key = time.strftime('%Y%m%d', today)
return self.visits[key]
def newChatter(self):
self.chatters += 1
def lostChatter(self):
self.chatters -= 1
def newVisit(self):
today = time.localtime()
key = time.strftime('%Y%m%d', today)
self.visits[key] += 1
class StatsPageHandler(cyclone.web.RequestHandler):
def get(self):
self.render("stats.html")
def main():
reactor.listenTCP(8888, Application())
reactor.run()
if __name__ == "__main__":
log.startLogging(sys.stdout)
main()
python-cyclone-1.1/demos/websocket/chat/templates/ 0000755 0001750 0001750 00000000000 12124336260 021363 5 ustar lunar lunar python-cyclone-1.1/demos/websocket/chat/templates/index.html 0000644 0001750 0001750 00000002534 12124336260 023364 0 ustar lunar lunar
Cyclone Chat Demo
{% for message in messages %}
{% include "message.html" %}
{% end %}
python-cyclone-1.1/demos/locale/frontend/template/hello.txt 0000644 0001750 0001750 00000000062 12124336260 023213 0 ustar lunar lunar Simple text file.
{{ _("%s, translated") % msg }}
python-cyclone-1.1/demos/locale/mytest_pt_BR.po 0000644 0001750 0001750 00000002446 12124336260 020700 0 ustar lunar lunar # cyclone locale demo
# Copyright (C) 2010 Alexandre Fiori
# This file is distributed under the same license as the cyclone package.
# Alexandre Fiori , 2010
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: 0.1\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2010-01-20 12:19-0200\n"
"PO-Revision-Date: 2010-01-20 12:21-0300\n"
"Last-Translator: Alexandre Fiori \n"
"Language-Team: \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=UTF-8\n"
"Content-Transfer-Encoding: 8bit\n"
"Plural-Forms: nplurals=INTEGER; plural=n != 1;\n"
#: localedemo.py:76
msgid "hello world"
msgstr "olá mundo"
#: frontend/template/hello.txt:2
#, python-format
msgid "%s, translated"
msgstr "%s, traduzido"
#: frontend/template/index.html:5 frontend/template/index.html:25
msgid "cyclone locale demo"
msgstr "demonstração de internacionalização do cyclone"
#: frontend/template/index.html:29
msgid "Please select your language:"
msgstr "Por favor, selecione sua lÃngua:"
#: frontend/template/index.html:35
msgid "How many apples?"
msgstr "Quantas maçãs?"
#: frontend/template/index.html:39
msgid "Submit"
msgstr "Enviar"
#: frontend/template/index.html:42
#, python-format
msgid "One apple"
msgid_plural "%(count)d apples"
msgstr[0] "Uma maçã"
msgstr[1] "%(count)d maçãs"
python-cyclone-1.1/demos/s3/ 0000755 0001750 0001750 00000000000 12124336260 015005 5 ustar lunar lunar python-cyclone-1.1/demos/s3/README 0000644 0001750 0001750 00000000736 12124336260 015673 0 ustar lunar lunar Port of http://github.com/facebook/tornado/raw/master/tornado/s3server.py (s3 clone on tornado)
TODO:
- plug auth module
- plug riak, redis or another storage besides FS
- be awesome.
RUNNING
$ twistd -ny se.tac
TESTING:
create bucket: $ curl --request PUT "http://localhost:4000/meh/"
put some data (README file): curl --data "@README" --request PUT --header "Content-Type: text/plain" "http://localhost:4000/meh/README"
retrieve: curl http://localhost:4000/meh/README
python-cyclone-1.1/demos/s3/se.tac 0000644 0001750 0001750 00000000604 12124336260 016105 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
# twistd -ny s3.tac
# gleicon moraes (http://zenmachine.wordpress.com | http://github.com/gleicon)
SERVER_PORT = 4000
import s3server
from twisted.application import service, internet
application = service.Application("s3")
srv = internet.TCPServer(SERVER_PORT, s3server.S3Application(root_directory="/tmp/s3"))
srv.setServiceParent(application)
python-cyclone-1.1/demos/s3/s3server.py 0000644 0001750 0001750 00000022346 12124336260 017142 0 ustar lunar lunar #!/usr/bin/env python
#
# Copyright 2009 Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
# port to cyclone: took out ioloop initialization, fixed imports and created
# a .tac file.
# gleicon 04/10
"""Implementation of an S3-like storage server based on local files.
Useful to test features that will eventually run on S3, or if you want to
run something locally that was once running on S3.
We don't support all the features of S3, but it does work with the
standard S3 client for the most basic semantics. To use the standard
S3 client with this module:
c = S3.AWSAuthConnection("", "", server="localhost", port=8888,
is_secure=False)
c.create_bucket("mybucket")
c.put("mybucket", "mykey", "a value")
print c.get("mybucket", "mykey").body
"""
from cyclone import escape
from cyclone import web
from twisted.python import log
import datetime
import bisect
import hashlib
import os
import os.path
import urllib
class S3Application(web.Application):
"""Implementation of an S3-like storage server based on local files.
If bucket depth is given, we break files up into multiple directories
to prevent hitting file system limits for number of files in each
directories. 1 means one level of directories, 2 means 2, etc.
"""
def __init__(self, root_directory, bucket_depth=0):
web.Application.__init__(self, [
(r"/", RootHandler),
(r"/([^/]+)/(.+)", ObjectHandler),
(r"/([^/]+)/", BucketHandler),
])
self.directory = os.path.abspath(root_directory)
if not os.path.exists(self.directory):
os.makedirs(self.directory)
self.bucket_depth = bucket_depth
class BaseRequestHandler(web.RequestHandler):
# SUPPORTED_METHODS = ("PUT", "GET", "DELETE", "HEAD")
def render_xml(self, value):
assert isinstance(value, dict) and len(value) == 1
self.set_header("Content-Type", "application/xml; charset=UTF-8")
name = value.keys()[0]
parts = []
parts.append('<' + escape.utf8(name) +
' xmlns="http://doc.s3.amazonaws.com/2006-03-01">')
self._render_parts(value.values()[0], parts)
parts.append('')
self.finish('\n' +
''.join(parts))
def _render_parts(self, value, parts=[]):
if isinstance(value, basestring):
parts.append(escape.xhtml_escape(value))
elif isinstance(value, int) or isinstance(value, long):
parts.append(str(value))
elif isinstance(value, datetime.datetime):
parts.append(value.strftime("%Y-%m-%dT%H:%M:%S.000Z"))
elif isinstance(value, dict):
for name, subvalue in value.iteritems():
if not isinstance(subvalue, list):
subvalue = [subvalue]
for subsubvalue in subvalue:
parts.append('<' + escape.utf8(name) + '>')
self._render_parts(subsubvalue, parts)
parts.append('')
else:
raise Exception("Unknown S3 value type %r", value)
def _object_path(self, bucket, object_name):
if self.application.bucket_depth < 1:
return os.path.abspath(os.path.join(
self.application.directory, bucket, object_name))
hash = hashlib.md5(object_name).hexdigest()
path = os.path.abspath(os.path.join(
self.application.directory, bucket))
for i in range(self.application.bucket_depth):
path = os.path.join(path, hash[:2 * (i + 1)])
return os.path.join(path, object_name)
class RootHandler(BaseRequestHandler):
def get(self):
names = os.listdir(self.application.directory)
buckets = []
for name in names:
path = os.path.join(self.application.directory, name)
info = os.stat(path)
buckets.append({
"Name": name,
"CreationDate": datetime.datetime.utcfromtimestamp(
info.st_ctime),
})
self.render_xml({"ListAllMyBucketsResult": {
"Buckets": {"Bucket": buckets},
}})
class BucketHandler(BaseRequestHandler):
def get(self, bucket_name):
prefix = self.get_argument("prefix", u"")
marker = self.get_argument("marker", u"")
max_keys = int(self.get_argument("max-keys", 50000))
path = os.path.abspath(os.path.join(self.application.directory,
bucket_name))
terse = int(self.get_argument("terse", 0))
if not path.startswith(self.application.directory) or \
not os.path.isdir(path):
raise web.HTTPError(404)
object_names = []
for root, dirs, files in os.walk(path):
for file_name in files:
object_names.append(os.path.join(root, file_name))
skip = len(path) + 1
for i in range(self.application.bucket_depth):
skip += 2 * (i + 1) + 1
object_names = [n[skip:] for n in object_names]
object_names.sort()
contents = []
start_pos = 0
if marker:
start_pos = bisect.bisect_right(object_names, marker, start_pos)
if prefix:
start_pos = bisect.bisect_left(object_names, prefix, start_pos)
truncated = False
for object_name in object_names[start_pos:]:
if not object_name.startswith(prefix):
break
if len(contents) >= max_keys:
truncated = True
break
object_path = self._object_path(bucket_name, object_name)
c = {"Key": object_name}
if not terse:
info = os.stat(object_path)
c.update({
"LastModified": datetime.datetime.utcfromtimestamp(
info.st_mtime),
"Size": info.st_size,
})
contents.append(c)
marker = object_name
self.render_xml({"ListBucketResult": {
"Name": bucket_name,
"Prefix": prefix,
"Marker": marker,
"MaxKeys": max_keys,
"IsTruncated": truncated,
"Contents": contents,
}})
def put(self, bucket_name):
log.msg('bruxao')
path = os.path.abspath(os.path.join(
self.application.directory, bucket_name))
if not path.startswith(self.application.directory) or \
os.path.exists(path):
raise web.HTTPError(403)
os.makedirs(path)
self.finish()
def delete(self, bucket_name):
path = os.path.abspath(os.path.join(
self.application.directory, bucket_name))
if not path.startswith(self.application.directory) or \
not os.path.isdir(path):
raise web.HTTPError(404)
if len(os.listdir(path)) > 0:
raise web.HTTPError(403)
os.rmdir(path)
self.set_status(204)
self.finish()
class ObjectHandler(BaseRequestHandler):
def get(self, bucket, object_name):
object_name = urllib.unquote(object_name)
path = self._object_path(bucket, object_name)
if not path.startswith(self.application.directory) or \
not os.path.isfile(path):
raise web.HTTPError(404)
info = os.stat(path)
self.set_header("Content-Type", "application/unknown")
self.set_header("Last-Modified", datetime.datetime.utcfromtimestamp(
info.st_mtime))
object_file = open(path, "r")
try:
self.finish(object_file.read())
finally:
object_file.close()
def put(self, bucket, object_name):
object_name = urllib.unquote(object_name)
bucket_dir = os.path.abspath(os.path.join(
self.application.directory, bucket))
if not bucket_dir.startswith(self.application.directory) or \
not os.path.isdir(bucket_dir):
raise web.HTTPError(404)
path = self._object_path(bucket, object_name)
if not path.startswith(bucket_dir) or os.path.isdir(path):
raise web.HTTPError(403)
directory = os.path.dirname(path)
if not os.path.exists(directory):
os.makedirs(directory)
object_file = open(path, "w")
object_file.write(self.request.body)
object_file.close()
self.finish()
def delete(self, bucket, object_name):
object_name = urllib.unquote(object_name)
path = self._object_path(bucket, object_name)
if not path.startswith(self.application.directory) or \
not os.path.isfile(path):
raise web.HTTPError(404)
os.unlink(path)
self.set_status(204)
self.finish()
python-cyclone-1.1/demos/auth/ 0000755 0001750 0001750 00000000000 12124336260 015421 5 ustar lunar lunar python-cyclone-1.1/demos/auth/authdemo.py 0000755 0001750 0001750 00000004752 12124336260 017614 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import cyclone.auth
import cyclone.escape
import cyclone.web
from twisted.python import log
from twisted.internet import reactor
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", MainHandler),
(r"/auth/login", AuthHandler),
(r"/auth/logout", LogoutHandler),
]
settings = dict(
cookie_secret="32oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
debug=True,
login_url="/auth/login",
)
cyclone.web.Application.__init__(self, handlers, **settings)
class BaseHandler(cyclone.web.RequestHandler):
def get_current_user(self):
user_json = self.get_secure_cookie("user")
if not user_json:
return None
return cyclone.escape.json_decode(user_json)
class MainHandler(BaseHandler):
@cyclone.web.authenticated
def get(self):
name = cyclone.escape.xhtml_escape(self.current_user["name"])
self.write("Hello, " + name)
self.write("
Log out")
class AuthHandler(BaseHandler, cyclone.auth.GoogleMixin):
@cyclone.web.asynchronous
def get(self):
if self.get_argument("openid.mode", None):
self.get_authenticated_user(self._on_auth)
return
self.authenticate_redirect()
def _on_auth(self, user):
if not user:
raise cyclone.web.HTTPError(500, "Google auth failed")
self.set_secure_cookie("user", cyclone.escape.json_encode(user))
self.redirect("/")
class LogoutHandler(BaseHandler):
def get(self):
self.clear_cookie("user")
self.redirect("/")
def main():
log.startLogging(sys.stdout)
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/pycket/ 0000755 0001750 0001750 00000000000 12124336260 015757 5 ustar lunar lunar python-cyclone-1.1/demos/pycket/README.md 0000644 0001750 0001750 00000000601 12124336260 017233 0 ustar lunar lunar # pycket Demo
[pycket] is a session library, written for use with Redis or Memcached, and Tornado web server. It works equally well with cyclone.
[pycket]: https://github.com/diogobaeder/pycket
This demo shows how to set, get, and delete sessions stored persistently in redis (though it can easily be made to use memcached). See the [pycket] page for additional documentation.
python-cyclone-1.1/demos/pycket/pycketdemo.py 0000755 0001750 0001750 00000005743 12124336260 020511 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import cyclone.auth
import cyclone.escape
import cyclone.web
from twisted.python import log
from twisted.internet import reactor
from pycket.session import SessionMixin
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", MainHandler),
(r"/auth/login", AuthHandler),
(r"/auth/logout", LogoutHandler),
]
settings = dict(
cookie_secret="32oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
debug=True,
login_url="/auth/login",
logout_url="/auth/logout",
)
settings['pycket'] = {
'engine': 'redis',
'storage': {
'host': 'localhost',
'port': 6379,
'db_sessions': 10,
'db_notifications': 11
}
}
cyclone.web.Application.__init__(self, handlers, **settings)
class BaseHandler(cyclone.web.RequestHandler, SessionMixin):
def get_current_user(self):
user = self.session.get('user')
if not user:
return None
return user
class MainHandler(BaseHandler):
@cyclone.web.authenticated
def get(self):
name = cyclone.escape.xhtml_escape(self.current_user)
self.write("Hello, " + name)
self.write("
Log out")
class AuthHandler(BaseHandler, SessionMixin):
def get(self):
self.write('')
def post(self):
username = self.get_argument('username')
if not username:
self.write('')
else:
self.session.set('user', username)
self.redirect('/')
class LogoutHandler(BaseHandler, SessionMixin):
def get(self):
self.session.delete('user')
self.redirect("/")
def main():
log.startLogging(sys.stdout)
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/ssl/ 0000755 0001750 0001750 00000000000 12124336260 015261 5 ustar lunar lunar python-cyclone-1.1/demos/ssl/mkcert.sh 0000755 0001750 0001750 00000000517 12124336260 017110 0 ustar lunar lunar #!/bin/bash
echo -- key
openssl genrsa -des3 -out server.key 1024
echo -- csr
openssl req -new -key server.key -out server.csr
echo -- remove passphrase
cp server.key orig.server.key
openssl rsa -in orig.server.key -out server.key
echo -- generate crt
openssl x509 -req -days 365 -in server.csr -signkey server.key -out server.crt
python-cyclone-1.1/demos/ssl/helloworld_ssl.py 0000755 0001750 0001750 00000002611 12124336260 020672 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.web
import sys
from twisted.internet import reactor
from twisted.internet import ssl
from twisted.python import log
class MainHandler(cyclone.web.RequestHandler):
def get(self):
self.write("Hello, %s" % self.request.protocol)
def main():
log.startLogging(sys.stdout)
application = cyclone.web.Application([
(r"/", MainHandler)
])
interface = "127.0.0.1"
reactor.listenTCP(8888, application, interface=interface)
reactor.listenSSL(8443, application,
ssl.DefaultOpenSSLContextFactory("server.key",
"server.crt"),
interface=interface)
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/ssl/README 0000644 0001750 0001750 00000000377 12124336260 016150 0 ustar lunar lunar create a pair of certs:
$ mkcert (some questions, write down your passphrase, etc)
$ python helloworld_ssl.py
point your browser to https://localhost:8443
try using cyclone's twisted plugin:
$ twistd -n cyclone --ssl-app=helloworld_simple.Application
python-cyclone-1.1/demos/ssl/helloworld_simple.py 0000755 0001750 0001750 00000001705 12124336260 021365 0 ustar lunar lunar # coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
# Run: twistd -n cyclone --ssl-app helloworld_simple.Application
# For more info: twistd -n cyclone --help
import cyclone.web
class MainHandler(cyclone.web.RequestHandler):
def get(self):
self.write("Hello, %s" % self.request.protocol)
Application = lambda: cyclone.web.Application([(r"/", MainHandler)])
python-cyclone-1.1/demos/rpc/ 0000755 0001750 0001750 00000000000 12124336260 015244 5 ustar lunar lunar python-cyclone-1.1/demos/rpc/xmlrpc_client.py 0000644 0001750 0001750 00000001623 12124336260 020463 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import xmlrpclib
srv = xmlrpclib.Server("http://localhost:8888/xmlrpc")
print "echo:", srv.echo("hello world!")
print "sort:", srv.sort(["foo", "bar"])
print "count:", srv.count(["foo", "bar"])
print "geoip_lookup:\n", srv.geoip_lookup("google.com")
python-cyclone-1.1/demos/rpc/rpcdemo.py 0000755 0001750 0001750 00000004016 12124336260 017253 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import cyclone.httpclient
import cyclone.jsonrpc
import cyclone.xmlrpc
from twisted.python import log
from twisted.internet import defer, reactor
class XmlrpcHandler(cyclone.xmlrpc.XmlrpcRequestHandler):
allowNone = True
def xmlrpc_echo(self, text):
return text
def xmlrpc_sort(self, items):
return sorted(items)
def xmlrpc_count(self, items):
return len(items)
@defer.inlineCallbacks
def xmlrpc_geoip_lookup(self, address):
result = yield cyclone.httpclient.fetch(
"http://freegeoip.net/xml/%s" % address.encode("utf-8"))
defer.returnValue(result.body)
class JsonrpcHandler(cyclone.jsonrpc.JsonrpcRequestHandler):
def jsonrpc_echo(self, text):
return text
def jsonrpc_sort(self, items):
return sorted(items)
def jsonrpc_count(self, items):
return len(items)
@defer.inlineCallbacks
def jsonrpc_geoip_lookup(self, address):
result = yield cyclone.httpclient.fetch(
"http://freegeoip.net/json/%s" % address.encode("utf-8"))
defer.returnValue(result.body)
def main():
log.startLogging(sys.stdout)
application = cyclone.web.Application([
(r"/xmlrpc", XmlrpcHandler),
(r"/jsonrpc", JsonrpcHandler),
])
reactor.listenTCP(8888, application)
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/rpc/jsonrpc_sync_client.py 0000644 0001750 0001750 00000002350 12124336260 021666 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import json
import urllib
def request(url, func, *args):
req = json.dumps({"method": func, "params": args, "id": 1})
result = urllib.urlopen(url, req).read()
try:
response = json.loads(result)
except:
return "error: %s" % result
else:
return response.get("result", response.get("error"))
url = "http://localhost:8888/jsonrpc"
print "echo:", request(url, "echo", "foo bar")
print "sort:", request(url, "sort", ["foo", "bar"])
print "count:", request(url, "count", ["foo", "bar"])
print "geoip_lookup:", request(url, "geoip_lookup", "google.com")
python-cyclone-1.1/demos/rpc/jsonrpc_async_client.py 0000644 0001750 0001750 00000002160 12124336260 022026 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.httpclient
from twisted.internet import defer, reactor
@defer.inlineCallbacks
def main():
cli = cyclone.httpclient.JsonRPC("http://localhost:8888/jsonrpc")
print "echo:", (yield cli.echo("foo bar"))
print "sort:", (yield cli.sort(["foo", "bar"]))
print "count:", (yield cli.count(["foo", "bar"]))
print "geoip_lookup:", (yield cli.geoip_lookup("google.com"))
reactor.stop()
if __name__ == "__main__":
main()
reactor.run()
python-cyclone-1.1/demos/facebook/ 0000755 0001750 0001750 00000000000 12124336260 016231 5 ustar lunar lunar python-cyclone-1.1/demos/facebook/templates/ 0000755 0001750 0001750 00000000000 12124336260 020227 5 ustar lunar lunar python-cyclone-1.1/demos/facebook/templates/stream.html 0000644 0001750 0001750 00000001461 12124336260 022412 0 ustar lunar lunar
Tornado Facebook Stream Demo
python-cyclone-1.1/demos/facebook/README 0000644 0001750 0001750 00000000527 12124336260 017115 0 ustar lunar lunar Running the Tornado Facebook example
=====================================
To work with the provided Facebook api key, this example must be
accessed at http://localhost:8888/ to match the Connect URL set in the
example application.
To use any other domain, a new Facebook application must be registered
with a Connect URL set to that domain.
python-cyclone-1.1/demos/facebook/uimodules.py 0000644 0001750 0001750 00000001410 12124336260 020605 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.web
class Entry(cyclone.web.UIModule):
def render(self):
return '
ENTRY
'
python-cyclone-1.1/demos/facebook/facebook.py 0000755 0001750 0001750 00000007501 12124336260 020362 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import os.path
import cyclone.auth
import cyclone.escape
import cyclone.web
from twisted.python import log
from twisted.internet import reactor
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", MainHandler),
(r"/auth/login", AuthLoginHandler),
(r"/auth/logout", AuthLogoutHandler),
]
settings = dict(
cookie_secret="12oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
login_url="/auth/login",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=True,
facebook_api_key="9e2ada1b462142c4dfcc8e894ea1e37c",
facebook_secret="32fc6114554e3c53d5952594510021e2",
ui_modules={"Post": PostModule},
debug=True,
)
cyclone.web.Application.__init__(self, handlers, **settings)
class BaseHandler(cyclone.web.RequestHandler):
def get_current_user(self):
user_json = self.get_secure_cookie("user")
if not user_json:
return None
return cyclone.escape.json_decode(user_json)
class MainHandler(BaseHandler, cyclone.auth.FacebookMixin):
@cyclone.web.authenticated
@cyclone.web.asynchronous
def get(self):
self.facebook_request(
method="stream.get",
callback=self._on_stream,
session_key=self.current_user["session_key"])
def _on_stream(self, stream):
if stream is None:
# Session may have expired
self.redirect("/auth/login")
return
# Turn profiles into a dict mapping id => profile
stream["profiles"] = dict((p["id"], p) for p in stream["profiles"])
self.render("stream.html", stream=stream)
class AuthLoginHandler(BaseHandler, cyclone.auth.FacebookMixin):
@cyclone.web.asynchronous
def get(self):
if self.get_argument("session", None):
self.get_authenticated_user(self._on_auth)
return
self.authorize_redirect("read_stream")
def _on_auth(self, user):
if not user:
raise cyclone.web.HTTPError(500, "Facebook auth failed")
self.set_secure_cookie("user", cyclone.escape.json_encode(user))
self.redirect(self.get_argument("next", "/"))
class AuthLogoutHandler(BaseHandler, cyclone.auth.FacebookMixin):
@cyclone.web.asynchronous
def get(self):
self.clear_cookie("user")
if not self.current_user:
self.redirect(self.get_argument("next", "/"))
return
self.facebook_request(
method="auth.revokeAuthorization",
callback=self._on_deauthorize,
session_key=self.current_user["session_key"])
def _on_deauthorize(self, response):
self.redirect(self.get_argument("next", "/"))
class PostModule(cyclone.web.UIModule):
def render(self, post, actor):
return self.render_string("modules/post.html", post=post, actor=actor)
def main():
reactor.listenTCP(8888, Application())
reactor.run()
if __name__ == "__main__":
log.startLogging(sys.stdout)
main()
python-cyclone-1.1/demos/facebook/static/ 0000755 0001750 0001750 00000000000 12124336260 017520 5 ustar lunar lunar python-cyclone-1.1/demos/facebook/static/facebook.js 0000644 0001750 0001750 00000000000 12124336260 021615 0 ustar lunar lunar python-cyclone-1.1/demos/facebook/static/facebook.css 0000644 0001750 0001750 00000002724 12124336260 022010 0 ustar lunar lunar /*
* Copyright 2009 Facebook
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
body {
background: white;
color: black;
margin: 15px;
}
body,
input,
textarea {
font-family: "Lucida Grande", Tahoma, Verdana, sans-serif;
font-size: 10pt;
}
table {
border-collapse: collapse;
border: 0;
}
td {
border: 0;
padding: 0;
}
img {
border: 0;
}
a {
text-decoration: none;
color: #3b5998;
}
a:hover {
text-decoration: underline;
}
.post {
border-bottom: 1px solid #eeeeee;
min-height: 50px;
padding-bottom: 10px;
margin-top: 10px;
}
.post .picture {
float: left;
}
.post .picture img {
height: 50px;
width: 50px;
}
.post .body {
margin-left: 60px;
}
.post .media img {
border: 1px solid #cccccc;
padding: 3px;
}
.post .media:hover img {
border: 1px solid #3b5998;
}
.post a.actor {
font-weight: bold;
}
.post .meta {
font-size: 11px;
}
.post a.permalink {
color: #777777;
}
#body {
max-width: 700px;
margin: auto;
}
python-cyclone-1.1/demos/helloworld/ 0000755 0001750 0001750 00000000000 12124336260 016633 5 ustar lunar lunar python-cyclone-1.1/demos/helloworld/helloworld.py 0000755 0001750 0001750 00000002102 12124336260 021356 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.web
import sys
from twisted.internet import reactor
from twisted.python import log
class MainHandler(cyclone.web.RequestHandler):
def get(self):
self.write("Hello, world")
if __name__ == "__main__":
application = cyclone.web.Application([
(r"/", MainHandler)
])
log.startLogging(sys.stdout)
reactor.listenTCP(8888, application, interface="127.0.0.1")
reactor.run()
python-cyclone-1.1/demos/helloworld/nginx.conf 0000644 0001750 0001750 00000001021 12124336260 020617 0 ustar lunar lunar upstream backend {
server localhost:9901;
server localhost:9902;
server localhost:9903;
server localhost:9904;
# server unix:/tmp/cyclone.1;
# server unix:/tmp/cyclone.2;
}
server {
listen 80;
server_name localhost;
#access_log /var/log/nginx/access.log;
location / {
proxy_pass http://backend;
proxy_redirect off;
proxy_set_header Host $host;
proxy_set_header X-Real-IP $remote_addr;
proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
}
}
python-cyclone-1.1/demos/helloworld/helloworld_bottle.py 0000755 0001750 0001750 00000001467 12124336260 022744 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
from cyclone.bottle import run, route
@route("/")
def index(web):
web.write("Hello, world")
run(host="127.0.0.1", port=8888, log=sys.stdout)
python-cyclone-1.1/demos/helloworld/helloworld_twistd.py 0000755 0001750 0001750 00000002104 12124336260 022756 0 ustar lunar lunar #!/usr/bin/env twistd -ny
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.web
from twisted.application import internet
from twisted.application import service
class MainHandler(cyclone.web.RequestHandler):
def get(self):
self.write("Hello, world")
webapp = cyclone.web.Application([
(r"/", MainHandler)
])
application = service.Application("helloworld_twistd")
server = internet.TCPServer(8888, webapp, interface="127.0.0.1")
server.setServiceParent(application)
python-cyclone-1.1/demos/helloworld/helloworld_simple.py 0000755 0001750 0001750 00000002350 12124336260 022734 0 ustar lunar lunar # coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
#
# Start the server:
# cyclone run helloworld_simple.py
#
# For more info:
# cyclone run --help
#
# If this server is reverse proxied by nginx, some headers must be added to
# the request. Check our sample nginx.conf for details, and set xheaders=True
# to make cyclone use those headers.
import cyclone.web
class MainHandler(cyclone.web.RequestHandler):
def get(self):
self.write("Hello, world")
class Application(cyclone.web.Application):
def __init__(self):
cyclone.web.Application.__init__(self, [(r"/", MainHandler)],
xheaders=False)
python-cyclone-1.1/demos/digest_auth/ 0000755 0001750 0001750 00000000000 12124336260 016760 5 ustar lunar lunar python-cyclone-1.1/demos/digest_auth/digest.py 0000644 0001750 0001750 00000014472 12124336260 020621 0 ustar lunar lunar from cyclone.web import *
from hashlib import md5
class DigestAuthMixin(object):
def apply_checksum(self, data):
return md5(data).hexdigest()
def apply_digest(self, secret, data):
return self.apply_checksum(secret + ":" + data)
def A1(self, algorithm, auth_pass):
"""
If 'algorithm' is "MD5" or unset, A1 is:
A1 = unq(username-value) ":" unq(realm-value) ":" passwd
if 'algorithm' is 'MD5-Sess', A1 is:
A1 = H( unq(username-value) ":" unq(realm-value) ":" passwd )
":" unq(nonce-value) ":" unq(cnonce-value)
"""
username = self.params["username"]
if algorithm == 'MD5' or not algorithm:
return "%s:%s:%s" % (username, self.realm, auth_pass)
elif algorithm == 'MD5-Sess':
return self.apply_checksum('%s:%s:%s:%s:%s' % \
(username,
self.realm,
auth_pass,
self.params['nonce'],
self.params['cnonce']))
def A2(self):
"""
If the "qop" directive's value is "auth" or is unspecified, then A2 is:
A2 = Method ":" digest-uri-value
Else,
A2 = Method ":" digest-uri-value ":" H(entity-body)
"""
if self.params['qop'] == 'auth' or not self.params['qop']:
return self.request.method + ":" + self.request.uri
elif self.params['qop'] == 'auth-int':
#print "UNSUPPORTED 'qop' METHOD\n"
return ":".join([self.request.method,
self.request.uri,
self.apply_checksum(self.request.body)])
else:
print "A2 GOT BAD VALUE FOR 'qop': %s\n" % self.params['qop']
def response(self, auth_pass):
if 'qop' in self.params:
auth_comps = [self.params['nonce'],
self.params['nc'],
self.params['cnonce'],
self.params['qop'],
self.apply_checksum(self.A2())]
return self.apply_digest(self.apply_checksum( \
self.A1(self.params.get('algorithm'),
auth_pass)),
':'.join(auth_comps))
else:
return self.apply_digest(self.apply_checksum( \
self.A1(self.params.get('algorithm'),
auth_pass)),
':'.join([self.params["nonce"],
self.apply_checksum(self.A2())]))
def _parse_header(self, authheader):
try:
n = len("Digest ")
authheader = authheader[n:].strip()
items = authheader.split(", ")
keyvalues = [i.split("=", 1) for i in items]
keyvalues = [(k.strip(), v.strip().replace('"', '')) for k, v in keyvalues]
self.params = dict(keyvalues)
except:
self.params = []
def _create_nonce(self):
return md5("%d:%s" % (time.time(), self.realm)).hexdigest()
def createAuthHeader(self):
self.set_status(401)
nonce = self._create_nonce()
self.set_header("WWW-Authenticate", "Digest algorithm=MD5, realm=%s, qop=auth, nonce=%s" % (self.realm, nonce))
self.finish()
return False
def get_authenticated_user(self, get_creds_callback, realm):
creds = None
expected_response = None
actual_response = None
auth = None
if not hasattr(self,'realm'):
self.realm = realm
try:
auth = self.request.headers.get('Authorization')
if not auth or not auth.startswith('Digest '):
return self.createAuthHeader()
else:
self._parse_header(auth)
required_params = ['username', 'realm', 'nonce', 'uri', 'response', 'qop', 'nc', 'cnonce']
for k in required_params:
if k not in self.params:
print "REQUIRED PARAM %s MISSING\n" % k
return self.createAuthHeader()
elif not self.params[k]:
print "REQUIRED PARAM %s IS NONE OR EMPTY\n" % k
return self.createAuthHeader()
else:
continue
creds = get_creds_callback(self.params['username'])
if not creds:
# the username passed to get_creds_callback didn't
# match any valid users.
self.createAuthHeader()
else:
expected_response = self.response(creds['auth_password'])
actual_response = self.params['response']
print "Expected: %s" % expected_response
print "Actual: %s" % actual_response
if expected_response and actual_response:
if expected_response == actual_response:
self._current_user = self.params['username']
print "Digest Auth user '%s' successful for realm '%s'. URI: '%s', IP: '%s'" % (self.params['username'], self.realm, self.request.uri, self.request.remote_ip)
return True
else:
self.createAuthHeader()
except Exception as out:
print "FELL THROUGH: %s\n" % out
print "AUTH HEADERS: %s" % auth
print "SELF.PARAMS: ",self.params,"\n"
print "CREDS: ", creds
print "EXPECTED RESPONSE: %s" % expected_response
print "ACTUAL RESPONSE: %s" % actual_response
return self.createAuthHeader()
def digest_auth(realm, auth_func):
"""A decorator used to protect methods with HTTP Digest authentication.
"""
def digest_auth_decorator(func):
def func_replacement(self, *args, **kwargs):
# 'self' here is the RequestHandler object, which is inheriting
# from DigestAuthMixin to get 'get_authenticated_user'
if self.get_authenticated_user(auth_func, realm):
return func(self, *args, **kwargs)
return func_replacement
return digest_auth_decorator
python-cyclone-1.1/demos/digest_auth/README.md 0000644 0001750 0001750 00000001663 12124336260 020245 0 ustar lunar lunar # Cyclone auth digest example
This is a port of https://github.com/bkjones/curtain (Apache License)
## Basic usage
### import digest.py at the top of your views file
import digest
### subclass digest.DigestAuthMixin in authenticated views
class MainHandler(digest.DigestAuthMixin, cyclone.web.RequestHandler):
### define a password store. This function is expected to return a hash containing
auth\_username and auth\_password.
def passwordz(username):
creds = {
'auth_username': 'test',
'auth_password': 'foobar'
}
if username == creds['auth_username']:
return creds
### decorate views (get/post) with digest.digest_auth. Passing in authentication realm and password store.
If authenticated, `self.current_user` will be properly set.
@digest.digest_auth('Cyclone', passwordz)
def get(self):
self.write("Hello %s" % (self.current_user))
python-cyclone-1.1/demos/digest_auth/authdemo.py 0000755 0001750 0001750 00000003736 12124336260 021154 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import hashlib
import time
import cyclone.escape
import cyclone.web
import digest
from twisted.python import log
from twisted.internet import reactor
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", MainHandler),
]
settings = dict(
cookie_secret="32oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
debug=True,
login_url="/auth/login",
)
cyclone.web.Application.__init__(self, handlers, **settings)
class MainHandler(digest.DigestAuthMixin, cyclone.web.RequestHandler):
# forces this handler to parse only GET / PROPFIND methods
SUPPORTED_METHODS = ("GET", "PROPFIND")
def passwordz(username):
creds = {
'auth_username': 'test',
'auth_password': 'foobar'
}
if username == creds['auth_username']:
return creds
@digest.digest_auth('Cyclone', passwordz)
def get(self):
self.write("Hello %s" % (self.current_user))
@digest.digest_auth('Cyclone', passwordz)
def propfind(self):
self.write("Hello %s" % (self.current_user))
def main():
log.startLogging(sys.stdout)
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/fbgraphapi/ 0000755 0001750 0001750 00000000000 12124336260 016563 5 ustar lunar lunar python-cyclone-1.1/demos/fbgraphapi/templates/ 0000755 0001750 0001750 00000000000 12124336260 020561 5 ustar lunar lunar python-cyclone-1.1/demos/fbgraphapi/templates/stream.html 0000644 0001750 0001750 00000001445 12124336260 022746 0 ustar lunar lunar
Tornado Facebook Stream Demo
python-cyclone-1.1/demos/fbgraphapi/README 0000644 0001750 0001750 00000000527 12124336260 017447 0 ustar lunar lunar Running the Tornado Facebook example
=====================================
To work with the provided Facebook api key, this example must be
accessed at http://localhost:8888/ to match the Connect URL set in the
example application.
To use any other domain, a new Facebook application must be registered
with a Connect URL set to that domain.
python-cyclone-1.1/demos/fbgraphapi/uimodules.py 0000644 0001750 0001750 00000001410 12124336260 021137 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.web
class Entry(cyclone.web.UIModule):
def render(self):
return '
ENTRY
'
python-cyclone-1.1/demos/fbgraphapi/facebook.py 0000755 0001750 0001750 00000007572 12124336260 020724 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import sys
import os.path
import cyclone.auth
import cyclone.escape
import cyclone.web
from twisted.python import log
from twisted.internet import reactor
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", MainHandler),
(r"/auth/login", AuthLoginHandler),
(r"/auth/logout", AuthLogoutHandler),
]
settings = dict(
cookie_secret="12oETzKXQAGaYdkL5gEmGeJJFuYh7EQnp2XdTP1o/Vo=",
login_url="/auth/login",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
static_path=os.path.join(os.path.dirname(__file__), "static"),
xsrf_cookies=True,
facebook_api_key="501833353168262",
facebook_secret="56d788a22ee09499ea57b5044da123a1",
ui_modules={"Post": PostModule},
debug=True,
)
cyclone.web.Application.__init__(self, handlers, **settings)
class BaseHandler(cyclone.web.RequestHandler):
def get_current_user(self):
user_json = self.get_secure_cookie("user")
if not user_json:
return None
return cyclone.escape.json_decode(user_json)
class MainHandler(BaseHandler, cyclone.auth.FacebookGraphMixin):
@cyclone.web.authenticated
@cyclone.web.asynchronous
def get(self):
self.facebook_request("/me/friends", self._on_stream,
access_token=self.current_user["access_token"])
def _on_stream(self, stream):
if stream is None:
# Session may have expired
self.redirect("/auth/login")
return
self.render("stream.html", stream=stream)
class AuthLoginHandler(BaseHandler, cyclone.auth.FacebookGraphMixin):
@cyclone.web.asynchronous
def get(self):
my_url = (self.request.protocol + "://" + self.request.host +
"/auth/login?next=" +
cyclone.escape.url_escape(self.get_argument("next", "/")))
if self.get_argument("code", False):
self.get_authenticated_user(
redirect_uri=my_url,
client_id=self.settings["facebook_api_key"],
client_secret=self.settings["facebook_secret"],
code=self.get_argument("code"),
callback=self._on_auth)
return
self.authorize_redirect(redirect_uri=my_url,
client_id=self.settings["facebook_api_key"],
extra_params={"scope": "read_stream"})
def _on_auth(self, user):
if not user:
raise cyclone.web.HTTPError(500, "Facebook auth failed")
self.set_secure_cookie("user", cyclone.escape.json_encode(user))
self.redirect(self.get_argument("next", "/"))
class AuthLogoutHandler(BaseHandler, cyclone.auth.FacebookGraphMixin):
def get(self):
self.clear_cookie("user")
self.redirect(self.get_argument("next", "/"))
class PostModule(cyclone.web.UIModule):
def render(self, post, actor):
return self.render_string("modules/post.html", post=post, actor=actor)
def main():
reactor.listenTCP(8888, Application())
reactor.run()
if __name__ == "__main__":
log.startLogging(sys.stdout)
main()
python-cyclone-1.1/demos/fbgraphapi/static/ 0000755 0001750 0001750 00000000000 12124336260 020052 5 ustar lunar lunar python-cyclone-1.1/demos/fbgraphapi/static/facebook.js 0000644 0001750 0001750 00000000000 12124336260 022147 0 ustar lunar lunar python-cyclone-1.1/demos/fbgraphapi/static/facebook.css 0000644 0001750 0001750 00000002724 12124336260 022342 0 ustar lunar lunar /*
* Copyright 2009 Facebook
*
* Licensed under the Apache License, Version 2.0 (the "License"); you may
* not use this file except in compliance with the License. You may obtain
* a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
* WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
* License for the specific language governing permissions and limitations
* under the License.
*/
body {
background: white;
color: black;
margin: 15px;
}
body,
input,
textarea {
font-family: "Lucida Grande", Tahoma, Verdana, sans-serif;
font-size: 10pt;
}
table {
border-collapse: collapse;
border: 0;
}
td {
border: 0;
padding: 0;
}
img {
border: 0;
}
a {
text-decoration: none;
color: #3b5998;
}
a:hover {
text-decoration: underline;
}
.post {
border-bottom: 1px solid #eeeeee;
min-height: 50px;
padding-bottom: 10px;
margin-top: 10px;
}
.post .picture {
float: left;
}
.post .picture img {
height: 50px;
width: 50px;
}
.post .body {
margin-left: 60px;
}
.post .media img {
border: 1px solid #cccccc;
padding: 3px;
}
.post .media:hover img {
border: 1px solid #3b5998;
}
.post a.actor {
font-weight: bold;
}
.post .meta {
font-size: 11px;
}
.post a.permalink {
color: #777777;
}
#body {
max-width: 700px;
margin: auto;
}
python-cyclone-1.1/demos/email/ 0000755 0001750 0001750 00000000000 12124336260 015547 5 ustar lunar lunar python-cyclone-1.1/demos/email/emaildemo.py 0000755 0001750 0001750 00000006264 12124336260 020070 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import os.path
import sys
import cyclone.mail
import cyclone.web
from twisted.python import log
from twisted.internet import defer, reactor
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", cyclone.web.RedirectHandler, {"url": "/static/index.html"}),
(r"/sendmail", SendmailHandler),
]
settings = dict(
debug=True,
static_path="./static",
template_path="./template",
email_settings=dict(
host="smtp.gmail.com", # mandatory
port=587, # optional. default=25 or 587 for TLS
tls=True, # optional. default=False
username="foo", # optional. no default
password="bar", # optional. no default
)
)
cyclone.web.Application.__init__(self, handlers, **settings)
class SendmailHandler(cyclone.web.RequestHandler):
@defer.inlineCallbacks
def post(self):
to_addrs = self.get_argument("to_addrs").split(",")
subject = self.get_argument("subject")
message = self.get_argument("message")
content_type = self.get_argument("content_type")
# message may also be an html template:
# message = self.render_string("email.html", name="foobar")
msg = cyclone.mail.Message(
from_addr="you@domain.com",
to_addrs=to_addrs,
subject=subject,
message=message,
mime=content_type, # optional. default=text/plain
charset="utf-8") # optional. default=utf-8
img_path = os.path.join(self.settings.static_path, "me.png")
msg.attach(img_path, mime="image/png")
txt_path = os.path.join(self.settings.static_path, "info.txt")
msg.attach(txt_path, mime="text/plain", charset="utf-8")
msg.attach("fake.txt", mime="text/plain", charset="utf-8",
content="this file is fake!")
msg.add_header('X-MailTag', 'sampleUpload') # custom email header
try:
response = yield cyclone.mail.sendmail(
self.settings.email_settings, msg)
self.render("response.html", title="Success", response=response)
except Exception, e:
self.render("response.html", title="Failure", response=str(e))
def main():
log.startLogging(sys.stdout)
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/demos/email/template/ 0000755 0001750 0001750 00000000000 12124336260 017362 5 ustar lunar lunar python-cyclone-1.1/demos/email/template/response.html 0000644 0001750 0001750 00000001567 12124336260 022117 0 ustar lunar lunar
{{title}}
python-cyclone-1.1/demos/upload/uploaddemo.py 0000755 0001750 0001750 00000006020 12124336260 020450 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import os
import sys
import cyclone.web
from twisted.python import log
from twisted.internet import reactor
# Helper function to convert bytes to human readable strings
humanreadable = lambda s: [(s % 1024 ** i and "%.1f" % (s / 1024.0 ** i) or \
str(s / 1024 ** i)) + x.strip() + "B" \
for i, x in enumerate(' KMGTPEZY') \
if s < 1024 ** (i + 1) or i == 8][0]
class Application(cyclone.web.Application):
def __init__(self):
handlers = [
(r"/", IndexHandler),
]
settings = dict(
debug=True,
template_path="./template",
repository_path="./uploaded_files",
)
if not os.path.exists(settings["repository_path"]):
try:
os.mkdir(settings["repository_path"])
except Exception, e:
print("mkdir failed: %s" % str(e))
sys.exit(1)
cyclone.web.Application.__init__(self, handlers, **settings)
class IndexHandler(cyclone.web.RequestHandler):
def get(self):
self.render("index.html", missing=[], info=None)
def post(self):
name = self.get_argument("fullname", None)
if name is None:
self.render("index.html", missing=["fullname"], info=None)
return
picture = self.request.files.get("picture")
if picture is None:
self.render("index.html", missing=["picture"], info=None)
return
else:
picture = picture[0]
# File properties
filename = picture["filename"]
content_type = picture["content_type"]
body = picture["body"] # bytes!
try:
fn = os.path.join(self.settings.repository_path, filename)
fp = open(os.path.abspath(fn), "w")
fp.write(body)
fp.close()
except Exception, e:
log.msg("Could not write file: %s" % str(e))
raise cyclone.web.HTTPError(500)
self.render("index.html", missing=[], info={
"name": name,
"file": "%s, type=%s, size=%s" % \
(filename, content_type, humanreadable(len(body)))})
def main():
log.startLogging(sys.stdout)
reactor.listenTCP(8888, Application(), interface="127.0.0.1")
reactor.run()
if __name__ == "__main__":
main()
python-cyclone-1.1/scripts/ 0000755 0001750 0001750 00000000000 12124336260 015040 5 ustar lunar lunar python-cyclone-1.1/scripts/cyclone 0000755 0001750 0001750 00000001362 12124336260 016424 0 ustar lunar lunar #!/bin/bash
# Copyright 2012 Alexandre Fiori
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
opt=$1
shift
case "$opt" in
run)
twistd -n cyclone $*
;;
app)
python -m cyclone.app $*
;;
*)
echo "usage: $0 [run|app] [options]"
esac
python-cyclone-1.1/README.md 0000644 0001750 0001750 00000004374 12124336260 014640 0 ustar lunar lunar Cyclone
=======
Cyclone is a web server framework for Python, that implements the Tornado API
as a Twisted protocol.
See http://cyclone.io for details.
Installation
------------
Cyclone is listed in PyPI and can be installed with pip or easy_install.
Note that the source distribution includes demo applications that are not
present when Cyclone is installed in this way, so you may wish to download a
copy of the source tarball as well.
Manual installation
-------------------
Download the latest release from http://pypi.python.org/pypi/cyclone
tar zxvf cyclone-$VERSION.tar.gz
cd cyclone-$VERSION
sudo python setup.py install
The Cyclone source code is hosted on GitHub: https://github.com/fiorix/cyclone
Prerequisites
-------------
Cyclone runs on Python 2.5, 2.6 and 2.7, and requires:
- Twisted: http://twistedmatrix.com/trac/wiki/Downloads
- pyOpenSSL: https://launchpad.net/pyopenssl (only if you want SSL/TLS)
On Python 2.5, simplejson is required too.
Platforms
---------
Cyclone should run on any Unix-like platform, although for the best
performance and scalability only Linux and BSD (including BSD derivatives like
Mac OS X) are recommended.
Credits
-------
Thanks to (in no particular order):
- Nuswit Telephony API
- Granting permission for this code to be published and sponsoring
- Gleicon Moraes
- Testing and using on RestMQ
- Vanderson Mota
- Patching setup.py and PyPi maintenance
- Andrew Badr
- Fixing auth bugs and adding current Tornado's features
- Jon Oberheide
- Syncing code with Tornado and security features/fixes
- Silas Sewell
- Syncing code and minor mail fix
- Twitter Bootstrap
- For making our demo applications look good
- Dan Griffin
- WebSocket Keep-Alive for OpDemand
- Toby Padilla
- WebSocket server
- Jeethu Rao
- Minor bugfixes and patches
- Flavio Grossi
- Minor code fixes and websockets chat statistics example
- Gautam Jeyaraman
- Minor code fixes and patches
- DhilipSiva
- Minor patches
python-cyclone-1.1/LICENSE 0000644 0001750 0001750 00000026136 12124336260 014366 0 ustar lunar lunar
Apache License
Version 2.0, January 2004
http://www.apache.org/licenses/
TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
1. Definitions.
"License" shall mean the terms and conditions for use, reproduction,
and distribution as defined by Sections 1 through 9 of this document.
"Licensor" shall mean the copyright owner or entity authorized by
the copyright owner that is granting the License.
"Legal Entity" shall mean the union of the acting entity and all
other entities that control, are controlled by, or are under common
control with that entity. For the purposes of this definition,
"control" means (i) the power, direct or indirect, to cause the
direction or management of such entity, whether by contract or
otherwise, or (ii) ownership of fifty percent (50%) or more of the
outstanding shares, or (iii) beneficial ownership of such entity.
"You" (or "Your") shall mean an individual or Legal Entity
exercising permissions granted by this License.
"Source" form shall mean the preferred form for making modifications,
including but not limited to software source code, documentation
source, and configuration files.
"Object" form shall mean any form resulting from mechanical
transformation or translation of a Source form, including but
not limited to compiled object code, generated documentation,
and conversions to other media types.
"Work" shall mean the work of authorship, whether in Source or
Object form, made available under the License, as indicated by a
copyright notice that is included in or attached to the work
(an example is provided in the Appendix below).
"Derivative Works" shall mean any work, whether in Source or Object
form, that is based on (or derived from) the Work and for which the
editorial revisions, annotations, elaborations, or other modifications
represent, as a whole, an original work of authorship. For the purposes
of this License, Derivative Works shall not include works that remain
separable from, or merely link (or bind by name) to the interfaces of,
the Work and Derivative Works thereof.
"Contribution" shall mean any work of authorship, including
the original version of the Work and any modifications or additions
to that Work or Derivative Works thereof, that is intentionally
submitted to Licensor for inclusion in the Work by the copyright owner
or by an individual or Legal Entity authorized to submit on behalf of
the copyright owner. For the purposes of this definition, "submitted"
means any form of electronic, verbal, or written communication sent
to the Licensor or its representatives, including but not limited to
communication on electronic mailing lists, source code control systems,
and issue tracking systems that are managed by, or on behalf of, the
Licensor for the purpose of discussing and improving the Work, but
excluding communication that is conspicuously marked or otherwise
designated in writing by the copyright owner as "Not a Contribution."
"Contributor" shall mean Licensor and any individual or Legal Entity
on behalf of whom a Contribution has been received by Licensor and
subsequently incorporated within the Work.
2. Grant of Copyright License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
copyright license to reproduce, prepare Derivative Works of,
publicly display, publicly perform, sublicense, and distribute the
Work and such Derivative Works in Source or Object form.
3. Grant of Patent License. Subject to the terms and conditions of
this License, each Contributor hereby grants to You a perpetual,
worldwide, non-exclusive, no-charge, royalty-free, irrevocable
(except as stated in this section) patent license to make, have made,
use, offer to sell, sell, import, and otherwise transfer the Work,
where such license applies only to those patent claims licensable
by such Contributor that are necessarily infringed by their
Contribution(s) alone or by combination of their Contribution(s)
with the Work to which such Contribution(s) was submitted. If You
institute patent litigation against any entity (including a
cross-claim or counterclaim in a lawsuit) alleging that the Work
or a Contribution incorporated within the Work constitutes direct
or contributory patent infringement, then any patent licenses
granted to You under this License for that Work shall terminate
as of the date such litigation is filed.
4. Redistribution. You may reproduce and distribute copies of the
Work or Derivative Works thereof in any medium, with or without
modifications, and in Source or Object form, provided that You
meet the following conditions:
(a) You must give any other recipients of the Work or
Derivative Works a copy of this License; and
(b) You must cause any modified files to carry prominent notices
stating that You changed the files; and
(c) You must retain, in the Source form of any Derivative Works
that You distribute, all copyright, patent, trademark, and
attribution notices from the Source form of the Work,
excluding those notices that do not pertain to any part of
the Derivative Works; and
(d) If the Work includes a "NOTICE" text file as part of its
distribution, then any Derivative Works that You distribute must
include a readable copy of the attribution notices contained
within such NOTICE file, excluding those notices that do not
pertain to any part of the Derivative Works, in at least one
of the following places: within a NOTICE text file distributed
as part of the Derivative Works; within the Source form or
documentation, if provided along with the Derivative Works; or,
within a display generated by the Derivative Works, if and
wherever such third-party notices normally appear. The contents
of the NOTICE file are for informational purposes only and
do not modify the License. You may add Your own attribution
notices within Derivative Works that You distribute, alongside
or as an addendum to the NOTICE text from the Work, provided
that such additional attribution notices cannot be construed
as modifying the License.
You may add Your own copyright statement to Your modifications and
may provide additional or different license terms and conditions
for use, reproduction, or distribution of Your modifications, or
for any such Derivative Works as a whole, provided Your use,
reproduction, and distribution of the Work otherwise complies with
the conditions stated in this License.
5. Submission of Contributions. Unless You explicitly state otherwise,
any Contribution intentionally submitted for inclusion in the Work
by You to the Licensor shall be under the terms and conditions of
this License, without any additional terms or conditions.
Notwithstanding the above, nothing herein shall supersede or modify
the terms of any separate license agreement you may have executed
with Licensor regarding such Contributions.
6. Trademarks. This License does not grant permission to use the trade
names, trademarks, service marks, or product names of the Licensor,
except as required for reasonable and customary use in describing the
origin of the Work and reproducing the content of the NOTICE file.
7. Disclaimer of Warranty. Unless required by applicable law or
agreed to in writing, Licensor provides the Work (and each
Contributor provides its Contributions) on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
implied, including, without limitation, any warranties or conditions
of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
PARTICULAR PURPOSE. You are solely responsible for determining the
appropriateness of using or redistributing the Work and assume any
risks associated with Your exercise of permissions under this License.
8. Limitation of Liability. In no event and under no legal theory,
whether in tort (including negligence), contract, or otherwise,
unless required by applicable law (such as deliberate and grossly
negligent acts) or agreed to in writing, shall any Contributor be
liable to You for damages, including any direct, indirect, special,
incidental, or consequential damages of any character arising as a
result of this License or out of the use or inability to use the
Work (including but not limited to damages for loss of goodwill,
work stoppage, computer failure or malfunction, or any and all
other commercial damages or losses), even if such Contributor
has been advised of the possibility of such damages.
9. Accepting Warranty or Additional Liability. While redistributing
the Work or Derivative Works thereof, You may choose to offer,
and charge a fee for, acceptance of support, warranty, indemnity,
or other liability obligations and/or rights consistent with this
License. However, in accepting such obligations, You may act only
on Your own behalf and on Your sole responsibility, not on behalf
of any other Contributor, and only if You agree to indemnify,
defend, and hold each Contributor harmless for any liability
incurred by, or claims asserted against, such Contributor by reason
of your accepting any such warranty or additional liability.
END OF TERMS AND CONDITIONS
APPENDIX: How to apply the Apache License to your work.
To apply the Apache License to your work, attach the following
boilerplate notice, with the fields enclosed by brackets "[]"
replaced with your own identifying information. (Don't include
the brackets!) The text should be enclosed in the appropriate
comment syntax for the file format. We also recommend that a
file or class name and description of purpose be included on the
same "printed page" as the copyright notice for easier
identification within third-party archives.
Copyright [yyyy] [name of copyright owner]
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
python-cyclone-1.1/twisted/ 0000755 0001750 0001750 00000000000 12124336260 015034 5 ustar lunar lunar python-cyclone-1.1/twisted/plugins/ 0000755 0001750 0001750 00000000000 12124336260 016515 5 ustar lunar lunar python-cyclone-1.1/twisted/plugins/cyclone_plugin.py 0000644 0001750 0001750 00000011200 12124336260 022073 0 ustar lunar lunar # coding: utf-8
#
# Copyright 2012 Alexandre Fiori
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import cyclone.web
import imp
import os
import sys
import types
from twisted.application import internet
from twisted.application import service
from twisted.plugin import IPlugin
from twisted.python import usage
from twisted.python import reflect
from zope.interface import implements
try:
from twisted.internet import ssl
except ImportError:
ssl_support = False
else:
ssl_support = True
class Options(usage.Options):
# The reason for having app=x and ssl-app=y is to be able to have
# different URI routing on HTTP and HTTPS.
# Example: A login handler that only exists in HTTPS.
optParameters = [
["port", "p", 8888, "tcp port to listen on", int],
["listen", "l", "0.0.0.0", "interface to listen on"],
["unix", "u", None, "listen on unix socket instead of ip:port"],
["app", "r", None, "cyclone application to run"],
["appopts", "c", None, "arguments to your application"],
["ssl-port", None, 8443, "port to listen on for ssl", int],
["ssl-listen", None, "0.0.0.0", "interface to listen on for ssl"],
["ssl-cert", None, "server.crt", "ssl certificate"],
["ssl-key", None, "server.key", "ssl server key"],
["ssl-app", None, None, "ssl application (same as --app)"],
["ssl-appopts", None, None, "arguments to the ssl application"],
]
def parseArgs(self, *args):
if args:
self["filename"] = args[0]
class ServiceMaker(object):
implements(service.IServiceMaker, IPlugin)
tapname = "cyclone"
description = "A high performance web server"
options = Options
def makeService(self, options):
srv = service.MultiService()
s = None
if "app" in options and (options["app"] or "")[-3:].lower() == ".py":
options["filename"] = options["app"]
if "filename" in options and os.path.exists(options["filename"]):
n = os.path.splitext(os.path.split(options["filename"])[-1])[0]
appmod = imp.load_source(n, options["filename"])
for name in dir(appmod):
kls = getattr(appmod, name)
if isinstance(kls, (type, types.ClassType)):
if issubclass(kls, cyclone.web.Application):
options["app"] = kls
if ssl_support and os.path.exists(options["ssl-cert"]):
options["ssl-app"] = kls
# http
if options["app"]:
if callable(options["app"]):
appmod = options["app"]
else:
appmod = reflect.namedAny(options["app"])
if options["appopts"]:
app = appmod(options["appopts"])
else:
app = appmod()
unix = options.get("unix")
if unix:
s = internet.UNIXServer(unix, app)
else:
s = internet.TCPServer(options["port"], app,
interface=options["listen"])
s.setServiceParent(srv)
# https
if options["ssl-app"]:
if ssl_support:
if callable(options["ssl-app"]):
appmod = options["ssl-app"]
else:
appmod = reflect.namedAny(options["ssl-app"])
if options["ssl-appopts"]:
app = appmod(options["ssl-appopts"])
else:
app = appmod()
s = internet.SSLServer(options["ssl-port"], app,
ssl.DefaultOpenSSLContextFactory(
options["ssl-key"],
options["ssl-cert"]),
interface=options["ssl-listen"])
s.setServiceParent(srv)
else:
print("SSL support is disabled. "
"Install PyOpenSSL and try again.")
if s is None:
print("usage: cyclone run [server.py|--help]")
sys.exit(1)
return srv
serviceMaker = ServiceMaker()
python-cyclone-1.1/appskel/ 0000755 0001750 0001750 00000000000 12124336260 015010 5 ustar lunar lunar python-cyclone-1.1/appskel/default/ 0000755 0001750 0001750 00000000000 12124336260 016434 5 ustar lunar lunar python-cyclone-1.1/appskel/default/modname/ 0000755 0001750 0001750 00000000000 12124336260 020054 5 ustar lunar lunar python-cyclone-1.1/appskel/default/modname/views.py 0000644 0001750 0001750 00000004366 12124336260 021574 0 ustar lunar lunar # coding: utf-8
#
$license
import cyclone.escape
import cyclone.locale
import cyclone.web
from twisted.internet import defer
from twisted.python import log
from $modname.storage import DatabaseMixin
from $modname.utils import BaseHandler
from $modname.utils import TemplateFields
class IndexHandler(BaseHandler):
def get(self):
self.render("index.html", hello="world", awesome="bacon")
def post(self):
f = TemplateFields(post=True, ip=self.request.remote_ip)
#f["this_is_a_dict"] = True
#f["raw_config"] = self.settings.raw
#f["mysql_host"] = self.settings.raw.get("mysql", "host")
self.render("post.html", fields=f)
class LangHandler(BaseHandler):
def get(self, lang_code):
if lang_code in cyclone.locale.get_supported_locales():
self.set_secure_cookie("lang", lang_code)
self.redirect(self.request.headers.get("Referer",
self.get_argument("next", "/")))
class SampleSQLiteHandler(BaseHandler, DatabaseMixin):
def get(self):
if self.sqlite:
response = self.sqlite.runQuery("select strftime('%Y-%m-%d')")
self.write({"response": response})
else:
self.write("SQLite is disabled\r\n")
class SampleRedisHandler(BaseHandler, DatabaseMixin):
@defer.inlineCallbacks
def get(self):
if self.redis:
try:
response = yield self.redis.get("foo")
except Exception, e:
log.msg("Redis query failed: %s" % str(e))
raise cyclone.web.HTTPError(503) # Service Unavailable
else:
self.write({"response": response})
else:
self.write("Redis is disabled\r\n")
class SampleMySQLHandler(BaseHandler, DatabaseMixin):
@defer.inlineCallbacks
def get(self):
if self.mysql:
try:
response = yield self.mysql.runQuery("select now()")
except Exception, e:
log.msg("MySQL query failed: %s" % str(e))
raise cyclone.web.HTTPError(503) # Service Unavailable
else:
self.write({"response": str(response[0][0])})
else:
self.write("MySQL is disabled\r\n")
python-cyclone-1.1/appskel/default/modname/web.py 0000644 0001750 0001750 00000002012 12124336260 021176 0 ustar lunar lunar # coding: utf-8
#
$license
import cyclone.locale
import cyclone.web
from $modname import views
from $modname import config
from $modname.storage import DatabaseMixin
class Application(cyclone.web.Application):
def __init__(self, config_file):
handlers = [
(r"/", views.IndexHandler),
(r"/lang/(.+)", views.LangHandler),
(r"/sample/mysql", views.SampleMySQLHandler),
(r"/sample/redis", views.SampleRedisHandler),
(r"/sample/sqlite", views.SampleSQLiteHandler),
]
conf = config.parse_config(config_file)
# Initialize locales
if "locale_path" in conf:
cyclone.locale.load_gettext_translations(conf["locale_path"],
"$modname")
# Set up database connections
DatabaseMixin.setup(conf)
#conf["login_url"] = "/auth/login"
#conf["autoescape"] = None
cyclone.web.Application.__init__(self, handlers, **conf)
python-cyclone-1.1/appskel/default/modname/utils.py 0000644 0001750 0001750 00000001342 12124336260 021566 0 ustar lunar lunar # coding: utf-8
#
$license
import cyclone.escape
import cyclone.web
class TemplateFields(dict):
"""Helper class to make sure our
template doesn't fail due to an invalid key"""
def __getattr__(self, name):
try:
return self[name]
except KeyError:
return None
def __setattr__(self, name, value):
self[name] = value
class BaseHandler(cyclone.web.RequestHandler):
#def get_current_user(self):
# user_json = self.get_secure_cookie("user")
# if user_json:
# return cyclone.escape.json_decode(user_json)
def get_user_locale(self):
lang = self.get_secure_cookie("lang")
if lang:
return cyclone.locale.get(lang)
python-cyclone-1.1/appskel/default/modname/storage.py 0000644 0001750 0001750 00000005715 12124336260 022102 0 ustar lunar lunar # coding: utf-8
#
$license
try:
sqlite_ok = True
import cyclone.sqlite
except ImportError, sqlite_err:
sqlite_ok = False
import cyclone.redis
from twisted.enterprise import adbapi
from twisted.internet import defer
from twisted.internet import reactor
from twisted.python import log
class DatabaseMixin(object):
mysql = None
redis = None
sqlite = None
@classmethod
def setup(cls, conf):
if "sqlite_settings" in conf:
if sqlite_ok:
DatabaseMixin.sqlite = \
cyclone.sqlite.InlineSQLite(conf["sqlite_settings"].database)
else:
log.err("SQLite is currently disabled: %s" % sqlite_err)
if "redis_settings" in conf:
if conf["redis_settings"].get("unixsocket"):
DatabaseMixin.redis = \
cyclone.redis.lazyUnixConnectionPool(
conf["redis_settings"].unixsocket,
conf["redis_settings"].dbid,
conf["redis_settings"].poolsize)
else:
DatabaseMixin.redis = \
cyclone.redis.lazyConnectionPool(
conf["redis_settings"].host,
conf["redis_settings"].port,
conf["redis_settings"].dbid,
conf["redis_settings"].poolsize)
if "mysql_settings" in conf:
DatabaseMixin.mysql = \
adbapi.ConnectionPool("MySQLdb",
host=conf["mysql_settings"].host,
port=conf["mysql_settings"].port,
db=conf["mysql_settings"].database,
user=conf["mysql_settings"].username,
passwd=conf["mysql_settings"].password,
cp_min=1,
cp_max=conf["mysql_settings"].poolsize,
cp_reconnect=True,
cp_noisy=conf["mysql_settings"].debug)
# Ping MySQL to avoid timeouts. On timeouts, the first query
# responds with the following error, before it reconnects:
# mysql.Error: (2006, 'MySQL server has gone away')
#
# There's no way differentiate this from the server shutting down
# and write() failing. To avoid the timeout, we ping.
@defer.inlineCallbacks
def _ping_mysql():
try:
yield cls.mysql.runQuery("select 1")
except Exception, e:
log.msg("MySQL ping error:", e)
else:
if conf["mysql_settings"].debug:
log.msg("MySQL ping: OK")
reactor.callLater(conf["mysql_settings"].ping, _ping_mysql)
if conf["mysql_settings"].ping > 1:
_ping_mysql()
python-cyclone-1.1/appskel/default/modname/__init__.py 0000644 0001750 0001750 00000000123 12124336260 022161 0 ustar lunar lunar # coding: utf-8
#
$license
__author__ = "$name <$email>"
__version__ = "$version"
python-cyclone-1.1/appskel/default/modname/config.py 0000644 0001750 0001750 00000006105 12124336260 021675 0 ustar lunar lunar # coding: utf-8
#
$license
import os
import sys
import ConfigParser
from cyclone.util import ObjectDict
def tryget(func, section, option, default=None):
try:
return func(section, option)
except ConfigParser.NoOptionError:
return default
def my_parse_config(filename):
cp = ConfigParser.RawConfigParser()
cp.read([filename])
conf = dict(raw=cp, config_file=filename)
# server settings
conf["debug"] = tryget(cp.getboolean, "server", "debug", False)
conf["xheaders"] = tryget(cp.getboolean, "server", "xheaders", False)
conf["cookie_secret"] = cp.get("server", "cookie_secret")
conf["xsrf_cookies"] = tryget(cp.getboolean,
"server", "xsrf_cookies", False)
# make relative path absolute to this file's parent directory
root = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
getpath = lambda k, v: os.path.join(root, tryget(cp.get, k, v))
# locale, template and static directories
conf["locale_path"] = getpath("frontend", "locale_path")
conf["static_path"] = getpath("frontend", "static_path")
conf["template_path"] = getpath("frontend", "template_path")
# sqlite support
if tryget(cp.getboolean, "sqlite", "enabled", False) is True:
conf["sqlite_settings"] = \
ObjectDict(database=cp.get("sqlite", "database"))
# redis support
if tryget(cp.getboolean, "redis", "enabled", False) is True:
conf["redis_settings"] = ObjectDict(
unixsocket=tryget(cp.get, "redis", "unixsocket", None),
host=tryget(cp.get, "redis", "host", "127.0.0.1"),
port=tryget(cp.getint, "redis", "port", 6379),
dbid=tryget(cp.getint, "redis", "dbid", 0),
poolsize=tryget(cp.getint, "redis", "poolsize", 10))
# mysql support
if tryget(cp.getboolean, "mysql", "enabled", False) is True:
conf["mysql_settings"] = ObjectDict(
host=cp.get("mysql", "host"),
port=cp.getint("mysql", "port"),
username=tryget(cp.get, "mysql", "username"),
password=tryget(cp.get, "mysql", "password"),
database=tryget(cp.get, "mysql", "database"),
poolsize=tryget(cp.getint, "mysql", "poolsize", 10),
debug=tryget(cp.getboolean, "mysql", "debug", False),
ping=tryget(cp.getint, "mysql", "ping_interval"))
# email support
if tryget(cp.getboolean, "email", "enabled", False) is True:
conf["email_settings"] = ObjectDict(
host=cp.get("email", "host"),
port=tryget(cp.getint, "email", "port"),
tls=tryget(cp.getboolean, "email", "tls"),
username=tryget(cp.get, "email", "username"),
password=tryget(cp.get, "email", "password"))
return conf
def parse_config(filename):
try:
return my_parse_config(filename)
except Exception, e:
print("Error parsing %s: %s" % (filename, e))
sys.exit(1)
python-cyclone-1.1/appskel/default/start.sh 0000755 0001750 0001750 00000000303 12124336260 020124 0 ustar lunar lunar #!/bin/bash
# see scripts/debian-init.d for production deployments
export PYTHONPATH=`dirname $$0`
twistd -n cyclone -p 8888 -l 0.0.0.0 \
-r $modname.web.Application -c $modname.conf $$*
python-cyclone-1.1/appskel/default/.gitignore 0000644 0001750 0001750 00000000031 12124336260 020416 0 ustar lunar lunar *.swp
*.pyc
dropin.cache
python-cyclone-1.1/appskel/default/scripts/ 0000755 0001750 0001750 00000000000 12124336260 020123 5 ustar lunar lunar python-cyclone-1.1/appskel/default/scripts/cookie_secret.py 0000644 0001750 0001750 00000000255 12124336260 023315 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
$license
import base64
import uuid
if __name__ == "__main__":
print(base64.b64encode(uuid.uuid4().bytes + uuid.uuid4().bytes))
python-cyclone-1.1/appskel/default/scripts/debian-init.d 0000644 0001750 0001750 00000003306 12124336260 022455 0 ustar lunar lunar #!/bin/sh
### BEGIN INIT INFO
# Provides: $modname
# Required-Start: $$all
# Required-Stop: $$all
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Starts a service on the cyclone web server
# Description: Foobar
### END INIT INFO
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/bin/twistd
SERVICE_DIR=/path/to/$modname
SERVICE_NAME=$modname
PYTHONPATH=$$SERVICE_DIR:$$PYTHONPATH
export PYTHONPATH
PORT=8888
LISTEN="127.0.0.1"
CONFIG=$$SERVICE_DIR/$$SERVICE_NAME.conf
PIDFILE=/var/run/$$SERVICE_NAME.pid
LOGFILE=/var/log/$$SERVICE_NAME.log
APP=$${SERVICE_NAME}.web.Application
USER=www-data
GROUP=www-data
DAEMON_OPTS="-u $$USER -g $$GROUP --pidfile=$$PIDFILE --logfile=$$LOGFILE cyclone --port $$PORT --listen $$LISTEN --app $$APP -c $$CONFIG"
if [ ! -x $$DAEMON ]; then
echo "ERROR: Can't execute $$DAEMON."
exit 1
fi
if [ ! -d $$SERVICE_DIR ]; then
echo "ERROR: Directory doesn't exist: $$SERVICE_DIR"
exit 1
fi
start_service() {
echo -n " * Starting $$SERVICE_NAME... "
start-stop-daemon -Sq -p $$PIDFILE -x $$DAEMON -- $$DAEMON_OPTS
e=$$?
if [ $$e -eq 1 ]; then
echo "already running"
return
fi
if [ $$e -eq 255 ]; then
echo "couldn't start"
return
fi
echo "done"
}
stop_service() {
echo -n " * Stopping $$SERVICE_NAME... "
start-stop-daemon -Kq -R 10 -p $$PIDFILE
e=$$?
if [ $$e -eq 1 ]; then
echo "not running"
return
fi
echo "done"
}
case "$$1" in
start)
start_service
;;
stop)
stop_service
;;
restart)
stop_service
start_service
;;
*)
echo "Usage: /etc/init.d/$$SERVICE_NAME {start|stop|restart}" >&2
exit 1
;;
esac
exit 0
python-cyclone-1.1/appskel/default/scripts/debian-multicore-init.d 0000644 0001750 0001750 00000004433 12124336260 024460 0 ustar lunar lunar #!/bin/bash
### BEGIN INIT INFO
# Provides: $modname
# Required-Start: $$all
# Required-Stop: $$all
# Default-Start: 2 3 4 5
# Default-Stop: 0 1 6
# Short-Description: Starts a service on the cyclone web server
# Description: Foobar
### END INIT INFO
PATH=/usr/local/sbin:/usr/local/bin:/sbin:/bin:/usr/sbin:/usr/bin
DAEMON=/usr/bin/twistd
SERVICE_DIR=/path/to/$modname
SERVICE_NAME=$modname
PYTHONPATH=$$SERVICE_DIR:$$PYTHONPATH
export PYTHONPATH
INSTANCES=4
START_PORT=9901
LISTEN="127.0.0.1"
CONFIG=$$SERVICE_DIR/$$SERVICE_NAME.conf
APP=$${SERVICE_NAME}.web.Application
USER=www-data
GROUP=www-data
# Check out the start_service function for other customization options
# such as setting CPU affinity.
if [ ! -x $$DAEMON ]; then
echo "ERROR: Can't execute $$DAEMON."
exit 1
fi
if [ ! -d $$SERVICE_DIR ]; then
echo "ERROR: Directory doesn't exist: $$SERVICE_DIR"
exit 1
fi
start_service() {
echo -n " * Starting $$SERVICE_NAME... "
for n in `seq 1 $$INSTANCES`
do
PORT=$$[START_PORT]
PIDFILE=/var/run/$$SERVICE_NAME.$$PORT.pid
LOGFILE=/var/log/$$SERVICE_NAME.$$PORT.log
DAEMON_OPTS="-u $$USER -g $$GROUP --pidfile=$$PIDFILE --logfile=$$LOGFILE cyclone --port $$PORT --listen $$LISTEN --app $$APP -c $$CONFIG"
START_PORT=$$[PORT+1]
start-stop-daemon -Sq -p $$PIDFILE -x $$DAEMON -- $$DAEMON_OPTS
e=$$?
if [ $$e -eq 1 ]; then
echo "already running"
return
fi
if [ $$e -eq 255 ]; then
echo "couldn't start"
return
fi
# Set CPU affinity
if [ -x /usr/bin/taskset ]; then
sleep 1
/usr/bin/taskset -pc $$n `cat $$PIDFILE` &> /dev/null
fi
done
echo "done"
}
stop_service() {
echo -n " * Stopping $$SERVICE_NAME... "
for n in `seq 1 $$INSTANCES`
do
PORT=$$[START_PORT]
PIDFILE=/var/run/$$SERVICE_NAME.$$PORT.pid
START_PORT=$$[PORT+1]
start-stop-daemon -Kq -R 10 -p $$PIDFILE
e=$$?
if [ $$e -eq 1 ]; then
echo "not running"
return
fi
done
echo "done"
}
case "$$1" in
start)
start_service
;;
stop)
stop_service
;;
restart)
sp=$$START_PORT
stop_service
START_PORT=$$sp
start_service
;;
*)
echo "Usage: /etc/init.d/$$SERVICE_NAME {start|stop|restart}" >&2
exit 1
;;
esac
exit 0
python-cyclone-1.1/appskel/default/scripts/localefix.py 0000644 0001750 0001750 00000000576 12124336260 022453 0 ustar lunar lunar #!/usr/bin/env python
# coding: utf-8
#
$license
import re
import sys
if __name__ == "__main__":
try:
filename = sys.argv[1]
assert filename != "-"
fd = open(filename)
except:
fd = sys.stdin
line_re = re.compile(r'="([^"]+)"')
for line in fd:
line = line_re.sub(r"=\\1", line)
sys.stdout.write(line)
fd.close()
python-cyclone-1.1/appskel/default/README.md 0000644 0001750 0001750 00000005637 12124336260 017726 0 ustar lunar lunar # cyclone-based project
This is the source code of $project_name
$name <$email>
## About
This file has been created automatically by cyclone for $project_name.
It contains the following:
- ``start.sh``: simple shell script to start the development server
- ``$modname.conf``: configuration file for the web server
- ``$modname/``: web server code
- ``frontend/``: static files, templates and locales
- ``scripts/``: debian init scripts and other useful scripts
### Running
For development and testing:
twistd -n cyclone --help
twistd -n cyclone -r $modname.web.Application [--help]
or just run ./start.sh
For production:
twistd cyclone \
--logfile=/var/log/$project.log \
--pidfile=/var/run/$project.pid \
-r $modname.web.Application
or check scripts/debian-init.d and scripts/debian-multicore-init.d
## Customization
This section is dedicated to explaining how to customize your brand new
package.
### Databases
cyclone provides built-in support for SQLite and Redis databases.
It also supports any RDBM supported by the ``twisted.enterprise.adbapi``
module, like MySQL or PostgreSQL.
The default configuration file ``$modname.conf`` ships with pre-configured
settings for SQLite, Redis and MySQL.
The code for loading all the database settings is in ``$modname/config.py``.
Feel free to comment or even remove such code, and configuration entries. It
shouldn't break the web server.
Take a look at ``$modname/storage.py``, which is where persistent database
connections are initialized.
### Internationalization
cyclone uses the standard ``gettext`` library for dealing with string
translation.
Make sure you have the ``gettext`` package installed. If you don't, you won't
be able to translate your software.
For installing the ``gettext`` package on Debian and Ubuntu systems, do this:
apt-get install gettext
For Mac OS X, I'd suggest using [HomeBrew](http://mxcl.github.com/homebrew>).
If you already use HomeBrew, run:
brew install gettext
brew link gettext
For generating translatable files for HTML and Python code of your software,
run this:
cat frontend/template/*.html $modname/*.py | python scripts/localefix.py | xgettext - --language=Python --from-code=utf-8 --keyword=_:1,2 -d $modname
Then translate $modname.po, compile and copy to the appropriate locale
directory:
(pt_BR is used as example here)
vi $modname.po
mkdir -p frontend/locale/pt_BR/LC_MESSAGES/
msgfmt $modname.po -o frontend/locale/pt_BR/LC_MESSAGES/$modname.mo
There are sample translations for both Spanish and Portuguese in this package,
already compiled.
### Cookie Secret
The current cookie secret key in ``$modname.conf`` was generated during the
creation of this package. However, if you need a new one, you may run the
``scripts/cookie_secret.py`` script to generate a random key.
## Credits
- [cyclone](http://github.com/fiorix/cyclone) web server.
python-cyclone-1.1/appskel/default/frontend/ 0000755 0001750 0001750 00000000000 12124336260 020253 5 ustar lunar lunar python-cyclone-1.1/appskel/default/frontend/locale/ 0000755 0001750 0001750 00000000000 12124336260 021512 5 ustar lunar lunar python-cyclone-1.1/appskel/default/frontend/locale/es_ES/ 0000755 0001750 0001750 00000000000 12124336260 022510 5 ustar lunar lunar python-cyclone-1.1/appskel/default/frontend/locale/es_ES/LC_MESSAGES/ 0000755 0001750 0001750 00000000000 12124336260 024275 5 ustar lunar lunar python-cyclone-1.1/appskel/default/frontend/locale/es_ES/LC_MESSAGES/modname.po 0000644 0001750 0001750 00000001314 12124336260 026254 0 ustar lunar lunar # cyclone-tools sample translation.
# Copyright (C) 2011 Alexandre Fiori
# This file is distributed under the same license as the cyclone package.
# Alexandre Fiori , 2011.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: 0.1\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2011-02-24 15:36-0300\n"
"PO-Revision-Date: 2011-02-28 15:44+-0300\n"
"Last-Translator: Alexandre Fiori \n"
"Language-Team: Alexandre Fiori \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: standard input:5
msgid "cyclone web server"
msgstr "servidor web cyclone"
#: standard input:8
msgid "It works!"
msgstr "¡Funciona!"
python-cyclone-1.1/appskel/default/frontend/locale/es_ES/LC_MESSAGES/modname.mo 0000644 0001750 0001750 00000000741 12124336260 026254 0 ustar lunar lunar Þ• 4 L ` a k A ~ À Ì It works! cyclone web server Project-Id-Version: 0.1
Report-Msgid-Bugs-To:
POT-Creation-Date: 2011-02-24 15:36-0300
PO-Revision-Date: 2011-02-28 15:44+-0300
Last-Translator: Alexandre Fiori
Language-Team: Alexandre Fiori
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
¡Funciona! servidor web cyclone python-cyclone-1.1/appskel/default/frontend/locale/pt_BR/ 0000755 0001750 0001750 00000000000 12124336260 022520 5 ustar lunar lunar python-cyclone-1.1/appskel/default/frontend/locale/pt_BR/LC_MESSAGES/ 0000755 0001750 0001750 00000000000 12124336260 024305 5 ustar lunar lunar python-cyclone-1.1/appskel/default/frontend/locale/pt_BR/LC_MESSAGES/modname.po 0000644 0001750 0001750 00000001312 12124336260 026262 0 ustar lunar lunar # cyclone-tools sample translation.
# Copyright (C) 2011 Alexandre Fiori
# This file is distributed under the same license as the cyclone package.
# Alexandre Fiori , 2011.
#
#, fuzzy
msgid ""
msgstr ""
"Project-Id-Version: 0.1\n"
"Report-Msgid-Bugs-To: \n"
"POT-Creation-Date: 2011-02-24 15:36-0300\n"
"PO-Revision-Date: 2011-02-28 15:44+-0300\n"
"Last-Translator: Alexandre Fiori \n"
"Language-Team: Alexandre Fiori \n"
"MIME-Version: 1.0\n"
"Content-Type: text/plain; charset=utf-8\n"
"Content-Transfer-Encoding: 8bit\n"
#: standard input:5
msgid "cyclone web server"
msgstr "servidor web cyclone"
#: standard input:8
msgid "It works!"
msgstr "Funciona!"
python-cyclone-1.1/appskel/default/frontend/locale/pt_BR/LC_MESSAGES/modname.mo 0000644 0001750 0001750 00000000737 12124336260 026271 0 ustar lunar lunar Þ• 4 L ` a k A ~ À Ê It works! cyclone web server Project-Id-Version: 0.1
Report-Msgid-Bugs-To:
POT-Creation-Date: 2011-02-24 15:36-0300
PO-Revision-Date: 2011-02-28 15:44+-0300
Last-Translator: Alexandre Fiori
Language-Team: Alexandre Fiori
MIME-Version: 1.0
Content-Type: text/plain; charset=utf-8
Content-Transfer-Encoding: 8bit
Funciona! servidor web cyclone python-cyclone-1.1/appskel/default/frontend/template/ 0000755 0001750 0001750 00000000000 12124336260 022066 5 ustar lunar lunar python-cyclone-1.1/appskel/default/frontend/template/index.html 0000644 0001750 0001750 00000000577 12124336260 024074 0 ustar lunar lunar {% extends 'base.html' %}
{% block page %}
Cras justo odio, dapibus ac facilisis in, egestas eget quam. Fusce dapibus, tellus ac cursus commodo, tortor mauris condimentum nibh, ut fermentum massa justo sit amet risus.
### bold.html
{% extends "base.html" %}
{% block title %}A bolder title{% end %}
{% block student %}
{{ escape(student.name) }}
{% end %}
Unlike most other template systems, we do not put any restrictions on the
expressions you can include in your statements. if and for blocks get
translated exactly into Python, you can do complex expressions like::
{% for student in [p for p in people if p.student and p.age > 23] %}
{{ escape(student.name) }}
{% end %}
Translating directly to Python means you can apply functions to expressions
easily, like the escape() function in the examples above. You can pass
functions in to your template just like any other variable::
### Python code
def add(x, y):
return x + y
template.execute(add=add)
### The template
{{ add(1, 2) }}
We provide the functions escape(), url_escape(), json_encode(), and squeeze()
to all templates by default.
Typical applications do not create `Template` or `Loader` instances by
hand, but instead use the `render` and `render_string` methods of
`cyclone.web.RequestHandler`, which load templates automatically based
on the ``template_path`` `Application` setting.
Syntax Reference
----------------
Template expressions are surrounded by double curly braces: ``{{ ... }}``.
The contents may be any python expression, which will be escaped according
to the current autoescape setting and inserted into the output. Other
template directives use ``{% %}``. These tags may be escaped as ``{{!``
and ``{%!`` if you need to include a literal ``{{`` or ``{%`` in the output.
To comment out a section so that it is omitted from the output, surround it
with ``{# ... #}``.
``{% apply *function* %}...{% end %}``
Applies a function to the output of all template code between ``apply``
and ``end``::
{% apply linkify %}{{name}} said: {{message}}{% end %}
Note that as an implementation detail apply blocks are implemented
as nested functions and thus may interact strangely with variables
set via ``{% set %}``, or the use of ``{% break %}`` or ``{% continue %}``
within loops.
``{% autoescape *function* %}``
Sets the autoescape mode for the current file. This does not affect
other files, even those referenced by ``{% include %}``. Note that
autoescaping can also be configured globally, at the `Application`
or `Loader`.::
{% autoescape xhtml_escape %}
{% autoescape None %}
``{% block *name* %}...{% end %}``
Indicates a named, replaceable block for use with ``{% extends %}``.
Blocks in the parent template will be replaced with the contents of
the same-named block in a child template.::
{% block title %}Default title{% end %}
{% extends "base.html" %}
{% block title %}My page title{% end %}
``{% comment ... %}``
A comment which will be removed from the template output. Note that
there is no ``{% end %}`` tag; the comment goes from the word ``comment``
to the closing ``%}`` tag.
``{% extends *filename* %}``
Inherit from another template. Templates that use ``extends`` should
contain one or more ``block`` tags to replace content from the parent
template. Anything in the child template not contained in a ``block``
tag will be ignored. For an example, see the ``{% block %}`` tag.
``{% for *var* in *expr* %}...{% end %}``
Same as the python ``for`` statement. ``{% break %}`` and
``{% continue %}`` may be used inside the loop.
``{% from *x* import *y* %}``
Same as the python ``import`` statement.
``{% if *condition* %}...{% elif *condition* %}...{% else %}...{% end %}``
Conditional statement - outputs the first section whose condition is
true. (The ``elif`` and ``else`` sections are optional)
``{% import *module* %}``
Same as the python ``import`` statement.
``{% include *filename* %}``
Includes another template file. The included file can see all the local
variables as if it were copied directly to the point of the ``include``
directive (the ``{% autoescape %}`` directive is an exception).
Alternately, ``{% module Template(filename, **kwargs) %}`` may be used
to include another template with an isolated namespace.
``{% module *expr* %}``
Renders a `~cyclone.web.UIModule`. The output of the ``UIModule`` is
not escaped::
{% module Template("foo.html", arg=42) %}
``{% raw *expr* %}``
Outputs the result of the given expression without autoescaping.
``{% set *x* = *y* %}``
Sets a local variable.
``{% try %}...{% except %}...{% finally %}...{% else %}...{% end %}``
Same as the python ``try`` statement.
``{% while *condition* %}... {% end %}``
Same as the python ``while`` statement. ``{% break %}`` and
``{% continue %}`` may be used inside the loop.
"""
from __future__ import absolute_import, division, with_statement
import datetime
import linecache
import os.path
import posixpath
import re
import sys
import threading
import traceback
import types
from cStringIO import StringIO
from cyclone import escape
from cyclone.util import ObjectDict
from cyclone.util import bytes_type
from cyclone.util import unicode_type
_DEFAULT_AUTOESCAPE = "xhtml_escape"
_UNSET = object()
class Template(object):
"""A compiled template.
We compile into Python from the given template_string. You can generate
the template from variables with generate().
"""
def __init__(self, template_string, name="", loader=None,
compress_whitespace=None, autoescape=_UNSET):
self.name = name
if compress_whitespace is None:
compress_whitespace = name.endswith(".html") or \
name.endswith(".js")
if autoescape is not _UNSET:
self.autoescape = autoescape
elif loader:
self.autoescape = loader.autoescape
else:
self.autoescape = _DEFAULT_AUTOESCAPE
self.namespace = loader.namespace if loader else {}
reader = _TemplateReader(name, escape.native_str(template_string))
try:
self.file = _File(self, _parse(reader, self))
self.code = self._generate_python(loader, compress_whitespace)
except ParseError, e:
raise TemplateError("Error parsing template %s, line %d: %s" %
(name, reader.line, str(e)))
self.loader = loader
try:
# Under python2.5, the fake filename used here must match
# the module name used in __name__ below.
self.compiled = compile(
escape.to_unicode(self.code),
"%s.generated.py" % self.name.replace('.', '_'),
"exec")
except Exception:
raise TemplateError("Error compiling template " + name + ":\n" +
_format_code(self.code).rstrip())
def generate(self, **kwargs):
"""Generate this template with the given arguments."""
namespace = {
"escape": escape.xhtml_escape,
"xhtml_escape": escape.xhtml_escape,
"url_escape": escape.url_escape,
"json_encode": escape.json_encode,
"squeeze": escape.squeeze,
"linkify": escape.linkify,
"datetime": datetime,
"_utf8": escape.utf8, # for internal use
"_string_types": (unicode_type, bytes_type),
# __name__ and __loader__ allow the traceback mechanism to find
# the generated source code.
"__name__": self.name.replace('.', '_'),
"__loader__": ObjectDict(get_source=lambda name: self.code),
}
namespace.update(self.namespace)
namespace.update(kwargs)
exec self.compiled in namespace
execute = namespace["_execute"]
# Clear the traceback module's cache of source data now that
# we've generated a new template (mainly for this module's
# unittests, where different tests reuse the same name).
linecache.clearcache()
try:
return execute()
except:
raise TemplateError("Error executing template " + self.name +
":\n" + _format_code(traceback.format_exception(*sys.exc_info())))
def _generate_python(self, loader, compress_whitespace):
buffer = StringIO()
try:
# named_blocks maps from names to _NamedBlock objects
named_blocks = {}
ancestors = self._get_ancestors(loader)
ancestors.reverse()
for ancestor in ancestors:
ancestor.find_named_blocks(loader, named_blocks)
self.file.find_named_blocks(loader, named_blocks)
writer = _CodeWriter(buffer, named_blocks, loader,
ancestors[0].template,
compress_whitespace)
ancestors[0].generate(writer)
return buffer.getvalue()
finally:
buffer.close()
def _get_ancestors(self, loader):
ancestors = [self.file]
for chunk in self.file.body.chunks:
if isinstance(chunk, _ExtendsBlock):
if not loader:
raise ParseError("{% extends %} block found, but no "
"template loader")
template = loader.load(chunk.name, self.name)
ancestors.extend(template._get_ancestors(loader))
return ancestors
class BaseLoader(object):
"""Base class for template loaders."""
def __init__(self, autoescape=_DEFAULT_AUTOESCAPE, namespace=None):
"""Creates a template loader.
root_directory may be the empty string if this loader does not
use the filesystem.
autoescape must be either None or a string naming a function
in the template namespace, such as "xhtml_escape".
"""
self.autoescape = autoescape
self.namespace = namespace or {}
self.templates = {}
# self.lock protects self.templates. It's a reentrant lock
# because templates may load other templates via `include` or
# `extends`. Note that thanks to the GIL this code would be safe
# even without the lock, but could lead to wasted work as multiple
# threads tried to compile the same template simultaneously.
self.lock = threading.RLock()
def reset(self):
"""Resets the cache of compiled templates."""
with self.lock:
self.templates = {}
def resolve_path(self, name, parent_path=None):
"""Converts a possibly-relative path to absolute (used internally)."""
raise NotImplementedError()
def load(self, name, parent_path=None):
"""Loads a template."""
name = self.resolve_path(name, parent_path=parent_path)
with self.lock:
if name not in self.templates:
self.templates[name] = self._create_template(name)
return self.templates[name]
def _create_template(self, name):
raise NotImplementedError()
class Loader(BaseLoader):
"""A template loader that loads from a single root directory.
You must use a template loader to use template constructs like
{% extends %} and {% include %}. Loader caches all templates after
they are loaded the first time.
"""
def __init__(self, root_directory, **kwargs):
super(Loader, self).__init__(**kwargs)
self.root = os.path.abspath(root_directory)
def resolve_path(self, name, parent_path=None):
if parent_path and not parent_path.startswith("<") and \
not parent_path.startswith("/") and \
not name.startswith("/"):
current_path = os.path.join(self.root, parent_path)
file_dir = os.path.dirname(os.path.abspath(current_path))
relative_path = os.path.abspath(os.path.join(file_dir, name))
if relative_path.startswith(self.root):
name = relative_path[len(self.root) + 1:]
return name
def _create_template(self, name):
path = os.path.join(self.root, name)
f = open(path, "rb")
template = Template(f.read(), name=name, loader=self)
f.close()
return template
class DictLoader(BaseLoader):
"""A template loader that loads from a dictionary."""
def __init__(self, dict, **kwargs):
super(DictLoader, self).__init__(**kwargs)
self.dict = dict
def resolve_path(self, name, parent_path=None):
if parent_path and not parent_path.startswith("<") and \
not parent_path.startswith("/") and \
not name.startswith("/"):
file_dir = posixpath.dirname(parent_path)
name = posixpath.normpath(posixpath.join(file_dir, name))
return name
def _create_template(self, name):
return Template(self.dict[name], name=name, loader=self)
class _Node(object):
def each_child(self):
return ()
def generate(self, writer):
raise NotImplementedError()
def find_named_blocks(self, loader, named_blocks):
for child in self.each_child():
child.find_named_blocks(loader, named_blocks)
class _File(_Node):
def __init__(self, template, body):
self.template = template
self.body = body
self.line = 0
def generate(self, writer):
writer.write_line("def _execute():", self.line)
with writer.indent():
writer.write_line("_buffer = []", self.line)
writer.write_line("_append = _buffer.append", self.line)
self.body.generate(writer)
writer.write_line("return _utf8('').join(_buffer)", self.line)
def each_child(self):
return (self.body,)
class _ChunkList(_Node):
def __init__(self, chunks):
self.chunks = chunks
def generate(self, writer):
for chunk in self.chunks:
chunk.generate(writer)
def each_child(self):
return self.chunks
class _NamedBlock(_Node):
def __init__(self, name, body, template, line):
self.name = name
self.body = body
self.template = template
self.line = line
def each_child(self):
return (self.body,)
def generate(self, writer):
block = writer.named_blocks[self.name]
with writer.include(block.template, self.line):
block.body.generate(writer)
def find_named_blocks(self, loader, named_blocks):
named_blocks[self.name] = self
_Node.find_named_blocks(self, loader, named_blocks)
class _ExtendsBlock(_Node):
def __init__(self, name):
self.name = name
class _IncludeBlock(_Node):
def __init__(self, name, reader, line):
self.name = name
self.template_name = reader.name
self.line = line
def find_named_blocks(self, loader, named_blocks):
included = loader.load(self.name, self.template_name)
included.file.find_named_blocks(loader, named_blocks)
def generate(self, writer):
included = writer.loader.load(self.name, self.template_name)
with writer.include(included, self.line):
included.file.body.generate(writer)
class _ApplyBlock(_Node):
def __init__(self, method, line, body=None):
self.method = method
self.line = line
self.body = body
def each_child(self):
return (self.body,)
def generate(self, writer):
method_name = "apply%d" % writer.apply_counter
writer.apply_counter += 1
writer.write_line("def %s():" % method_name, self.line)
with writer.indent():
writer.write_line("_buffer = []", self.line)
writer.write_line("_append = _buffer.append", self.line)
self.body.generate(writer)
writer.write_line("return _utf8('').join(_buffer)", self.line)
writer.write_line("_append(_utf8(%s(%s())))" % (
self.method, method_name), self.line)
class _ControlBlock(_Node):
def __init__(self, statement, line, body=None):
self.statement = statement
self.line = line
self.body = body
def each_child(self):
return (self.body,)
def generate(self, writer):
writer.write_line("%s:" % self.statement, self.line)
with writer.indent():
self.body.generate(writer)
# Just in case the body was empty
writer.write_line("pass", self.line)
class _IntermediateControlBlock(_Node):
def __init__(self, statement, line):
self.statement = statement
self.line = line
def generate(self, writer):
# In case the previous block was empty
writer.write_line("pass", self.line)
writer.write_line("%s:" % self.statement, self.line,
writer.indent_size() - 1)
class _Statement(_Node):
def __init__(self, statement, line):
self.statement = statement
self.line = line
def generate(self, writer):
writer.write_line(self.statement, self.line)
class _Expression(_Node):
def __init__(self, expression, line, raw=False):
self.expression = expression
self.line = line
self.raw = raw
def generate(self, writer):
writer.write_line("_tmp = %s" % self.expression, self.line)
writer.write_line("if isinstance(_tmp, _string_types):"
" _tmp = _utf8(_tmp)", self.line)
writer.write_line("else: _tmp = _utf8(str(_tmp))", self.line)
if not self.raw and writer.current_template.autoescape is not None:
# In python3 functions like xhtml_escape return unicode,
# so we have to convert to utf8 again.
writer.write_line("_tmp = _utf8(%s(_tmp))" %
writer.current_template.autoescape, self.line)
writer.write_line("_append(_tmp)", self.line)
class _Module(_Expression):
def __init__(self, expression, line):
super(_Module, self).__init__("_modules." + expression, line,
raw=True)
class _Text(_Node):
def __init__(self, value, line):
self.value = value
self.line = line
def generate(self, writer):
value = self.value
# Compress lots of white space to a single character. If the whitespace
# breaks a line, have it continue to break a line, but just with a
# single \n character
if writer.compress_whitespace and "
" not in value:
value = re.sub(r"([\t ]+)", " ", value)
value = re.sub(r"(\s*\n\s*)", "\n", value)
if value:
writer.write_line('_append(%r)' % escape.utf8(value), self.line)
class ParseError(Exception):
"""Raised for template syntax errors."""
pass
class TemplateError(Exception):
pass
class _CodeWriter(object):
def __init__(self, file, named_blocks, loader, current_template,
compress_whitespace):
self.file = file
self.named_blocks = named_blocks
self.loader = loader
self.current_template = current_template
self.compress_whitespace = compress_whitespace
self.apply_counter = 0
self.include_stack = []
self._indent = 0
def indent_size(self):
return self._indent
def indent(self):
class Indenter(object):
def __enter__(_):
self._indent += 1
return self
def __exit__(_, *args):
assert self._indent > 0
self._indent -= 1
return Indenter()
def include(self, template, line):
self.include_stack.append((self.current_template, line))
self.current_template = template
class IncludeTemplate(object):
def __enter__(_):
return self
def __exit__(_, *args):
self.current_template = self.include_stack.pop()[0]
return IncludeTemplate()
def write_line(self, line, line_number, indent=None):
if indent is None:
indent = self._indent
line_comment = ' # %s:%d' % (self.current_template.name, line_number)
if self.include_stack:
ancestors = ["%s:%d" % (tmpl.name, lineno)
for (tmpl, lineno) in self.include_stack]
line_comment += ' (via %s)' % ', '.join(reversed(ancestors))
self.file.write(" " * indent + line + line_comment + "\n")
class _TemplateReader(object):
def __init__(self, name, text):
self.name = name
self.text = text
self.line = 1
self.pos = 0
def find(self, needle, start=0, end=None):
assert start >= 0, start
pos = self.pos
start += pos
if end is None:
index = self.text.find(needle, start)
else:
end += pos
assert end >= start
index = self.text.find(needle, start, end)
if index != -1:
index -= pos
return index
def consume(self, count=None):
if count is None:
count = len(self.text) - self.pos
newpos = self.pos + count
self.line += self.text.count("\n", self.pos, newpos)
s = self.text[self.pos:newpos]
self.pos = newpos
return s
def remaining(self):
return len(self.text) - self.pos
def __len__(self):
return self.remaining()
def __getitem__(self, key):
if type(key) is slice:
size = len(self)
start, stop, step = key.indices(size)
if start is None:
start = self.pos
else:
start += self.pos
if stop is not None:
stop += self.pos
return self.text[slice(start, stop, step)]
elif key < 0:
return self.text[key]
else:
return self.text[self.pos + key]
def __str__(self):
return self.text[self.pos:]
def _format_code(code):
lines = code if isinstance(code, types.ListType) else code.splitlines()
format = "%%%dd %%s\n" % len(repr(len(lines) + 1))
return "".join([format % (i + 1, line) for (i, line) in enumerate(lines)])
def _parse(reader, template, in_block=None, in_loop=None):
body = _ChunkList([])
while True:
# Find next template directive
curly = 0
while True:
curly = reader.find("{", curly)
if curly == -1 or curly + 1 == reader.remaining():
# EOF
if in_block:
raise ParseError("Missing {%% end %%} block for %s" %
in_block)
body.chunks.append(_Text(reader.consume(), reader.line))
return body
# If the first curly brace is not the start of a special token,
# start searching from the character after it
if reader[curly + 1] not in ("{", "%", "#"):
curly += 1
continue
# When there are more than 2 curlies in a row, use the
# innermost ones. This is useful when generating languages
# like latex where curlies are also meaningful
if (curly + 2 < reader.remaining() and
reader[curly + 1] == '{' and reader[curly + 2] == '{'):
curly += 1
continue
break
# Append any text before the special token
if curly > 0:
cons = reader.consume(curly)
body.chunks.append(_Text(cons, reader.line))
start_brace = reader.consume(2)
line = reader.line
# Template directives may be escaped as "{{!" or "{%!".
# In this case output the braces and consume the "!".
# This is especially useful in conjunction with jquery templates,
# which also use double braces.
if reader.remaining() and reader[0] == "!":
reader.consume(1)
body.chunks.append(_Text(start_brace, line))
continue
# Comment
if start_brace == "{#":
end = reader.find("#}")
if end == -1:
raise ParseError("Missing end expression #} on line %d" % line)
contents = reader.consume(end).strip()
reader.consume(2)
continue
# Expression
if start_brace == "{{":
end = reader.find("}}")
if end == -1:
raise ParseError("Missing end expression }} on line %d" % line)
contents = reader.consume(end).strip()
reader.consume(2)
if not contents:
raise ParseError("Empty expression on line %d" % line)
body.chunks.append(_Expression(contents, line))
continue
# Block
assert start_brace == "{%", start_brace
end = reader.find("%}")
if end == -1:
raise ParseError("Missing end block %%} on line %d" % line)
contents = reader.consume(end).strip()
reader.consume(2)
if not contents:
raise ParseError("Empty block tag ({%% %%}) on line %d" % line)
operator, space, suffix = contents.partition(" ")
suffix = suffix.strip()
# Intermediate ("else", "elif", etc) blocks
intermediate_blocks = {
"else": set(["if", "for", "while", "try"]),
"elif": set(["if"]),
"except": set(["try"]),
"finally": set(["try"]),
}
allowed_parents = intermediate_blocks.get(operator)
if allowed_parents is not None:
if not in_block:
raise ParseError("%s outside %s block" %
(operator, allowed_parents))
if in_block not in allowed_parents:
raise ParseError("%s block cannot be attached to %s block" %
(operator, in_block))
body.chunks.append(_IntermediateControlBlock(contents, line))
continue
# End tag
elif operator == "end":
if not in_block:
raise ParseError("Extra {%% end %%} block on line %d" % line)
return body
elif operator in ("extends", "include", "set", "import", "from",
"comment", "autoescape", "raw", "module"):
if operator == "comment":
continue
if operator == "extends":
suffix = suffix.strip('"').strip("'")
if not suffix:
raise ParseError("extends missing file path on line %d" %
line)
block = _ExtendsBlock(suffix)
elif operator in ("import", "from"):
if not suffix:
raise ParseError("import missing statement on line %d" %
line)
block = _Statement(contents, line)
elif operator == "include":
suffix = suffix.strip('"').strip("'")
if not suffix:
raise ParseError("include missing file path on line %d" %
line)
block = _IncludeBlock(suffix, reader, line)
elif operator == "set":
if not suffix:
raise ParseError("set missing statement on line %d" % line)
block = _Statement(suffix, line)
elif operator == "autoescape":
fn = suffix.strip()
if fn == "None":
fn = None
template.autoescape = fn
continue
elif operator == "raw":
block = _Expression(suffix, line, raw=True)
elif operator == "module":
block = _Module(suffix, line)
body.chunks.append(block)
continue
elif operator in ("apply", "block", "try", "if", "for", "while"):
# parse inner body recursively
if operator in ("for", "while"):
block_body = _parse(reader, template, operator, operator)
elif operator == "apply":
# apply creates a nested function so syntactically it's not
# in the loop.
block_body = _parse(reader, template, operator, None)
else:
block_body = _parse(reader, template, operator, in_loop)
if operator == "apply":
if not suffix:
raise ParseError("apply missing method name on line %d" %
line)
block = _ApplyBlock(suffix, line, block_body)
elif operator == "block":
if not suffix:
raise ParseError("block missing name on line %d" % line)
block = _NamedBlock(suffix, block_body, template, line)
else:
block = _ControlBlock(contents, line, block_body)
body.chunks.append(block)
continue
elif operator in ("break", "continue"):
if not in_loop:
raise ParseError("%s outside %s block" % (operator,
set(["for", "while"])))
body.chunks.append(_Statement(contents, line))
continue
else:
raise ParseError("unknown operator: %r" % operator)
python-cyclone-1.1/cyclone/util.py 0000644 0001750 0001750 00000005255 12124336260 016343 0 ustar lunar lunar # coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from twisted.python import log
def _emit(self, eventDict):
text = log.textFromEventDict(eventDict)
if not text:
return
#print "hello? '%s'" % repr(text)
timeStr = self.formatTime(eventDict['time'])
#fmtDict = {'system': eventDict['system'],
# 'text': text.replace("\n", "\n\t")}
#msgStr = log._safeFormat("[%(system)s] %(text)s\n", fmtDict)
log.util.untilConcludes(self.write, "%s %s\n" % (timeStr,
text.replace("\n", "\n\t")))
log.util.untilConcludes(self.flush) # Hoorj!
# monkey patch, sorry
log.FileLogObserver.emit = _emit
class ObjectDict(dict):
"""Makes a dictionary behave like an object."""
def __getattr__(self, name):
try:
return self[name]
except KeyError:
raise AttributeError(name)
def __setattr__(self, name, value):
self[name] = value
def import_object(name):
"""Imports an object by name.
import_object('x.y.z') is equivalent to 'from x.y import z'.
>>> import cyclone.escape
>>> import_object('cyclone.escape') is cyclone.escape
True
>>> import_object('cyclone.escape.utf8') is cyclone.escape.utf8
True
"""
parts = name.split('.')
obj = __import__('.'.join(parts[:-1]), None, None, [parts[-1]], 0)
method = getattr(obj, parts[-1], None)
if method:
return method
else:
raise ImportError("No method named %s" % parts[-1])
# Fake byte literal support: In python 2.6+, you can say b"foo" to get
# a byte literal (str in 2.x, bytes in 3.x). There's no way to do this
# in a way that supports 2.5, though, so we need a function wrapper
# to convert our string literals. b() should only be applied to literal
# latin1 strings. Once we drop support for 2.5, we can remove this function
# and just use byte literals.
#def b(s):
# return s
#
#def u(s):
# return s.decode('unicode_escape')
bytes_type = str
unicode_type = unicode
basestring_type = basestring
def doctests():
import doctest
return doctest.DocTestSuite()
python-cyclone-1.1/cyclone/httpserver.py 0000644 0001750 0001750 00000033170 12124336260 017571 0 ustar lunar lunar # coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""A non-blocking, single-threaded HTTP server.
Typical applications have little direct interaction with the `HTTPConnection`
class, which is the HTTP parser executed on incoming connections.
It is a protocol class that inherits Twisted's `LineReceiver
`_, and is usually created by
`cyclone.web.Application`, our connection factory.
This module also defines the `HTTPRequest` class which is exposed via
`cyclone.web.RequestHandler.request`.
"""
from __future__ import absolute_import, division, with_statement
import Cookie
import socket
import time
from io import BytesIO as StringIO
from tempfile import TemporaryFile
from twisted.python import log
from twisted.protocols import basic
from twisted.internet import address
from twisted.internet import defer
from twisted.internet import interfaces
from cyclone.escape import utf8, native_str, parse_qs_bytes
from cyclone import httputil
from cyclone.util import bytes_type
class _BadRequestException(Exception):
"""Exception class for malformed HTTP requests."""
pass
class HTTPConnection(basic.LineReceiver):
"""Handles a connection to an HTTP client, executing HTTP requests.
We parse HTTP headers and bodies, and execute the request callback
until the HTTP conection is closed.
If ``xheaders`` is ``True``, we support the ``X-Real-Ip`` and ``X-Scheme``
headers, which override the remote IP and HTTP scheme for all requests.
These headers are useful when running Tornado behind a reverse proxy or
load balancer.
"""
delimiter = "\r\n"
def connectionMade(self):
self._headersbuffer = []
self._contentbuffer = None
self._finish_callback = None
self.no_keep_alive = False
self.content_length = None
self.request_callback = self.factory
self.xheaders = self.factory.settings.get('xheaders', False)
self._request = None
self._request_finished = False
def connectionLost(self, reason):
if self._finish_callback:
self._finish_callback.callback(reason.getErrorMessage())
self._finish_callback = None
def notifyFinish(self):
if self._finish_callback is None:
self._finish_callback = defer.Deferred()
return self._finish_callback
def lineReceived(self, line):
if line:
self._headersbuffer.append(line + self.delimiter)
else:
buff = "".join(self._headersbuffer)
self._headersbuffer = []
self._on_headers(buff)
def rawDataReceived(self, data):
if self.content_length is not None:
data, rest = data[:self.content_length], data[self.content_length:]
self.content_length -= len(data)
else:
rest = ''
self._contentbuffer.write(data)
if self.content_length == 0:
self._contentbuffer.seek(0, 0)
self._on_request_body(self._contentbuffer.read())
self.content_length = self._contentbuffer = None
self.setLineMode(rest)
def write(self, chunk):
assert self._request, "Request closed"
self.transport.write(chunk)
def finish(self):
assert self._request, "Request closed"
self._request_finished = True
self._finish_request()
def _on_write_complete(self):
if self._request_finished:
self._finish_request()
def _finish_request(self):
if self.no_keep_alive:
disconnect = True
else:
connection_header = self._request.headers.get("Connection")
if self._request.supports_http_1_1():
disconnect = connection_header == "close"
elif ("Content-Length" in self._request.headers
or self._request.method in ("HEAD", "GET")):
disconnect = connection_header != "Keep-Alive"
else:
disconnect = True
if self._finish_callback:
self._finish_callback.callback(None)
self._finish_callback = None
self._request = None
self._request_finished = False
if disconnect is True:
self.transport.loseConnection()
def _on_headers(self, data):
try:
data = native_str(data.decode("latin1"))
eol = data.find("\r\n")
start_line = data[:eol]
try:
method, uri, version = start_line.split(" ")
except ValueError:
raise _BadRequestException("Malformed HTTP request line")
if not version.startswith("HTTP/"):
raise _BadRequestException(
"Malformed HTTP version in HTTP Request-Line")
headers = httputil.HTTPHeaders.parse(data[eol:])
self._request = HTTPRequest(
connection=self, method=method, uri=uri, version=version,
headers=headers, remote_ip=self._remote_ip)
content_length = int(headers.get("Content-Length", 0))
if content_length:
if headers.get("Expect") == "100-continue":
self.transport.write("HTTP/1.1 100 (Continue)\r\n\r\n")
if content_length < 100000:
self._contentbuffer = StringIO()
else:
self._contentbuffer = TemporaryFile()
self.content_length = content_length
self.setRawMode()
return
self.request_callback(self._request)
except _BadRequestException, e:
log.msg("Malformed HTTP request from %s: %s", self._remote_ip, e)
self.transport.loseConnection()
def _on_request_body(self, data):
self._request.body = data
content_type = self._request.headers.get("Content-Type", "")
if self._request.method in ("POST", "PATCH", "PUT"):
if content_type.startswith("application/x-www-form-urlencoded"):
arguments = parse_qs_bytes(native_str(self._request.body))
for name, values in arguments.iteritems():
values = [v for v in values if v]
if values:
self._request.arguments.setdefault(name,
[]).extend(values)
elif content_type.startswith("multipart/form-data"):
fields = content_type.split(";")
for field in fields:
k, sep, v, = field.strip().partition("=")
if k == "boundary" and v:
httputil.parse_multipart_form_data(
utf8(v), data,
self._request.arguments,
self._request.files)
break
else:
log.msg("Invalid multipart/form-data")
self.request_callback(self._request)
@property
def _remote_ip(self):
peer = self.transport.getPeer()
if isinstance(peer, address.UNIXAddress):
remote_ip = "unix:%s" % self.transport.getHost().name
else:
remote_ip = self.transport.getPeer().host
return remote_ip
class HTTPRequest(object):
"""A single HTTP request.
All attributes are type `str` unless otherwise noted.
.. attribute:: method
HTTP request method, e.g. "GET" or "POST"
.. attribute:: uri
The requested uri.
.. attribute:: path
The path portion of `uri`
.. attribute:: query
The query portion of `uri`
.. attribute:: version
HTTP version specified in request, e.g. "HTTP/1.1"
.. attribute:: headers
`HTTPHeader` dictionary-like object for request headers. Acts like
a case-insensitive dictionary with additional methods for repeated
headers.
.. attribute:: body
Request body, if present, as a byte string.
.. attribute:: remote_ip
Client's IP address as a string. If `HTTPConnection.xheaders` is set,
will pass along the real IP address provided by a load balancer
in the ``X-Real-Ip`` header
.. attribute:: protocol
The protocol used, either "http" or "https".
If `HTTPConnection.xheaders` is set, will pass along the protocol used
by a load balancer if
reported via an ``X-Scheme`` header.
.. attribute:: host
The requested hostname, usually taken from the ``Host`` header.
.. attribute:: arguments
GET/POST arguments are available in the arguments property, which
maps arguments names to lists of values (to support multiple values
for individual names). Names are of type `str`, while arguments
are byte strings. Note that this is different from
`RequestHandler.get_argument`, which returns argument values as
unicode strings.
.. attribute:: files
File uploads are available in the files property, which maps file
names to lists of :class:`HTTPFile`.
.. attribute:: connection
An HTTP request is attached to a single HTTP connection, which can
be accessed through the "connection" attribute. Since connections
are typically kept open in HTTP/1.1, multiple requests can be handled
sequentially on a single connection.
"""
def __init__(self, method, uri, version="HTTP/1.0", headers=None,
body=None, remote_ip=None, protocol=None, host=None,
files=None, connection=None):
self.method = method
self.uri = uri
self.version = version
self.headers = headers or httputil.HTTPHeaders()
self.body = body or ""
if connection and connection.xheaders:
# Squid uses X-Forwarded-For, others use X-Real-Ip
self.remote_ip = self.headers.get(
"X-Real-Ip", self.headers.get("X-Forwarded-For", remote_ip))
if not self._valid_ip(self.remote_ip):
self.remote_ip = remote_ip
# AWS uses X-Forwarded-Proto
self.protocol = self.headers.get("X-Scheme",
self.headers.get("X-Forwarded-Proto", protocol))
if self.protocol not in ("http", "https"):
self.protocol = "http"
else:
self.remote_ip = remote_ip
if connection and interfaces.ISSLTransport.providedBy(
connection.transport):
self.protocol = "https"
else:
self.protocol = "http"
self.host = host or self.headers.get("Host") or "127.0.0.1"
self.files = files or {}
self.connection = connection
self._start_time = time.time()
self._finish_time = None
self.path, sep, self.query = uri.partition("?")
self.arguments = parse_qs_bytes(self.query, keep_blank_values=True)
def supports_http_1_1(self):
"""Returns True if this request supports HTTP/1.1 semantics"""
return self.version == "HTTP/1.1"
@property
def cookies(self):
"""A dictionary of Cookie.Morsel objects."""
if not hasattr(self, "_cookies"):
self._cookies = Cookie.SimpleCookie()
if "Cookie" in self.headers:
try:
self._cookies.load(
native_str(self.headers["Cookie"]))
except Exception:
self._cookies = {}
return self._cookies
def write(self, chunk):
"""Writes the given chunk to the response stream."""
assert isinstance(chunk, bytes_type)
self.connection.write(chunk)
def finish(self):
"""Finishes this HTTP request on the open connection."""
self.connection.finish()
self._finish_time = time.time()
def full_url(self):
"""Reconstructs the full URL for this request."""
return self.protocol + "://" + self.host + self.uri
def request_time(self):
"""Returns the amount of time it took for this request to execute."""
if self._finish_time is None:
return time.time() - self._start_time
else:
return self._finish_time - self._start_time
def notifyFinish(self):
"""Returns a Deferred object, which is fired when the request is
finished and the connection is closed.
"""
return self.connection.notifyFinish()
def __repr__(self):
attrs = ("protocol", "host", "method", "uri", "version", "remote_ip",
"body")
args = ", ".join(["%s=%r" % (n, getattr(self, n)) for n in attrs])
return "%s(%s, headers=%s)" % (
self.__class__.__name__, args, dict(self.headers))
def _valid_ip(self, ip):
try:
res = socket.getaddrinfo(ip, 0, socket.AF_UNSPEC,
socket.SOCK_STREAM,
0, socket.AI_NUMERICHOST)
return bool(res)
except socket.gaierror, e:
if e.args[0] == socket.EAI_NONAME:
return False
raise
return True
python-cyclone-1.1/cyclone/web.py 0000644 0001750 0001750 00000250040 12124336260 016135 0 ustar lunar lunar # coding: utf-8
#
# Copyright 2010 Alexandre Fiori
# based on the original Tornado by Facebook
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""
The cyclone web framework looks a bit like web.py (http://webpy.org/) or
Google's webapp (http://code.google.com/appengine/docs/python/tools/webapp/),
but with additional tools and optimizations to take advantage of the
non-blocking web server and tools.
Here is the canonical "Hello, world" example app::
import cyclone.web
from twisted.internet import reactor
class MainHandler(tornado.web.RequestHandler):
def get(self):
self.write("Hello, world")
if __name__ == "__main__":
application = tornado.web.Application([
(r"/", MainHandler),
])
reactor.listenTCP(8888, application)
reactor.run()
See the cyclone walkthrough on http://cyclone.io for more details and a good
getting started guide.
Thread-safety notes
-------------------
In general, methods on RequestHandler and elsewhere in cyclone are not
thread-safe. In particular, methods such as write(), finish(), and
flush() must only be called from the main thread. For more information on
using threads, please check the twisted documentation:
http://twistedmatrix.com/documents/current/core/howto/threading.html
"""
from __future__ import absolute_import, division, with_statement
import Cookie
import base64
import binascii
import calendar
import datetime
import email.utils
import functools
import gzip
import hashlib
import hmac
import httplib
import itertools
import mimetypes
import numbers
import os.path
import re
import stat
import sys
import threading
import time
import traceback
import types
import urllib
import urlparse
import uuid
import cyclone
from cyclone import escape
from cyclone import httpserver
from cyclone import locale
from cyclone import template
from cyclone.escape import utf8, _unicode
from cyclone.util import ObjectDict
from cyclone.util import bytes_type
from cyclone.util import import_object
from cyclone.util import unicode_type
from cStringIO import StringIO as BytesIO # python 2
from twisted.python import failure
from twisted.python import log
from twisted.internet import defer
from twisted.internet import protocol
from twisted.internet import reactor
class RequestHandler(object):
"""Subclass this class and define get() or post() to make a handler.
If you want to support more methods than the standard GET/HEAD/POST, you
should override the class variable SUPPORTED_METHODS in your
RequestHandler class.
If you want lists to be serialized when calling self.write() set
serialize_lists to True.
This may have some security implications if you are not protecting against
XSRF with other means (such as a XSRF token).
More details on this vulnerability here:
http://haacked.com/archive/2008/11/20/anatomy-of-a-subtle-json-vulnerability.aspx
"""
SUPPORTED_METHODS = ("GET", "HEAD", "POST", "DELETE", "PATCH", "PUT",
"OPTIONS")
serialize_lists = False
no_keep_alive = False
xsrf_cookie_name = "_xsrf"
_template_loaders = {} # {path: template.BaseLoader}
_template_loader_lock = threading.Lock()
def __init__(self, application, request, **kwargs):
super(RequestHandler, self).__init__()
self.application = application
self.request = request
self._headers_written = False
self._finished = False
self._auto_finish = True
self._transforms = None # will be set in _execute
self.path_args = None
self.path_kwargs = None
self.ui = ObjectDict((n, self._ui_method(m)) for n, m in
application.ui_methods.items())
# UIModules are available as both `modules` and `_modules` in the
# template namespace. Historically only `modules` was available
# but could be clobbered by user additions to the namespace.
# The template {% module %} directive looks in `_modules` to avoid
# possible conflicts.
self.ui["_modules"] = ObjectDict((n, self._ui_module(n, m)) for n, m in
application.ui_modules.items())
self.ui["modules"] = self.ui["_modules"]
self.clear()
self.request.connection.no_keep_alive = self.no_keep_alive
self.initialize(**kwargs)
def initialize(self):
"""Hook for subclass initialization.
A dictionary passed as the third argument of a url spec will be
supplied as keyword arguments to initialize().
Example::
class ProfileHandler(RequestHandler):
def initialize(self, database):
self.database = database
def get(self, username):
...
app = Application([
(r'/user/(.*)', ProfileHandler, dict(database=database)),
])
"""
pass
@property
def settings(self):
"""An alias for `self.application.settings`."""
return self.application.settings
def head(self, *args, **kwargs):
raise HTTPError(405)
def get(self, *args, **kwargs):
raise HTTPError(405)
def post(self, *args, **kwargs):
raise HTTPError(405)
def delete(self, *args, **kwargs):
raise HTTPError(405)
def patch(self, *args, **kwargs):
raise HTTPError(405)
def put(self, *args, **kwargs):
raise HTTPError(405)
def options(self, *args, **kwargs):
raise HTTPError(405)
def prepare(self):
"""Called at the beginning of a request before `get`/`post`/etc.
Override this method to perform common initialization regardless
of the request method.
"""
pass
def on_finish(self):
"""Called after the end of a request.
Override this method to perform cleanup, logging, etc.
This method is a counterpart to `prepare`. ``on_finish`` may
not produce any output, as it is called after the response
has been sent to the client.
"""
pass
def on_connection_close(self, *args, **kwargs):
"""Called in async handlers if the client closed the connection.
Override this to clean up resources associated with
long-lived connections. Note that this method is called only if
the connection was closed during asynchronous processing; if you
need to do cleanup after every request override `on_finish`
instead.
Proxies may keep a connection open for a time (perhaps
indefinitely) after the client has gone away, so this method
may not be called promptly after the end user closes their
connection.
"""
pass
def clear(self):
"""Resets all headers and content for this response."""
# The performance cost of cyclone.httputil.HTTPHeaders is significant
# (slowing down a benchmark with a trivial handler by more than 10%),
# and its case-normalization is not generally necessary for
# headers we generate on the server side, so use a plain dict
# and list instead.
self._headers = {
"Server": "cyclone/%s" % cyclone.version,
"Content-Type": "text/html; charset=UTF-8",
"Date": datetime.datetime.utcnow().strftime(
"%a, %d %b %Y %H:%M:%S GMT"),
}
self._list_headers = []
self.set_default_headers()
if not self.request.supports_http_1_1():
if self.request.headers.get("Connection") == "Keep-Alive":
self.set_header("Connection", "Keep-Alive")
self._write_buffer = []
self._status_code = 200
self._reason = httplib.responses[200]
def set_default_headers(self):
"""Override this to set HTTP headers at the beginning of the request.
For example, this is the place to set a custom ``Server`` header.
Note that setting such headers in the normal flow of request
processing may not do what you want, since headers may be reset
during error handling.
"""
pass
def set_status(self, status_code, reason=None):
"""Sets the status code for our response.
:arg int status_code: Response status code. If `reason` is ``None``,
it must be present in `httplib.responses`.
:arg string reason: Human-readable reason phrase describing the status
code. If ``None``, it will be filled in from `httplib.responses`.
"""
self._status_code = status_code
if reason is not None:
self._reason = escape.native_str(reason)
else:
try:
self._reason = httplib.responses[status_code]
except KeyError:
raise ValueError("unknown status code %d", status_code)
def get_status(self):
"""Returns the status code for our response."""
return self._status_code
def set_header(self, name, value):
"""Sets the given response header name and value.
If a datetime is given, we automatically format it according to the
HTTP specification. If the value is not a string, we convert it to
a string. All header values are then encoded as UTF-8.
"""
self._headers[name] = self._convert_header_value(value)
def add_header(self, name, value):
"""Adds the given response header and value.
Unlike `set_header`, `add_header` may be called multiple times
to return multiple values for the same header.
"""
self._list_headers.append((name, self._convert_header_value(value)))
def clear_header(self, name):
"""Clears an outgoing header, undoing a previous `set_header` call.
Note that this method does not apply to multi-valued headers
set by `add_header`.
"""
if name in self._headers:
del self._headers[name]
def _convert_header_value(self, value):
if isinstance(value, bytes_type):
pass
elif isinstance(value, unicode_type):
value = value.encode("utf-8")
elif isinstance(value, numbers.Integral):
# return immediately since we know the converted value will be safe
return str(value)
elif isinstance(value, datetime.datetime):
t = calendar.timegm(value.utctimetuple())
return email.utils.formatdate(t, localtime=False, usegmt=True)
else:
raise TypeError("Unsupported header value %r" % value)
# If \n is allowed into the header, it is possible to inject
# additional headers or split the request. Also cap length to
# prevent obviously erroneous values.
if len(value) > 4000 or re.search(r"[\x00-\x1f]", value):
raise ValueError("Unsafe header value %r", value)
return value
_ARG_DEFAULT = []
def get_argument(self, name, default=_ARG_DEFAULT, strip=True):
"""Returns the value of the argument with the given name.
If default is not provided, the argument is considered to be
required, and we throw an HTTP 400 exception if it is missing.
If the argument appears in the url more than once, we return the
last value.
The returned value is always unicode.
"""
args = self.get_arguments(name, strip=strip)
if not args:
if default is self._ARG_DEFAULT:
raise HTTPError(400, "Missing argument " + name)
return default
return args[-1]
def get_arguments(self, name, strip=True):
"""Returns a list of the arguments with the given name.
If the argument is not present, returns an empty list.
The returned values are always unicode.
"""
values = []
for v in self.request.arguments.get(name, []):
v = self.decode_argument(v, name=name)
if isinstance(v, unicode_type):
# Get rid of any weird control chars (unless decoding gave
# us bytes, in which case leave it alone)
v = re.sub(r"[\x00-\x08\x0e-\x1f]", " ", v)
if strip:
v = v.strip()
values.append(v)
return values
def decode_argument(self, value, name=None):
"""Decodes an argument from the request.
The argument has been percent-decoded and is now a byte string.
By default, this method decodes the argument as utf-8 and returns
a unicode string, but this may be overridden in subclasses.
This method is used as a filter for both get_argument() and for
values extracted from the url and passed to get()/post()/etc.
The name of the argument is provided if known, but may be None
(e.g. for unnamed groups in the url regex).
"""
return _unicode(value)
@property
def cookies(self):
return self.request.cookies
def get_cookie(self, name, default=None):
"""Gets the value of the cookie with the given name, else default."""
if self.request.cookies is not None and name in self.request.cookies:
return self.request.cookies[name].value
return default
def set_cookie(self, name, value, domain=None, expires=None, path="/",
expires_days=None, **kwargs):
"""Sets the given cookie name/value with the given options.
Additional keyword arguments are set on the Cookie.Morsel directly.
See http://docs.python.org/library/cookie.html#morsel-objects
for available attributes.
"""
# The cookie library only accepts type str, in both python 2 and 3
name = escape.native_str(name)
value = escape.native_str(value)
if re.search(r"[\x00-\x20]", name + value):
# Don't let us accidentally inject bad stuff
raise ValueError("Invalid cookie %r: %r" % (name, value))
if not hasattr(self, "_new_cookie"):
self._new_cookie = Cookie.SimpleCookie()
if name in self._new_cookie:
del self._new_cookie[name]
self._new_cookie[name] = value
morsel = self._new_cookie[name]
if domain:
morsel["domain"] = domain
if expires_days is not None and not expires:
expires = datetime.datetime.utcnow() + datetime.timedelta(
days=expires_days)
if expires:
timestamp = calendar.timegm(expires.utctimetuple())
morsel["expires"] = email.utils.formatdate(
timestamp, localtime=False, usegmt=True)
if path:
morsel["path"] = path
for k, v in kwargs.items():
if k == 'max_age':
k = 'max-age'
morsel[k] = v
def clear_cookie(self, name, path="/", domain=None):
"""Deletes the cookie with the given name."""
expires = datetime.datetime.utcnow() - datetime.timedelta(days=365)
self.set_cookie(name, value="", path=path, expires=expires,
domain=domain)
def clear_all_cookies(self):
"""Deletes all the cookies the user sent with this request."""
for name in self.request.cookies.iterkeys():
self.clear_cookie(name)
def set_secure_cookie(self, name, value, expires_days=30, **kwargs):
"""Signs and timestamps a cookie so it cannot be forged.
You must specify the ``cookie_secret`` setting in your Application
to use this method. It should be a long, random sequence of bytes
to be used as the HMAC secret for the signature.
To read a cookie set with this method, use `get_secure_cookie()`.
Note that the ``expires_days`` parameter sets the lifetime of the
cookie in the browser, but is independent of the ``max_age_days``
parameter to `get_secure_cookie`.
Secure cookies may contain arbitrary byte values, not just unicode
strings (unlike regular cookies)
"""
self.set_cookie(name, self.create_signed_value(name, value),
expires_days=expires_days, **kwargs)
def create_signed_value(self, name, value):
"""Signs and timestamps a string so it cannot be forged.
Normally used via set_secure_cookie, but provided as a separate
method for non-cookie uses. To decode a value not stored
as a cookie use the optional value argument to get_secure_cookie.
"""
self.require_setting("cookie_secret", "secure cookies")
return create_signed_value(self.application.settings["cookie_secret"],
name, value)
def get_secure_cookie(self, name, value=None, max_age_days=31):
"""Returns the given signed cookie if it validates, or None.
The decoded cookie value is returned as a byte string (unlike
`get_cookie`).
"""
self.require_setting("cookie_secret", "secure cookies")
if value is None:
value = self.get_cookie(name)
return decode_signed_value(self.application.settings["cookie_secret"],
name, value, max_age_days=max_age_days)
def redirect(self, url, permanent=False, status=None):
"""Sends a redirect to the given (optionally relative) URL.
If the ``status`` argument is specified, that value is used as the
HTTP status code; otherwise either 301 (permanent) or 302
(temporary) is chosen based on the ``permanent`` argument.
The default is 302 (temporary).
"""
if self._headers_written:
raise Exception("Cannot redirect after headers have been written")
if status is None:
status = 301 if permanent else 302
else:
assert isinstance(status, types.IntType) and 300 <= status <= 399
self.set_status(status)
# Remove whitespace
url = re.sub(r"[\x00-\x20]+", "", utf8(url))
self.set_header("Location", urlparse.urljoin(utf8(self.request.uri),
url))
self.finish()
def write(self, chunk):
"""Writes the given chunk to the output buffer.
To write the output to the network, use the flush() method below.
If the given chunk is a dictionary, we write it as JSON and set
the Content-Type of the response to be application/json.
(if you want to send JSON as a different Content-Type, call
set_header *after* calling write()).
Note that lists are not converted to JSON because of a potential
cross-site security vulnerability. All JSON output should be
wrapped in a dictionary. More details at
http://haacked.com/archive/2008/11/20/\
anatomy-of-a-subtle-json-vulnerability.aspx
"""
if self._finished:
raise RuntimeError("Cannot write() after finish(). May be caused "
"by using async operations without the "
"@asynchronous decorator.")
if isinstance(chunk, types.DictType) or \
(self.serialize_lists and isinstance(chunk, types.ListType)):
chunk = escape.json_encode(chunk)
self.set_header("Content-Type", "application/json")
chunk = utf8(chunk)
self._write_buffer.append(chunk)
def render(self, template_name, **kwargs):
"""Renders the template with the given arguments as the response."""
html = self.render_string(template_name, **kwargs)
# Insert the additional JS and CSS added by the modules on the page
js_embed = []
js_files = []
css_embed = []
css_files = []
html_heads = []
html_bodies = []
for module in getattr(self, "_active_modules", {}).values():
embed_part = module.embedded_javascript()
if embed_part:
js_embed.append(utf8(embed_part))
file_part = module.javascript_files()
if file_part:
if isinstance(file_part, (unicode_type, bytes_type)):
js_files.append(file_part)
else:
js_files.extend(file_part)
embed_part = module.embedded_css()
if embed_part:
css_embed.append(utf8(embed_part))
file_part = module.css_files()
if file_part:
if isinstance(file_part, (unicode_type, bytes_type)):
css_files.append(file_part)
else:
css_files.extend(file_part)
head_part = module.html_head()
if head_part:
html_heads.append(utf8(head_part))
body_part = module.html_body()
if body_part:
html_bodies.append(utf8(body_part))
def is_absolute(path):
return any(path.startswith(x) for x in ["/", "http:", "https:"])
if js_files:
# Maintain order of JavaScript files given by modules
paths = []
unique_paths = set()
for path in js_files:
if not is_absolute(path):
path = self.static_url(path)
if path not in unique_paths:
paths.append(path)
unique_paths.add(path)
js = ''.join(''
for p in paths)
sloc = html.rindex('
')
html = html[:sloc] + utf8(js) + '\n' + html[sloc:]
if js_embed:
js = '
{% end %}