def request_info(self, jid, request_vcard=True, allow_redirect=False): _task = yield redirected = False disco_info = yield self.disco_info(jid) if is_error(disco_info): error_response = disco_info if not allow_redirect: raise error_response if error_response.condition != 'gone': raise error_response try: jid = parse_xmpp_uri(error_response.condition_data)[0] except Exception: raise error_response redirected = True disco_info = yield self.disco_info(jid) raise_if_error(disco_info) if not request_vcard or not disco_info.supports(Namespace.VCARD): yield MucInfoResult(info=disco_info, redirected=redirected) vcard = yield self.request_vcard(jid) if is_error(vcard): yield MucInfoResult(info=disco_info, redirected=redirected) yield MucInfoResult(info=disco_info, vcard=vcard, redirected=redirected)
def request_archive_on_muc_join(self, jid): _task = yield threshold = app.settings.get_group_chat_setting( self._account, jid, 'sync_threshold') self._log.info('Threshold for %s: %s', jid, threshold) if threshold == SyncThreshold.NO_SYNC: return mam_id, start_date = self._get_muc_query_params(jid, threshold) result = yield self._execute_query(jid, mam_id, start_date) if is_error(result): if result.condition != 'item-not-found': self._log.warning(result) return app.storage.archive.reset_archive_infos(result.jid) _, start_date = self._get_muc_query_params(jid, threshold) result = yield self._execute_query(result.jid, None, start_date) if is_error(result): self._log.warning(result) return if result.rsm.last is not None: # <last> is not provided if the requested page was empty # so this means we did not get anything hence we only need # to update the archive info if <last> is present app.storage.archive.set_archive_infos( result.jid, last_mam_id=result.rsm.last, last_muc_timestamp=time.time())
def get_roster_delimiter(self): _task = yield delimiter = yield self.request_delimiter() if is_error(delimiter) or delimiter is None: result = yield self.set_delimiter(self.delimiter) if is_error(result): self._con.connect_machine() return delimiter = self.delimiter self.delimiter = delimiter self.available = True self._con.connect_machine()
def publish(self, node, item, id_=None, options=None, jid=None, force_node_options=False): _task = yield request = _make_publish_request(node, item, id_, options, jid) response = yield request if response.isError(): error = PubSubStanzaError(response) if (not force_node_options or error.app_condition != 'precondition-not-met'): raise error result = yield self.reconfigure_node(node, options, jid) if is_error(result): raise result response = yield request if response.isError(): raise PubSubStanzaError(response) jid = response.getFrom() item_id = _get_published_item_id(response, node, id_) yield PubSubPublishResult(jid, node, item_id)
def send_ping(self, contact: ContactsT) -> Generator: _task = yield if not app.account_is_available(self._account): return jid = contact.get_full_jid() self._log.info('Send ping to %s', jid) app.nec.push_incoming_event( NetworkEvent('ping-sent', account=self._account, contact=contact)) ping_time = time.time() response = yield self.ping(jid, timeout=10) if is_error(response): app.nec.push_incoming_event( NetworkEvent('ping-error', account=self._account, contact=contact, error=str(response))) return diff = round(time.time() - ping_time, 2) self._log.info('Received pong from %s after %s seconds', response.jid, diff) app.nec.push_incoming_event( NetworkEvent('ping-reply', account=self._account, contact=contact, seconds=diff))
def _log_if_fatal(self, error): if is_error(error): if error.is_fatal: self._logger.log(error.log_level, error) elif isinstance(error, Exception): self._logger.exception('Fatal Exception')
def reconfigure_node(self, node, options, jid=None): _task = yield result = yield self.get_node_configuration(node, jid) if is_error(result): raise result _apply_options(result.form, options) result = yield self.set_node_configuration(node, result.form, jid) yield result
def _request_vcard(self, jid): _task = yield con = app.connections[self.account] vcard = yield con.get_module('VCardTemp').request_vcard(jid=jid) if is_error(vcard): return self.clear_values() self._set_values(vcard.data, str(jid)) self._load_avatar(vcard)
def request_archive_on_signin(self): _task = yield own_jid = self._con.get_own_jid().bare if own_jid in self._mam_query_ids: self._log.warning('request already running for %s', own_jid) return mam_id, start_date = self._get_query_params() result = yield self._execute_query(own_jid, mam_id, start_date) if is_error(result): if result.condition != 'item-not-found': self._log.warning(result) return app.storage.archive.reset_archive_infos(result.jid) _, start_date = self._get_query_params() result = yield self._execute_query(result.jid, None, start_date) if is_error(result): self._log.warning(result) return if result.rsm.last is not None: # <last> is not provided if the requested page was empty # so this means we did not get anything hence we only need # to update the archive info if <last> is present app.storage.archive.set_archive_infos( result.jid, last_mam_id=result.rsm.last, last_muc_timestamp=time.time()) if start_date is not None: # Record the earliest timestamp we request from # the account archive. For the account archive we only # set start_date at the very first request. app.storage.archive.set_archive_infos( result.jid, oldest_mam_timestamp=start_date.timestamp())
def _process_search_result(self, result, parameters=False): if self._search_stopped: raise CancelledError() if is_error(result): self._global_search_listbox.remove_progress() self._show_error_page(to_user_string(result)) raise result if parameters: return for item in result.items: self._global_search_listbox.add(ResultRow(item))
def request_catalog(self, jid): _task = yield catalog = yield self._nbxmpp('SecurityLabels').request_catalog(jid) if is_error(catalog): self._log.info(catalog) return self._catalogs[jid] = catalog self._log.info('Received catalog: %s', jid) app.nec.push_incoming_event( NetworkEvent('sec-catalog-received', account=self._account, jid=jid, catalog=catalog))
def finalize(task, result): if is_error(result): raise result if isinstance(result, Node): return task.set_result(result) return result
def raise_if_error(result): if is_error(result): raise result
def is_fatal_error(error): if is_error(error): return error.is_fatal return isinstance(error, Exception)