def __init__(self, bridge: 'Bridge', homeserver_address: str, user_id_prefix: str, user_id_suffix: str, db_url: str, key_sharing_config: Dict[str, bool] = None ) -> None: self.loop = bridge.loop or asyncio.get_event_loop() self.bridge = bridge self.az = bridge.az self.device_name = bridge.name self._id_prefix = user_id_prefix self._id_suffix = user_id_suffix self._share_session_events = {} self.key_sharing_config = key_sharing_config or {} pickle_key = "mautrix.bridge.e2ee" if db_url.startswith("postgres://"): if not PgCryptoStore or not PgCryptoStateStore: raise RuntimeError("Database URL is set to postgres, but asyncpg is not installed") self.crypto_db = Database(url=db_url, upgrade_table=PgCryptoStore.upgrade_table, log=logging.getLogger("mau.crypto.db"), loop=self.loop) self.crypto_store = PgCryptoStore("", pickle_key, self.crypto_db) self.state_store = PgCryptoStateStore(self.crypto_db, bridge.get_portal) elif db_url.startswith("pickle:///"): self.crypto_db = None self.crypto_store = PickleCryptoStore("", pickle_key, db_url[len("pickle:///"):]) self.state_store = SQLCryptoStateStore(bridge.get_portal) else: raise RuntimeError("Unsupported database scheme") self.client = Client(base_url=homeserver_address, mxid=self.az.bot_mxid, loop=self.loop, sync_store=self.crypto_store) self.crypto = OlmMachine(self.client, self.crypto_store, self.state_store) self.crypto.allow_key_share = self.allow_key_share
async def start_database( self, upgrade_table: UpgradeTable | None = None, actually_start: bool = True ) -> None: if self.loader.meta.database_type == DatabaseType.SQLALCHEMY: self.inst_db = sql.create_engine(f"sqlite:///{self._sqlite_db_path}") elif self.loader.meta.database_type == DatabaseType.ASYNCPG: instance_db_log = db_log.getChild(self.id) # TODO should there be a way to choose between SQLite and Postgres # for individual instances? Maybe checking the existence of the SQLite file. if self.maubot.plugin_postgres_db: self.inst_db = ProxyPostgresDatabase( pool=self.maubot.plugin_postgres_db, instance_id=self.id, max_conns=self.maubot.config["plugin_databases.postgres_max_conns_per_plugin"], upgrade_table=upgrade_table, log=instance_db_log, ) else: self.inst_db = Database.create( f"sqlite:///{self._sqlite_db_path}", upgrade_table=upgrade_table, log=instance_db_log, ) if actually_start: await self.inst_db.start() else: raise RuntimeError(f"Unrecognized database type {self.loader.meta.database_type}")
def prepare_db(self) -> None: self.db = Database.create( self.config["database"], upgrade_table=upgrade_table, db_args=self.config["database_opts"], owner_name=self.name, ignore_foreign_tables=self.args.ignore_foreign_tables, ) init_db(self.db) if PgCryptoStore: if self.config["crypto_database"] == "default": self.crypto_db = self.db else: self.crypto_db = Database.create( self.config["crypto_database"], upgrade_table=PgCryptoStore.upgrade_table, ignore_foreign_tables=self.args.ignore_foreign_tables, ) else: self.crypto_db = None if self.config["plugin_databases.postgres"] == "default": if self.db.scheme != Scheme.POSTGRES: self.log.critical( 'Using "default" as the postgres plugin database URL is only allowed if ' "the default database is postgres.") sys.exit(24) assert isinstance(self.db, PostgresDatabase) self.plugin_postgres_db = self.db elif self.config["plugin_databases.postgres"]: plugin_db = Database.create( self.config["plugin_databases.postgres"], db_args={ **self.config["database_opts"], **self.config["plugin_databases.postgres_opts"], }, ) if plugin_db.scheme != Scheme.POSTGRES: self.log.critical( "The plugin postgres database URL must be a postgres database" ) sys.exit(24) assert isinstance(plugin_db, PostgresDatabase) self.plugin_postgres_db = plugin_db else: self.plugin_postgres_db = None
def prepare_db(self) -> None: if not hasattr(self, "upgrade_table") or not self.upgrade_table: raise RuntimeError("upgrade_table is not set") self.db = Database.create( self.config["appservice.database"], upgrade_table=self.upgrade_table, db_args=self.config["appservice.database_opts"], owner_name=self.name, ignore_foreign_tables=self.args.ignore_foreign_tables, )
async def start(self) -> None: self.database = Database(url=self.config["server.database"], upgrade_table=upgrade_table) Base.db = self.database init_mixpanel(self.config) self.server = Server(self.config) await self.database.start() await self.server.start() await super().start()
def __init__( self, bridge: br.Bridge, homeserver_address: str, user_id_prefix: str, user_id_suffix: str, db_url: str, key_sharing_config: dict[str, bool] = None, ) -> None: self.loop = bridge.loop or asyncio.get_event_loop() self.bridge = bridge self.az = bridge.az self.device_name = bridge.name self._id_prefix = user_id_prefix self._id_suffix = user_id_suffix self._share_session_events = {} self.key_sharing_config = key_sharing_config or {} pickle_key = "mautrix.bridge.e2ee" self.crypto_db = Database.create( url=db_url, upgrade_table=PgCryptoStore.upgrade_table, log=logging.getLogger("mau.crypto.db"), ) self.crypto_store = PgCryptoStore("", pickle_key, self.crypto_db) self.state_store = PgCryptoStateStore(self.crypto_db, bridge.get_portal) default_http_retry_count = bridge.config.get( "homeserver.http_retry_count", None) self.client = Client( base_url=homeserver_address, mxid=self.az.bot_mxid, loop=self.loop, sync_store=self.crypto_store, log=self.log.getChild("client"), default_retry_count=default_http_retry_count, ) self.crypto = OlmMachine(self.client, self.crypto_store, self.state_store) self.client.add_event_handler(InternalEventType.SYNC_STOPPED, self._exit_on_sync_fail) self.crypto.allow_key_share = self.allow_key_share
# # This program is distributed in the hope that it will be useful, # but WITHOUT ANY WARRANTY; without even the implied warranty of # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the # GNU Affero General Public License for more details. # # You should have received a copy of the GNU Affero General Public License # along with this program. If not, see <https://www.gnu.org/licenses/>. from typing import Dict, Optional, TYPE_CHECKING, ClassVar from asyncpg import Record from attr import dataclass from mautrix.util.async_db import Database fake_db = Database("") if TYPE_CHECKING else None @dataclass class UserPortal: db: ClassVar[Database] = fake_db user: int portal: int portal_receiver: int in_community: bool @classmethod def _from_row(cls, row: Optional[Record]) -> Optional['UserPortal']: if row is None: return None
def prepare_db(self) -> None: self.db = Database(self.config["appservice.database"], upgrade_table=upgrade_table, loop=self.loop, db_args=self.config["appservice.database_opts"]) init_db(self.db)
module, main_class = meta.main_class.split("/", 1) else: module = meta.modules[0] main_class = meta.main_class bot_module = importlib.import_module(module) plugin: type[Plugin] = getattr(bot_module, main_class) loader = FileSystemLoader(os.path.dirname(args.meta)) log.info( f"Initializing standalone {meta.id} v{meta.version} on maubot {__version__}" ) db = Database.create( config["database"], db_args=config.get("database_opts", {}), ignore_foreign_tables=True, log=logging.getLogger("maubot.db.standalone.upgrade"), upgrade_table=upgrade_table, ) user_id = config["user.credentials.id"] device_id = config["user.credentials.device_id"] homeserver = config["user.credentials.homeserver"] access_token = config["user.credentials.access_token"] crypto_store = state_store = None if device_id and not OlmMachine: log.warning( "device_id set in config, but encryption dependencies not installed", exc_info=crypto_import_error, )