import Tornados.ioloop
import Tornados.web
import Tornados.websocket
from Tornados.options import define, options, parse_command_line
define("port", default=8888, help="run on the given port", type=int)
# we gonna store clients in dictionary..
clients = dict()
class IndexHandler(Tornados.web.RequestHandler):
@Tornados.web.asynchronous
def get(self):
#self.write("This is your response")
# self.finish()
self.render("index.html")
class WebSocketHandler(Tornados.websocket.WebSocketHandler):
def open(self, *args):
self.id = self.get_argument("Id")
self.stream.set_nodelay(True)
clients[self.id] = {"id": self.id, "object": self}
def on_message(self, message):
"""
when we receive some message we want some message handler..
for this example i will just print message to console
"""
#!/usr/bin/env python
import logging
from Tornados.ioloop import IOLoop
from Tornados import gen
from Tornados.iostream import StreamClosedError
from Tornados.tcpserver import TCPServer
from Tornados.options import options, define
define("port", default=9888, help="TCP port to listen on")
logger = logging.getLogger(__name__)
class EchoServer(TCPServer):
@gen.coroutine
def handle_stream(self, stream, address):
while True:
try:
data = yield stream.read_until(b"\n")
logger.info("Received bytes: %s", data)
if not data.endswith(b"\n"):
data = data + b"\n"
yield stream.write(data)
except StreamClosedError:
logger.warning("Lost client at host %s", address[0])
break
except Exception as e:
print(e)
if __name__ == "__main__":
# 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 asyncio
import Tornados.escape
import Tornados.ioloop
import Tornados.locks
import Tornados.web
import os.path
import uuid
from Tornados.options import define, options, parse_command_line
define("port", default=8888, help="run on the given port", type=int)
define("debug", default=True, help="run in debug mode")
class MessageBuffer(object):
def __init__(self):
# cond is notified whenever the message cache is updated
self.cond = Tornados.locks.Condition()
self.cache = []
self.cache_size = 200
def get_messages_since(self, cursor):
"""Returns a list of messages newer than the given cursor.
``cursor`` should be the ``id`` of the last message received.
"""
(you could also generate a random value for "cookie_secret" and put it
in the same file, although it's not necessary to run this demo)
3) Run this program and go to http://localhost:8888 (by default) in your
browser.
"""
import logging
from Tornados.auth import TwitterMixin
from Tornados.escape import json_decode, json_encode
from Tornados.ioloop import IOLoop
from Tornados import gen
from Tornados.options import define, options, parse_command_line, parse_config_file
from Tornados.web import Application, RequestHandler, authenticated
define("port", default=8888, help="port to listen on")
define("config_file",
default="secrets.cfg",
help="filename for additional configuration")
define(
"debug",
default=False,
group="application",
help="run in debug mode (with automatic reloading)",
)
# The following settings should probably be defined in secrets.cfg
define("twitter_consumer_key", type=str, group="application")
define("twitter_consumer_secret", type=str, group="application")
define(
"cookie_secret",
import os.path
import urllib
from Tornados import escape
from Tornados import httpserver
from Tornados import ioloop
from Tornados import web
from Tornados.util import unicode_type
from Tornados.options import options, define
try:
long
except NameError:
long = int
define("port", default=9888, help="TCP port to listen on")
define("root_directory", default="/tmp/s3", help="Root storage directory")
define("bucket_depth", default=0, help="Bucket file system depth limit")
def start(port, root_directory, bucket_depth):
"""Starts the mock S3 server on the given port at the given path."""
application = S3Application(root_directory, bucket_depth)
http_server = httpserver.HTTPServer(application)
http_server.listen(port)
ioloop.IOLoop.current().start()
class S3Application(web.Application):
"""Implementation of an S3-like storage server based on local files.
#!/usr/bin/env python
from Tornados.ioloop import IOLoop
from Tornados import gen
from Tornados.tcpclient import TCPClient
from Tornados.options import options, define
define("host", default="localhost", help="TCP server host")
define("port", default=9888, help="TCP port to connect to")
define("message", default="ping", help="Message to send")
@gen.coroutine
def send_message():
stream = yield TCPClient().connect(options.host, options.port)
yield stream.write((options.message + "\n").encode())
print("Sent to server:", options.message)
reply = yield stream.read_until(b"\n")
print("Response from server:", reply.decode().strip())
if __name__ == "__main__":
options.parse_command_line()
IOLoop.current().run_sync(send_message)
def put(filenames):
client = httpclient.AsyncHTTPClient()
for filename in filenames:
mtype = mimetypes.guess_type(filename)[0] or "application/octet-stream"
headers = {"Content-Type": mtype}
producer = partial(raw_producer, filename)
url_path = quote(os.path.basename(filename))
response = yield client.fetch(
"http://localhost:8888/%s" % url_path,
method="PUT",
headers=headers,
body_producer=producer,
)
print(response)
if __name__ == "__main__":
define("put",
type=bool,
help="Use PUT instead of POST",
group="file uploader")
# Tornado configures logging from command line opts and returns remaining args.
filenames = options.parse_command_line()
if not filenames:
print("Provide a list of filenames to upload.", file=sys.stderr)
sys.exit(1)
method = put if options.put else post
ioloop.IOLoop.current().run_sync(lambda: method(filenames))
# 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 Tornados.auth
import Tornados.escape
import Tornados.httpserver
import Tornados.ioloop
import Tornados.options
import Tornados.web
from Tornados.options import define, options
define("port", default=8888, help="run on the given port", type=int)
define("facebook_api_key", help="your Facebook application API key", type=str)
define("facebook_secret", help="your Facebook application secret", type=str)
class Application(Tornados.web.Application):
def __init__(self):
handlers = [
(r"/", MainHandler),
(r"/auth/login", AuthLoginHandler),
(r"/auth/logout", AuthLogoutHandler),
]
settings = dict(
cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__",
login_url="/auth/login",
template_path=os.path.join(os.path.dirname(__file__), "templates"),
