async def connect(self): """Create connection object with chat library.""" config = nio.AsyncClientConfig( nio.ClientConfig(encryption_enabled=False, pickle_key="")) mapi = nio.AsyncClient(self.homeserver, self.mxid, config=config) login_response = await mapi.login(password=self.password, device_name=self.device_name) if isinstance(login_response, nio.LoginError): _LOGGER.error( f"Error while connecting: {login_response.message} (status code {login_response.status_code})" ) return mapi.token = login_response.access_token mapi.sync_token = None for roomname, room in self.rooms.items(): response = await mapi.join(room["alias"]) if isinstance(response, nio.JoinError): _LOGGER.error( f"Error while joining room: {room['alias']}, Message: {response.message} (status code {response.status_code})" ) else: self.room_ids[roomname] = response.room_id self.connection = mapi # Create a filter now, saves time on each later sync self.filter_id = await self.make_filter(mapi, self.filter_json) first_filter_id = await self.make_filter( mapi, '{ "room": { "timeline" : { "limit" : 1 } } }') # Do initial sync so we don't get old messages later. response = await self.connection.sync(timeout=3000, sync_filter=first_filter_id) if isinstance(response, nio.SyncError): _LOGGER.error( f"Error during initial sync: {response.message} (status code {response.status_code})" ) return self.connection.sync_token = response.next_batch if self.nick: display_name = await self.connection.get_displayname(self.mxid) if display_name != self.nick: await self.connection.set_displayname(self.nick)
def __init__(self, config: Config, sync: bool = True): self.__client_config = nio.AsyncClientConfig( max_limit_exceeded=0, max_timeouts=0, store_sync_tokens=True, encryption_enabled=True, ) self.__config = config self.__client = self.__load_client() self.__sync_keys() self.__sync = None if sync: self.__sync = self.__sync_state()
def __init__(self, backend, user: str, homeserver: str = "https://matrix.org", device_id: Optional[str] = None) -> None: if not urlparse(homeserver).scheme: raise ValueError( f"homeserver is missing scheme (e.g. https://): {homeserver}", ) store = Path(backend.appdirs.user_data_dir) / "encryption" store.mkdir(parents=True, exist_ok=True) super().__init__( homeserver = homeserver, user = user, device_id = device_id, store_path = store, config = nio.AsyncClientConfig( max_timeout_retry_wait_time = 10, # TODO: pass a custom encryption DB pickle key? ), ) self.backend: "Backend" = backend self.models: ModelStore = self.backend.models self.profile_task: Optional[asyncio.Future] = None self.server_config_task: Optional[asyncio.Future] = None self.sync_task: Optional[asyncio.Future] = None self.load_rooms_task: Optional[asyncio.Future] = None self.upload_monitors: Dict[UUID, nio.TransferMonitor] = {} self.upload_tasks: Dict[UUID, asyncio.Task] = {} self.send_message_tasks: Dict[UUID, asyncio.Task] = {} self.first_sync_done: asyncio.Event = asyncio.Event() self.first_sync_date: Optional[datetime] = None self.past_tokens: Dict[str, str] = {} # {room_id: token} self.fully_loaded_rooms: Set[str] = set() # {room_id} self.loaded_once_rooms: Set[str] = set() # {room_id} self.cleared_events_rooms: Set[str] = set() # {room_id} self.skipped_events: DefaultDict[str, int] = DefaultDict(lambda: 0) self.nio_callbacks = NioCallbacks(self)
async def main() -> None: config = Config() store_path = config.get_store_path() if not os.path.exists(store_path): os.makedirs(store_path) if len(config.get_access_token()) > 0: print("Access token already set.") sys.exit(1) client_config = nio.AsyncClientConfig( max_limit_exceeded=0, max_timeouts=0, store_sync_tokens=True, encryption_enabled=True, ) client = nio.AsyncClient( homeserver=config.get_home_server(), user=config.get_user_id(), store_path=config.get_store_path(), config=client_config, ssl=True ) response = await client.login( password=getpass.getpass(), device_name=config.get_device_name() ) await client.close() if not isinstance(response, nio.LoginResponse): print("Failed to get access token.") sys.exit(1) config.set_access_token(response.access_token) config.set_device_id(response.device_id) config.save_config()
async def connect(self): """Create connection object with chat library.""" if self._allow_encryption: _LOGGER.debug( f"Using {self.store_path} for the matrix client store.") Path(self.store_path).mkdir(exist_ok=True) config = nio.AsyncClientConfig( encryption_enabled=self._allow_encryption, pickle_key="", store_name="opsdroid.db" if self._allow_encryption else "", ) self.connection = nio.AsyncClient( self.homeserver, self.mxid, config=config, store_path=self.store_path if self._allow_encryption else "", device_id=self.device_id, ) if self.access_token is not None: self.connection.access_token = self.access_token whoami_response = await self.connection.whoami() if isinstance(whoami_response, nio.responses.WhoamiError): _LOGGER.error( f"Error while connecting: {whoami_response.message} (status code {whoami_response.status_code})" ) return self.mxid = whoami_response.user_id self.connection.user_id = self.mxid elif self.mxid is not None and self.password is not None: login_response = await self.connection.login( password=self.password, device_name=self.device_name) if isinstance(login_response, nio.LoginError): _LOGGER.error( f"Error while connecting: {login_response.message} (status code {login_response.status_code})" ) return self.access_token = ( self.connection.access_token) = login_response.access_token else: raise ValueError( "Configuration for the matrix connector should specify mxid and password or access_token." ) # pragma: no cover self.connection.sync_token = None for roomname, room in self.rooms.items(): response = await self.connection.join(room["alias"]) if isinstance(response, nio.JoinError): _LOGGER.error( f"Error while joining room: {room['alias']}, Message: {response.message} (status code {response.status_code})" ) else: self.room_ids[roomname] = response.room_id # Create a filter now, saves time on each later sync self.filter_id = await self.make_filter(self.connection, self.filter_json) first_filter_id = await self.make_filter( self.connection, '{ "room": { "timeline" : { "limit" : 1 } } }') # Do initial sync so we don't get old messages later. response = await self.connection.sync(timeout=3000, sync_filter=first_filter_id, full_state=True) if isinstance(response, nio.SyncError): _LOGGER.error( f"Error during initial sync: {response.message} (status code {response.status_code})" ) return self.connection.sync_token = response.next_batch await self.exchange_keys(initial_sync=True) if self.nick: display_name = await self.connection.get_displayname(self.mxid) if isinstance(display_name, nio.ErrorResponse): _LOGGER.warning( f"Error fetching current display_name: {display_name.message} (status code {display_name.status_code})" ) display_name = None else: display_name = display_name.displayname if display_name != self.nick: display_name_resp = await self.connection.set_displayname( self.nick) if isinstance(display_name_resp, nio.ErrorResponse): _LOGGER.warning( f"Error setting display_name: {display_name_resp.message} (status code {display_name_resp.status_code})" )
async def connect(self): """Create connection object with chat library.""" if self._allow_encryption: _LOGGER.debug(f"Using {self.store_path} for the matrix client store.") Path(self.store_path).mkdir(exist_ok=True) config = nio.AsyncClientConfig( encryption_enabled=self._allow_encryption, pickle_key="", store_name="opsdroid.db" if self._allow_encryption else "", ) mapi = nio.AsyncClient( self.homeserver, self.mxid, config=config, store_path=self.store_path if self._allow_encryption else "", device_id=self.device_id, ) login_response = await mapi.login( password=self.password, device_name=self.device_name ) if isinstance(login_response, nio.LoginError): _LOGGER.error( f"Error while connecting: {login_response.message} (status code {login_response.status_code})" ) return mapi.token = login_response.access_token mapi.sync_token = None for roomname, room in self.rooms.items(): response = await mapi.join(room["alias"]) if isinstance(response, nio.JoinError): _LOGGER.error( f"Error while joining room: {room['alias']}, Message: {response.message} (status code {response.status_code})" ) else: self.room_ids[roomname] = response.room_id self.connection = mapi # Create a filter now, saves time on each later sync self.filter_id = await self.make_filter(mapi, self.filter_json) first_filter_id = await self.make_filter( mapi, '{ "room": { "timeline" : { "limit" : 1 } } }' ) # Do initial sync so we don't get old messages later. response = await self.connection.sync( timeout=3000, sync_filter=first_filter_id, full_state=True ) if isinstance(response, nio.SyncError): _LOGGER.error( f"Error during initial sync: {response.message} (status code {response.status_code})" ) return self.connection.sync_token = response.next_batch await self.exchange_keys(initial_sync=True) if self.nick: display_name = await self.connection.get_displayname(self.mxid) if display_name != self.nick: await self.connection.set_displayname(self.nick)