def main(): """Construct and serve the tornado application.""" api_root = '/api/v1' app = Application( handlers=[ (r'/', HomeView), (r'/favicon.ico', HomeView), (r'/error_500', ErrorView), (api_root, InfoView), (api_root + r'/login', LoginView), (api_root + r'/accounts', RegistrationView), (api_root + r'/accounts/([\w]+)', ProfileView), (api_root + r'/accounts/([\w]+)/tasks', TaskListView), (api_root + r'/accounts/([\w]+)/tasks/([\d]+)', TaskView), (api_root + r'/accounts/([\w]+)/logout', LogoutView), ], db=SQLAlchemy( os.environ.get( 'DATABASE_URL', 'postgres://*****:*****@localhost:5432/task_manager')), cookie_secret="__TODO:_GENERATE_YOUR_OWN_RANDOM_VALUE_HERE__", **options.group_dict('application'), login_url="/api/v1/login", xsrf_cookies=True, debug=True, static_path=os.path.join(os.path.dirname(__file__), "static"), template_path=os.path.join(os.path.dirname(__file__), "templates")) http_server = HTTPServer(app) http_server.listen(options.port) print('Listening on http://localhost:%d' % options.port) logging.info('Listening on http://localhost:%d' % options.port) IOLoop.current().start()
def create_app(): """ :return: """ app = Application( [ *(main_blueprint.publish('/')), *(auth_blueprint.publish('/')), *(terminal_blueprint.publish('/')), *(queue_blueprint.publish('/queue')), *(device_blueprint.publish('/device')) ], login_url="/login", cookie_secret=os.environ.get( 'TORNADO_SECRET_KEY', open( os.path.join(os.path.dirname(os.path.realpath(__file__)), "../cookie.key"), 'r').read()), template_path="HardwareCheckout/templates/", static_path="HardwareCheckout/static/", db=SQLAlchemy(url=db_path), # xsrf_cookies=True, #TODO websocket_ping_interval=10000, websocket_ping_timeout=30000, ) return app # skip all below for testing without removing it
def route(): routes = [ (r"/people", PeopleGetHandler), (r"/people/add", PeoplePostHandler), (r"/people/update/(?P<id>\w+)", PeopleUpdHandler), (r"/people/delete/(?P<id>\w+)", PeopleDelHandler) ] return Application(routes, db=SQLAlchemy(db_url), debug=True)
def db_object(options=None, url: str = None, binds: Optional[dict] = {}): """Return tornado_sqlalchemy session interface object. Used for SA Model class and ThreadPoolExecutor interfaces. """ if url: url = url.strip() elif options: url = make_url(options) else: raise OptionsNotProvided( 'Provide either options object or a valid DB URL') return SQLAlchemy(url=url, binds=binds)
def __init__(self): handlers = [ (r"/", ShowUrl), (r"/urls", UrlsApp), (r"/registration", RegistrationApp), (r"/login", AuthorizationApp) ] settings = { "cookie_secret": COOKIE_SECRET, "db": SQLAlchemy(DATABASE_URL), "login_url": '/login' } Application.__init__(self, handlers, **settings)
class BaseDBTestCase(AsyncHTTPTestCase): def setUp(self): super(BaseDBTestCase, self).setUp() alembic_config = AlembicConfig('alembic.ini') alembic_config.set_main_option('sqlalchemy.url', 'sqlite:///testdb.sqlite') alembic_upgrade(alembic_config, 'head') def tearDown(self): os.remove('testdb.sqlite') def get_app(self): self.engine = SQLAlchemy('sqlite:///testdb.sqlite') self.session = self.engine.sessionmaker() return Application(routes, db=self.engine, debug=True)
def make_app(): logging.info("Server start http://%s:%i", config.app_host, config.app_port) logging.info("DOC start http://%s:%i/swagger/spec.html", config.app_host, config.app_port) settings = dict( cookie_secret=config.app_key, debug=True, description=config.app_title, ) # 라우트 설정 routes = swirl.api_routes() + [ (r"/(.*)", RedirectHandler, { 'url': '/api' }), ] return swirl.Application( routes, db=SQLAlchemy( f"{config.db_type}://{config.db_user}:{config.db_pass}@{config.db_host}/{config.db_name}" ), **settings)
from os import environ from tornado.options import define from tornado_sqlalchemy import SQLAlchemy define("port", default=environ.get("DEFAULT_PORT", 9090), help="port to listen on") SETTINGS = { "debug": environ.get("DEBUG", True), } DB = { "username": environ.get("DB_USER", "booksales"), "password": environ.get("DB_PWD", "booksales"), "host": environ.get("DB_HOST", "db"), "port": environ.get("DB_PORT", 5432), "name": environ.get("DB_NAME", "booksales"), } DB_URL = "postgresql://{user}:{pwd}@{host}:5432/{db_name}".format( user=DB["username"], pwd=DB["password"], host=DB["host"], db_name=DB["name"]) DATABASE = SQLAlchemy(url=DB_URL)
from sqlalchemy import Column, String, BigInteger, ForeignKey, DateTime, func from tornado_sqlalchemy import SQLAlchemy from settings import DATABASE_URL db = SQLAlchemy(url=DATABASE_URL) class User(db.Model): __tablename__ = 'user' id = Column(BigInteger, primary_key=True, autoincrement=True) username = Column(String(50), unique=True) password = Column(String(255)) def __init__(self, username, password): self.username = username self.password = password class Url(db.Model): __tablename__ = 'url' id = Column(BigInteger, primary_key=True, autoincrement=True) datetime = Column(DateTime(timezone=True), server_default=func.now()) full_address = Column(String(255)) abbreviated_address = Column(String(255), unique=True) access_level = Column(String(10), default='general') rating = Column(BigInteger, default=0) user_id = Column('user_id', BigInteger, ForeignKey('user.id')) def __init__(self, full_address, abbreviated_address, access_level, user_id):
def route(): route = [(r"/siswa", SiswaGetHandler), (r"/siswa/action/add", SiswaPostHandler), (r"/siswa/(?P<id>\w+)/action/update", SiswaUpdtHandler), (r"/siswa/(?P<id>\w+)/action/delete", SiswaDelHandler)] return Application(route, db=SQLAlchemy(db_url), debug=True)
def make_app(): urls = [(r"/api/item/([^/]+)?", TodoItem), (r"/api/items", TodoItems)] db_url = 'postgresql://*****:*****@localhost:5400/postgres' return Application(urls, db=SQLAlchemy(db_url), debug=True)
from tornado_sqlalchemy import SQLAlchemy, SessionMixin from sqlalchemy import Column, BigInteger, String, Integer # for use in defining our models import os # FOR MASTER BRANCH db_url = os.environ['DATABASE_URL'] # FOR DEVELOPMENT / testing # db_url = 'postgres://harry:@localhost/games' # db_url = 'postgres://postgres:@localhost/games' db = SQLAlchemy(url=db_url) class Snake_Highscore(db.Model): __tablename__ = "snake_highscores" id = Column(Integer, primary_key = True, autoincrement = True) username = Column(String(100), nullable = False) highscore = Column(Integer) class Firefly_Highscore(db.Model): __tablename__ = "firefly_highscores" id = Column(Integer, primary_key = True, autoincrement = True) username = Column(String(100), nullable = False) highscore = Column(Integer) class User_Auth(db.Model): __tablename__ = "user_auth" id = Column(Integer, primary_key = True, autoincrement = True) username = Column(String(100), unique = True, nullable = False)
from functools import partial from .config import db_path, ctfd_db_path from sqlalchemy import Column, Integer, String, ForeignKey, DateTime from sqlalchemy import or_ from sqlalchemy.orm import relationship from tornado_sqlalchemy import SQLAlchemy, as_future db = SQLAlchemy( url=db_path, engine_options={ "max_overflow": 15, "pool_pre_ping": True, "pool_recycle": 60 * 60, "pool_size": 30, }, ) if ctfd_db_path: ctfd_db = SQLAlchemy( url=ctfd_db_path, engine_options={ "max_overflow": 15, "pool_pre_ping": True, "pool_recycle": 60 * 60, "pool_size": 30, }, ) else: ctfd_db = False
from sqlalchemy import BigInteger, Column, String from tornado.gen import coroutine from tornado.ioloop import IOLoop from tornado.web import Application, RequestHandler from tornado_sqlalchemy import ( SessionMixin, as_future, set_max_workers, SQLAlchemy, ) db = SQLAlchemy() set_max_workers(10) class User(db.Model): __tablename__ = 'users' id = Column(BigInteger, primary_key=True) username = Column(String(255)) class Foo(db.Model): __bind_key__ = 'foo' __tablename__ = 'foo' id = Column(BigInteger, primary_key=True) foo = Column(String(255))
from sqlalchemy import BigInteger, Column, String from tornado_sqlalchemy import SQLAlchemy postgres_url = 'postgresql://*****:*****@127.0.0.1:5432/t_sa' mysql_url = 'mysql+mysqldb://t_sa:[email protected]:3306/t_sa' mysql_url_1 = 'mysql+mysqldb://t_sa:[email protected]:3306/t_sa_1' mysql_url_2 = 'mysql+mysqldb://t_sa:[email protected]:3306/t_sa_2' sqlite_url = 'sqlite:///t_sa.sqlite3' db = SQLAlchemy() class User(db.Model): __tablename__ = 'users' id = Column(BigInteger, primary_key=True) username = Column(String(64), unique=True) def __init__(self, username): self.username = username class BaseTestCase(TestCase): def setUp(self): self.db_url = mysql_url
def get_app(self): self.engine = SQLAlchemy('sqlite:///testdb.sqlite') self.session = self.engine.sessionmaker() return Application(routes, db=self.engine, debug=True)
from sqlalchemy import BigInteger, Column, String from tornado.gen import coroutine from tornado.ioloop import IOLoop from tornado.options import define, options, parse_command_line from tornado.web import Application, RequestHandler from tornado_sqlalchemy import SessionMixin, as_future, SQLAlchemy db = SQLAlchemy() define('database-url', type=str, help='Database URL') class User(db.Model): __tablename__ = 'users' id = Column(BigInteger, primary_key=True) username = Column(String(255), unique=True) class SynchronousRequestHandler(SessionMixin, RequestHandler): def get(self): with self.make_session() as session: count = session.query(User).count() # OR count = self.session.query(User).count() self.write('{} users so far!'.format(count)) class GenCoroutinesRequestHandler(SessionMixin, RequestHandler):
def set_url(self, url): self.url = url self._db = SQLAlchemy(self.url)
def instance(self): if not self._db: self._db = SQLAlchemy(self.url) return self._db
from sqlalchemy import BigInteger, Column, String from tornado.gen import coroutine from tornado.ioloop import IOLoop from tornado.web import Application, RequestHandler from tornado_sqlalchemy import SessionMixin, as_future, SQLAlchemy db = SQLAlchemy() class User(db.Model): __tablename__ = 'users' id = Column(BigInteger, primary_key=True) username = Column(String(255), unique=True) class SynchronousRequestHandler(SessionMixin, RequestHandler): def get(self): with self.make_session() as session: count = session.query(User).count() # OR count = self.session.query(User).count() self.write('{} users so far!'.format(count)) class GenCoroutinesRequestHandler(SessionMixin, RequestHandler): @coroutine def get(self): with self.make_session() as session:
from types import UnicodeType except ImportError: UnicodeType = str try: from json.decoder import JSONDecodeError except ImportError: JSONDecodeError = ValueError from tornado.concurrent import run_on_executor from tornado_sqlalchemy import SQLAlchemy from tornado_sqlalchemy import SessionMixin from model import SSHConnection, UploadProgress from tornadostreamform.multipart_streamer import MultiPartStreamer TMP_DIR = os.path.join(os.path.dirname(os.path.abspath(__file__)), "tmp_dir") db = SQLAlchemy("sqlite:///webssh.sqlite") MB = 1024 * 1024 GB = 1024 * MB MAX_STREAM_SIZE = 5 * GB class BaseHandler(tornado.web.RequestHandler): def get_current_user(self): return self.get_secure_cookie("username") class RegisterConnectionHandler(SessionMixin, BaseHandler): def get(self): self.render("connection_register.html", edit=False)
def db_settings(database_url: str = options.mysql_host) -> SQLAlchemy: return SQLAlchemy(url=database_url)
from sqlalchemy import Column, Integer, String, ForeignKey, DateTime from sqlalchemy import func, or_ from sqlalchemy.orm import relationship # from . import db from .config import db_path from tornado_sqlalchemy import SQLAlchemy, as_future from functools import partial db = SQLAlchemy(url=db_path) class User(db.Model): """ Suuuuper basic User model, this will almost certainly need to be updated. """ __tablename__ = "user" id = Column(Integer, primary_key=True) password = Column(String(93), unique=True) name = Column(String(1000)) #relationships roles = relationship('Role', secondary='user_roles') userQueueEntry = relationship("UserQueue") deviceQueueEntry = relationship("DeviceQueue", foreign_keys="DeviceQueue.owner") def get_owned_devices(self, session): return session.query(DeviceType.name, DeviceQueue.sshAddr, DeviceQueue.webUrl).filter( or_(DeviceQueue.state == 'in-queue', DeviceQueue.state == 'in-use'),
from sqlalchemy import ARRAY, Column, DateTime, Integer from tornado_sqlalchemy import SQLAlchemy db = SQLAlchemy(url='localhost') class TableItem(db.Model): __tablename__ = 'table' id = Column(Integer, primary_key=True) raw_array = Column(ARRAY(Integer)) sorted_array = Column(ARRAY(Integer)) created_at = Column(DateTime) class Meta: database = db