예제 #1
0
 def __init__(self, config_files=(".env", ".env.secrets")):
     Starlette.__init__(self,
                        middleware=[Middleware(GlobalStateMiddleware)])
     ConfigAppMixin.__init__(self, config_files)
     DatabaseAppMixin.__init__(self)
     PrecomputationAppMixin.__init__(self)
     SessionAppMixin.__init__(self)
     AuthAppMixin.__init__(self)
     FormsAppMixin.__init__(self)
예제 #2
0
파일: app.py 프로젝트: storborg/remotedroid
    def __init__(self, name, serial=None, debug=False):
        self.name = name
        self.serial = serial
        self.templates = Jinja2Templates(directory=templates_dir)
        self.screenshot_queues = set()

        routes = [
            Route("/", self.index_route),
            WebSocketRoute("/ws/screenshots", self.screenshot_endpoint),
            WebSocketRoute("/ws/control", self.control_endpoint),
            Mount("/static", StaticFiles(directory=static_dir), name="static"),
        ]

        Starlette.__init__(self, debug=debug, routes=routes)

        async def startup_handler():
            asyncio.ensure_future(self.screenshot_task())

        self.add_event_handler("startup", startup_handler)
예제 #3
0
    def __init__(self, database_settings: DatabaseSettings,
                 b2_settings: B2Settings,
                 friendly_url: str,
                 secret_key: str = token_urlsafe(),
                 csrf_secret: str = token_urlsafe(),
                 map_images: dict = MAP_IMAGES,
                 upload_delay: float = 0.1,
                 max_upload_size: int = 80000000,
                 **kwargs) -> None:
        """
        SQLMatches server.

        database_settings: DatabaseSettings
            Holds settings for database.
        friendly_url: str
            URL to project.
        csrf_secret: str
            Optionally pass your own url safe secret key.
        secret_key: str
            Optionally pass your own url safe secret key.
        map_images: dict
            Key as actual map name, value as image name.
        upload_delay: float
            by default 0.1
        max_upload_size: int
            by default 80000000
        kwargs
            Additional parameters to pass to the Starlette instance.
        """

        startup_tasks = [self._startup]
        shutdown_tasks = [self._shutdown]

        if "on_startup" in kwargs:
            startup_tasks = startup_tasks + kwargs["on_startup"]

        if "on_shutdown" in kwargs:
            shutdown_tasks = shutdown_tasks + kwargs["on_shutdown"]

        middlewares = [
            Middleware(SessionMiddleware, secret_key=secret_key),
            Middleware(CSRFProtectMiddleware, csrf_secret=csrf_secret),
            Middleware(APIMiddleware)
        ]
        if "middleware" in kwargs:
            middlewares = middlewares + kwargs["middleware"]

        if "routes" in kwargs:
            routes = kwargs["routes"] + ROUTES
        else:
            routes = ROUTES

        if "exception_handlers" in kwargs:
            exception_handlers = kwargs["exception_handlers"] + ERROR_HANDLERS
        else:
            exception_handlers = ERROR_HANDLERS

        if friendly_url[:1] != "/":
            friendly_url += "/"

        Config.url = friendly_url
        Config.map_images = map_images
        Config.demo_pathway = b2_settings.pathway
        Config.cdn_url = b2_settings.cdn_url
        Config.upload_delay = upload_delay
        Config.max_upload_size = max_upload_size

        database_url = "://{}:{}@{}:{}/{}?charset=utf8mb4".format(
            database_settings.username,
            database_settings.password,
            database_settings.server,
            database_settings.port,
            database_settings.database
        )

        Sessions.database = Database(
            database_settings.engine + database_url
        )

        self.b2 = backblaze.Awaiting(
            b2_settings.key_id,
            b2_settings.application_key
        )

        Sessions.bucket = self.b2.bucket(
            b2_settings.bucket_id
        )

        create_tables(
            "{}+{}{}".format(
                database_settings.engine,
                database_settings.alchemy_engine,
                database_url
            )
        )

        Starlette.__init__(
            self,
            routes=routes,
            exception_handlers=exception_handlers,
            middleware=middlewares,
            on_startup=startup_tasks,
            on_shutdown=shutdown_tasks,
            **kwargs
        )