libervia-backend: libervia/backend/memory/memory.py annotate

annotate libervia/backend/memory/memory.py @ 4094:c3b68fdc2de7

component AP gateway: fix handling of XMPP comments authors: the gateway was supposing that comments where emitted from PEP of author. While this is the case for most blog posts, it's not for comments. Instead the component is now using `author_jid` which is retrieved by XEP-0277 plugin, and reject the item if the auhor is not verified (i.e. if `publisher` attribute is not set by XMPP service).

author	Goffi <goffi@goffi.org>
date	Mon, 12 Jun 2023 14:50:43 +0200
parents	4b842c1fb686
children	02f0adc745c6

rev	line source
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1 #!/usr/bin/env python3
3137 559a625a236b fixed shebangs Goffi <goffi@goffi.org> parents: 3136 diff changeset	2
3480 7550ae9cfbac Renamed the project from "Salut à Toi" to "Libervia": Goffi <goffi@goffi.org> parents: 3479 diff changeset	3 # Libervia: an XMPP client
3479 be6d91572633 date update Goffi <goffi@goffi.org> parents: 3371 diff changeset	4 # Copyright (C) 2009-2021 Jérôme Poisson (goffi@goffi.org)
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	5
609 84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	6 # This program is free software: you can redistribute it and/or modify
84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	7 # it under the terms of the GNU Affero General Public License as published by
84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	8 # the Free Software Foundation, either version 3 of the License, or
84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	9 # (at your option) any later version.
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	10
609 84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	11 # This program is distributed in the hope that it will be useful,
84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	14 # GNU Affero General Public License for more details.
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	15
609 84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	16 # You should have received a copy of the GNU Affero General Public License
84a6e83157c2 fixed licences in docstrings (they are now in comments) Goffi <goffi@goffi.org> parents: 592 diff changeset	17 # along with this program. If not, see <http://www.gnu.org/licenses/>.
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	18
c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	19 import os.path
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	20 import copy
3206 ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	21 import shortuuid
ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	22 import mimetypes
ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	23 import time
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	24 from functools import partial
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	25 from typing import Optional, Tuple, Dict
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	26 from pathlib import Path
3206 ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	27 from uuid import uuid4
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	28 from collections import namedtuple
1447 b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	29 from twisted.python import failure
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	30 from twisted.internet import defer, reactor, error
47 9aa2d9dd4045 memory methods improvement Goffi <goffi@goffi.org> parents: 41 diff changeset	31 from twisted.words.protocols.jabber import jid
4071 4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	32 from libervia.backend.core.i18n import _
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	33 from libervia.backend.core.log import getLogger
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	34 from libervia.backend.core import exceptions
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	35 from libervia.backend.core.constants import Const as C
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	36 from libervia.backend.memory.sqla import Storage
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	37 from libervia.backend.memory.persistent import PersistentDict
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	38 from libervia.backend.memory.params import Params
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	39 from libervia.backend.memory.disco import Discovery
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	40 from libervia.backend.memory.crypto import BlockCipher
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	41 from libervia.backend.memory.crypto import PasswordHasher
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	42 from libervia.backend.tools import config as tools_config
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	43 from libervia.backend.tools.common import data_format
4b842c1fb686 refactoring: renamed `sat` package to `libervia.backend` Goffi <goffi@goffi.org> parents: 4037 diff changeset	44 from libervia.backend.tools.common import regex
3206 ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	45
ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	46
ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	47 log = getLogger(__name__)
420 acd908528ef7 core: profile creation/deletion through database Goffi <goffi@goffi.org> parents: 418 diff changeset	48
679 59c9a7ff903d wix, misc: use picture of dimension 32x32 for tray icon + better PEP-8 compliance souliane <souliane@mailoo.org> parents: 677 diff changeset	49
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	50 PresenceTuple = namedtuple("PresenceTuple", ("show", "priority", "statuses"))
1447 b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	51 MSG_NO_SESSION = "Session id doesn't exist or is finished"
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	52
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	53
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	54 class Sessions(object):
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	55 """Sessions are data associated to key used for a temporary moment, with optional profile checking."""
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	56
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	57 DEFAULT_TIMEOUT = 600
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	58
1215 d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	59 def __init__(self, timeout=None, resettable_timeout=True):
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	60 """
1215 d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	61 @param timeout (int): nb of seconds before session destruction
d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	62 @param resettable_timeout (bool): if True, the timeout is reset on each access
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	63 """
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	64 self._sessions = dict()
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	65 self.timeout = timeout or Sessions.DEFAULT_TIMEOUT
1215 d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	66 self.resettable_timeout = resettable_timeout
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	67
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	68 def new_session(self, session_data=None, session_id=None, profile=None):
1447 b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	69 """Create a new session
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	70
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	71 @param session_data: mutable data to use, default to a dict
1212 628e320eab1f memory: Sessions.newSession can be called with a forced session ID souliane <souliane@mailoo.org> parents: 1199 diff changeset	72 @param session_id (str): force the session_id to the given string
757 bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	73 @param profile: if set, the session is owned by the profile,
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	74 and profile_get must be used instead of __getitem__
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	75 @return: session_id, session_data
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	76 """
1212 628e320eab1f memory: Sessions.newSession can be called with a forced session ID souliane <souliane@mailoo.org> parents: 1199 diff changeset	77 if session_id is None:
628e320eab1f memory: Sessions.newSession can be called with a forced session ID souliane <souliane@mailoo.org> parents: 1199 diff changeset	78 session_id = str(uuid4())
1213 b5928601d7aa memory: handle the case where an existing session ID is re-used for creating a new session souliane <souliane@mailoo.org> parents: 1212 diff changeset	79 elif session_id in self._sessions:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	80 raise exceptions.ConflictError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	81 "Session id {} is already used".format(session_id)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	82 )
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	83 timer = reactor.callLater(self.timeout, self._purge_session, session_id)
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	84 if session_data is None:
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	85 session_data = {}
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	86 self._sessions[session_id] = (
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	87 (timer, session_data) if profile is None else (timer, session_data, profile)
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	88 )
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	89 return session_id, session_data
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	90
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	91 def _purge_session(self, session_id):
1447 b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	92 try:
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	93 timer, session_data, profile = self._sessions[session_id]
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	94 except ValueError:
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	95 timer, session_data = self._sessions[session_id]
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	96 profile = None
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	97 try:
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	98 timer.cancel()
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	99 except error.AlreadyCalled:
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	100 # if the session is time-outed, the timer has been called
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	101 pass
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	102 del self._sessions[session_id]
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	103 log.debug(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	104 "Session {} purged{}".format(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	105 session_id,
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	106 " (profile {})".format(profile) if profile is not None else "",
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	107 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	108 )
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	109
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	110 def __len__(self):
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	111 return len(self._sessions)
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	112
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	113 def __contains__(self, session_id):
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	114 return session_id in self._sessions
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	115
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	116 def profile_get(self, session_id, profile):
757 bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	117 try:
bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	118 timer, session_data, profile_set = self._sessions[session_id]
bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	119 except ValueError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	120 raise exceptions.InternalError(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	121 "You need to use __getitem__ when profile is not set"
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	122 )
1447 b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	123 except KeyError:
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	124 raise failure.Failure(KeyError(MSG_NO_SESSION))
757 bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	125 if profile_set != profile:
bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	126 raise exceptions.InternalError("current profile differ from set profile !")
1215 d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	127 if self.resettable_timeout:
d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	128 timer.reset(self.timeout)
757 bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	129 return session_data
bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	130
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	131 def __getitem__(self, session_id):
757 bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	132 try:
bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	133 timer, session_data = self._sessions[session_id]
bbe55c7bee43 core (memory): added optional profile checking in Sessions: Goffi <goffi@goffi.org> parents: 756 diff changeset	134 except ValueError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	135 raise exceptions.InternalError(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	136 "You need to use profile_get instead of __getitem__ when profile is set"
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	137 )
1447 b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	138 except KeyError:
b003dbd2b4e9 core (memory): Sessions fixes: Goffi <goffi@goffi.org> parents: 1409 diff changeset	139 raise failure.Failure(KeyError(MSG_NO_SESSION))
1215 d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	140 if self.resettable_timeout:
d9c399ec5dd9 memory: session timeout won't be reset on each access if the Sessions() is called with resettable_timeout=False souliane <souliane@mailoo.org> parents: 1214 diff changeset	141 timer.reset(self.timeout)
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	142 return session_data
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	143
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	144 def __setitem__(self, key, value):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	145 raise NotImplementedError("You need do use new_session to create a session")
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	146
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	147 def __delitem__(self, session_id):
1474 c2a498dce4b4 core (memory): fixed a double timer.cancel in Sessions Goffi <goffi@goffi.org> parents: 1460 diff changeset	148 """ delete the session data """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	149 self._purge_session(session_id)
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	150
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	151 def keys(self):
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	152 return list(self._sessions.keys())
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	153
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	154 def iterkeys(self):
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	155 return iter(self._sessions.keys())
756 efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	156
efa0e0f57950 core (memory): new Sessions management class (similar to dict) Goffi <goffi@goffi.org> parents: 751 diff changeset	157
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	158 class ProfileSessions(Sessions):
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	159 """ProfileSessions extends the Sessions class, but here the profile can be
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	160 used as the key to retrieve data or delete a session (instead of session id).
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	161 """
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	162
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	163 def _profile_get_all_ids(self, profile):
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	164 """Return a list of the sessions ids that are associated to the given profile.
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	165
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	166 @param profile: %(doc_profile)s
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	167 @return: a list containing the sessions ids
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	168 """
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	169 ret = []
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	170 for session_id in self._sessions.keys():
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	171 try:
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	172 timer, session_data, profile_set = self._sessions[session_id]
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	173 except ValueError:
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	174 continue
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	175 if profile == profile_set:
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	176 ret.append(session_id)
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	177 return ret
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	178
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	179 def profile_get_unique(self, profile):
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	180 """Return the data of the unique session that is associated to the given profile.
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	181
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	182 @param profile: %(doc_profile)s
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	183 @return:
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	184 - mutable data (default: dict) of the unique session
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	185 - None if no session is associated to the profile
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	186 - raise an error if more than one session are found
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	187 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	188 ids = self._profile_get_all_ids(profile)
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	189 if len(ids) > 1:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	190 raise exceptions.InternalError(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	191 "profile_get_unique has been used but more than one session has been found!"
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	192 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	193 return (
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	194 self.profile_get(ids[0], profile) if len(ids) == 1 else None
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	195 ) # XXX: timeout might be reset
1214 ed3b01ed70d7 memory: profileSessions.profileGetUnique was not resetting the timer souliane <souliane@mailoo.org> parents: 1213 diff changeset	196
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	197 def profile_del_unique(self, profile):
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	198 """Delete the unique session that is associated to the given profile.
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	199
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	200 @param profile: %(doc_profile)s
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	201 @return: None, but raise an error if more than one session are found
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	202 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	203 ids = self._profile_get_all_ids(profile)
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	204 if len(ids) > 1:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	205 raise exceptions.InternalError(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	206 "profile_del_unique has been used but more than one session has been found!"
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	207 )
1029 f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	208 if len(ids) == 1:
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	209 del self._sessions[ids[0]]
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	210
f6182f6418ea memory: add class ProfileSessions based on Sessions souliane <souliane@mailoo.org> parents: 1015 diff changeset	211
1247 c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	212 class PasswordSessions(ProfileSessions):
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	213
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	214 # FIXME: temporary hack for the user personal key not to be lost. The session
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	215 # must actually be purged and later, when the personal key is needed, the
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	216 # profile password should be asked again in order to decrypt it.
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	217 def __init__(self, timeout=None):
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	218 ProfileSessions.__init__(self, timeout, resettable_timeout=False)
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	219
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	220 def _purge_session(self, session_id):
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	221 log.debug(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	222 "FIXME: PasswordSessions should ask for the profile password after the session expired"
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	223 )
1247 c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	224
c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	225
3582 71516731d0aa core (memory/sqla): database migration using Alembic: Goffi <goffi@goffi.org> parents: 3541 diff changeset	226 class Memory:
1199 96fb74a4714d misc: fixed some typos Matteo Cypriani <mcy@lm7.fr> parents: 1097 diff changeset	227 """This class manage all the persistent information"""
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	228
22 bb72c29f3432 added action cb mechanism for buttons. Tested with a temporary new user registration button. Goffi <goffi@goffi.org> parents: 21 diff changeset	229 def __init__(self, host):
993 301b342c697a core: use of the new core.log module: Goffi <goffi@goffi.org> parents: 946 diff changeset	230 log.info(_("Memory manager init"))
41 d24629c631fc SàT: new constant management, a local dir (~/.sat) is now used Goffi <goffi@goffi.org> parents: 38 diff changeset	231 self.host = host
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	232 self._entities_cache = {} # XXX: keep presence/last resource/other data in cache
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	233 # /!\ an entity is not necessarily in roster
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	234 # main key is bare jid, value is a dict
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	235 # where main key is resource, or None for bare jid
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	236 self._key_signals = set() # key which need a signal to frontends when updated
592 e5a875a3311b Fix pep8 support in src/memory. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 588 diff changeset	237 self.subscriptions = {}
1247 c6cf44e6330b memory: temporary dirty hack to fix the personnal key issue after the auth session expired souliane <souliane@mailoo.org> parents: 1240 diff changeset	238 self.auth_sessions = PasswordSessions() # remember the authenticated profiles
944 e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	239 self.disco = Discovery(host)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	240 self.config = tools_config.parse_main_conf(log_filenames=True)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	241 self._cache_path = Path(self.config_get("", "local_dir"), C.CACHE_DIR)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	242 self.admins = self.config_get("", "admins_list", [])
3777 001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	243 self.admin_jids = set()
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	244
3537 f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	245
f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	246 async def initialise(self):
3582 71516731d0aa core (memory/sqla): database migration using Alembic: Goffi <goffi@goffi.org> parents: 3541 diff changeset	247 self.storage = Storage()
3537 f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	248 await self.storage.initialise()
432 31e8c48b5f5d core: - memory refactoring (moved memory.py and sqlite.py from tools to memory) Goffi <goffi@goffi.org> parents: 428 diff changeset	249 PersistentDict.storage = self.storage
3537 f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	250 self.params = Params(self.host, self.storage)
993 301b342c697a core: use of the new core.log module: Goffi <goffi@goffi.org> parents: 946 diff changeset	251 log.info(_("Loading default params template"))
677 9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	252 self.params.load_default_params()
3537 f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	253 await self.load()
443 7099ea9c1b12 core: getPrivate/setPrivate removed from memory, private values now use database storage and persistent dicts \o/ Goffi <goffi@goffi.org> parents: 432 diff changeset	254 self.memory_data = PersistentDict("memory")
3537 f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	255 await self.memory_data.load()
f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	256 await self.disco.load()
3777 001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	257 for admin in self.admins:
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	258 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	259 admin_jid_s = await self.param_get_a_async(
3777 001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	260 "JabberID", "Connection", profile_key=admin
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	261 )
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	262 except Exception as e:
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	263 log.warning(f"Can't retrieve jid of admin {admin!r}: {e}")
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	264 else:
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	265 if admin_jid_s is not None:
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	266 try:
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	267 admin_jid = jid.JID(admin_jid_s).userhostJID()
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	268 except RuntimeError:
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	269 log.warning(f"Invalid JID for admin {admin}: {admin_jid_s}")
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	270 else:
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	271 self.admin_jids.add(admin_jid)
3537 f9a5b810f14d core (memory/storage): backend storage is now based on SQLAlchemy Goffi <goffi@goffi.org> parents: 3523 diff changeset	272
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	273
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	274 ## Configuration ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	275
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	276 def config_get(self, section, name, default=None):
364 312ca6f9d84a core: configuration file Goffi <goffi@goffi.org> parents: 346 diff changeset	277 """Get the main configuration option
1234 9c17bd37e6e5 core: better management of default value in getConfig Goffi <goffi@goffi.org> parents: 1224 diff changeset	278
364 312ca6f9d84a core: configuration file Goffi <goffi@goffi.org> parents: 346 diff changeset	279 @param section: section of the config file (None or '' for DEFAULT)
312ca6f9d84a core: configuration file Goffi <goffi@goffi.org> parents: 346 diff changeset	280 @param name: name of the option
1234 9c17bd37e6e5 core: better management of default value in getConfig Goffi <goffi@goffi.org> parents: 1224 diff changeset	281 @param default: value to use if not found
9c17bd37e6e5 core: better management of default value in getConfig Goffi <goffi@goffi.org> parents: 1224 diff changeset	282 @return: str, list or dict
365 efbfccfed623 core: local_dir moved to config file Goffi <goffi@goffi.org> parents: 364 diff changeset	283 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	284 return tools_config.config_get(self.config, section, name, default)
364 312ca6f9d84a core: configuration file Goffi <goffi@goffi.org> parents: 346 diff changeset	285
677 9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	286 def load_xml(self, filename):
1015 fee00f2e11c2 memory, jp: added jp commands to load/save parameters template souliane <souliane@mailoo.org> parents: 1007 diff changeset	287 """Load parameters template from xml file
fee00f2e11c2 memory, jp: added jp commands to load/save parameters template souliane <souliane@mailoo.org> parents: 1007 diff changeset	288
fee00f2e11c2 memory, jp: added jp commands to load/save parameters template souliane <souliane@mailoo.org> parents: 1007 diff changeset	289 @param filename (str): input file
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	290 @return: bool: True in case of success
1015 fee00f2e11c2 memory, jp: added jp commands to load/save parameters template souliane <souliane@mailoo.org> parents: 1007 diff changeset	291 """
fee00f2e11c2 memory, jp: added jp commands to load/save parameters template souliane <souliane@mailoo.org> parents: 1007 diff changeset	292 if not filename:
677 9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	293 return False
9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	294 filename = os.path.expanduser(filename)
9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	295 if os.path.exists(filename):
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	296 try:
677 9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	297 self.params.load_xml(filename)
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	298 log.debug(_("Parameters loaded from file: %s") % filename)
677 9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	299 return True
557 4f856dd4c0d0 core: paramaters are now merged: if a parameter doens't exist in loaded xml but exists in default parameters, it is added Goffi <goffi@goffi.org> parents: 556 diff changeset	300 except Exception as e:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	301 log.error(_("Can't load parameters from file: %s") % e)
677 9a50aa7feefb core (memory): cleaned the part for load/save to xml (not used) souliane <souliane@mailoo.org> parents: 669 diff changeset	302 return False
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	303
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	304 def save_xml(self, filename):
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	305 """Save parameters template to xml file
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	306
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	307 @param filename (str): output file
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	308 @return: bool: True in case of success
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	309 """
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	310 if not filename:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	311 return False
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	312 # TODO: need to encrypt files (at least passwords !) and set permissions
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	313 filename = os.path.expanduser(filename)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	314 try:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	315 self.params.save_xml(filename)
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	316 log.debug(_("Parameters saved to file: %s") % filename)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	317 return True
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	318 except Exception as e:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	319 log.error(_("Can't save parameters to file: %s") % e)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	320 return False
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	321
443 7099ea9c1b12 core: getPrivate/setPrivate removed from memory, private values now use database storage and persistent dicts \o/ Goffi <goffi@goffi.org> parents: 432 diff changeset	322 def load(self):
428 a4a9efadabfc core: fixed memory initialisation sequence Goffi <goffi@goffi.org> parents: 425 diff changeset	323 """Load parameters and all memory things from db"""
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	324 # parameters data
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	325 return self.params.load_gen_params()
412 62b17854254e database integration: first draft Goffi <goffi@goffi.org> parents: 399 diff changeset	326
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	327 def load_individual_params(self, profile):
412 62b17854254e database integration: first draft Goffi <goffi@goffi.org> parents: 399 diff changeset	328 """Load individual parameters for a profile
416 32dc8b18c2ae core: param loading/purging on profile connection/disconnection Goffi <goffi@goffi.org> parents: 413 diff changeset	329 @param profile: %(doc_profile)s"""
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	330 return self.params.load_ind_params(profile)
412 62b17854254e database integration: first draft Goffi <goffi@goffi.org> parents: 399 diff changeset	331
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	332 ## Profiles/Sessions management ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	333
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	334 def start_session(self, password, profile):
484 23cbdf0a0777 core: presence status + last resource refactored and kept in entitiesCache in memory.py, profile cache is purged on disconnection Goffi <goffi@goffi.org> parents: 480 diff changeset	335 """"Iniatialise session for a profile
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	336
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	337 @param password(unicode): profile session password
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	338 or empty string is no password is set
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	339 @param profile: %(doc_profile)s
1694 3c608d660f0b core (memory): profile is checked in startSession (an error is raised if it doesn't exist) Goffi <goffi@goffi.org> parents: 1693 diff changeset	340 @raise exceptions.ProfileUnknownError if profile doesn't exists
3c608d660f0b core (memory): profile is checked in startSession (an error is raised if it doesn't exist) Goffi <goffi@goffi.org> parents: 1693 diff changeset	341 @raise exceptions.PasswordError: the password does not match
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	342 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	343 profile = self.get_profile_name(profile)
1694 3c608d660f0b core (memory): profile is checked in startSession (an error is raised if it doesn't exist) Goffi <goffi@goffi.org> parents: 1693 diff changeset	344
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	345 def create_session(__):
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	346 """Called once params are loaded."""
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	347 self._entities_cache[profile] = {}
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	348 log.info("[{}] Profile session started".format(profile))
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	349 return False
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	350
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	351 def backend_initialised(__):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	352 def do_start_session(__=None):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	353 if self.is_session_started(profile):
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	354 log.info("Session already started!")
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	355 return True
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	356 try:
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	357 # if there is a value at this point in self._entities_cache,
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	358 # it is the load_individual_params Deferred, the session is starting
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	359 session_d = self._entities_cache[profile]
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	360 except KeyError:
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	361 # else we do request the params
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	362 session_d = self._entities_cache[profile] = self.load_individual_params(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	363 profile
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	364 )
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	365 session_d.addCallback(create_session)
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	366 finally:
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	367 return session_d
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	368
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	369 auth_d = defer.ensureDeferred(self.profile_authenticate(password, profile))
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	370 auth_d.addCallback(do_start_session)
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	371 return auth_d
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	372
1723 5632c5350296 core: avoid initialisation blocking when a long callback is added to backend.initialised (could prevent sessions starting) Goffi <goffi@goffi.org> parents: 1704 diff changeset	373 if self.host.initialised.called:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	374 return defer.succeed(None).addCallback(backend_initialised)
1723 5632c5350296 core: avoid initialisation blocking when a long callback is added to backend.initialised (could prevent sessions starting) Goffi <goffi@goffi.org> parents: 1704 diff changeset	375 else:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	376 return self.host.initialised.addCallback(backend_initialised)
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	377
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	378 def stop_session(self, profile):
1693 35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	379 """Delete a profile session
35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	380
35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	381 @param profile: %(doc_profile)s
35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	382 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	383 if self.host.is_connected(profile):
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	384 log.debug("Disconnecting profile because of session stop")
1693 35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	385 self.host.disconnect(profile)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	386 self.auth_sessions.profile_del_unique(profile)
1693 35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	387 try:
35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	388 self._entities_cache[profile]
35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	389 except KeyError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	390 log.warning("Profile was not in cache")
1693 35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	391
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	392 def _is_session_started(self, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	393 return self.is_session_started(self.get_profile_name(profile_key))
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	394
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	395 def is_session_started(self, profile):
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	396 try:
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	397 # XXX: if the value in self._entities_cache is a Deferred,
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	398 # the session is starting but not started yet
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	399 return not isinstance(self._entities_cache[profile], defer.Deferred)
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	400 except KeyError:
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	401 return False
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	402
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	403 async def profile_authenticate(self, password, profile):
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	404 """Authenticate the profile.
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	405
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	406 @param password (unicode): the SàT profile password
3160 330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	407 @return: None in case of success (an exception is raised otherwise)
1693 35426d58471c core (memory): stopSession implementation Goffi <goffi@goffi.org> parents: 1689 diff changeset	408 @raise exceptions.PasswordError: the password does not match
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	409 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	410 if not password and self.auth_sessions.profile_get_unique(profile):
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	411 # XXX: this allows any frontend to connect with the empty password as soon as
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	412 # the profile has been authenticated at least once before. It is OK as long as
0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	413 # submitting a form with empty passwords is restricted to local frontends.
3160 330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	414 return
1591 0df9c6247474 core: profile session starting and connection are now separated. Moved profile session starting/authentication to memory module Goffi <goffi@goffi.org> parents: 1587 diff changeset	415
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	416 sat_cipher = await self.param_get_a_async(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	417 C.PROFILE_PASS_PATH[1], C.PROFILE_PASS_PATH[0], profile_key=profile
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	418 )
3160 330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	419 valid = PasswordHasher.verify(password, sat_cipher)
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	420 if not valid:
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	421 log.warning(_("Authentication failure of profile {profile}").format(
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	422 profile=profile))
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	423 raise exceptions.PasswordError("The provided profile password doesn't match.")
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	424 return await self.new_auth_session(password, profile)
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	425
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	426 async def new_auth_session(self, key, profile):
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	427 """Start a new session for the authenticated profile.
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	428
3128 73b5228715e8 core (memory): avoid session locking if profileAuthenticate is called twice quickly Goffi <goffi@goffi.org> parents: 3123 diff changeset	429 If there is already an existing session, no new one is created
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	430 The personal key is loaded encrypted from a PersistentDict before being decrypted.
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	431
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	432 @param key: the key to decrypt the personal key
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	433 @param profile: %(doc_profile)s
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	434 """
3160 330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	435 data = await PersistentDict(C.MEMORY_CRYPTO_NAMESPACE, profile).load()
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	436 personal_key = BlockCipher.decrypt(key, data[C.MEMORY_CRYPTO_KEY])
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	437 # Create the session for this profile and store the personal key
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	438 session_data = self.auth_sessions.profile_get_unique(profile)
3160 330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	439 if not session_data:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	440 self.auth_sessions.new_session(
3160 330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	441 {C.MEMORY_CRYPTO_KEY: personal_key}, profile=profile
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	442 )
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	443 log.debug("auth session created for profile %s" % profile)
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	444
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	445 def purge_profile_session(self, profile):
416 32dc8b18c2ae core: param loading/purging on profile connection/disconnection Goffi <goffi@goffi.org> parents: 413 diff changeset	446 """Delete cache of data of profile
32dc8b18c2ae core: param loading/purging on profile connection/disconnection Goffi <goffi@goffi.org> parents: 413 diff changeset	447 @param profile: %(doc_profile)s"""
993 301b342c697a core: use of the new core.log module: Goffi <goffi@goffi.org> parents: 946 diff changeset	448 log.info(_("[%s] Profile session purge" % profile))
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	449 self.params.purge_profile(profile)
484 23cbdf0a0777 core: presence status + last resource refactored and kept in entitiesCache in memory.py, profile cache is purged on disconnection Goffi <goffi@goffi.org> parents: 480 diff changeset	450 try:
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	451 del self._entities_cache[profile]
484 23cbdf0a0777 core: presence status + last resource refactored and kept in entitiesCache in memory.py, profile cache is purged on disconnection Goffi <goffi@goffi.org> parents: 480 diff changeset	452 except KeyError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	453 log.error(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	454 _(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	455 "Trying to purge roster status cache for a profile not in memory: [%s]"
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	456 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	457 % profile
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	458 )
484 23cbdf0a0777 core: presence status + last resource refactored and kept in entitiesCache in memory.py, profile cache is purged on disconnection Goffi <goffi@goffi.org> parents: 480 diff changeset	459
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	460 def get_profiles_list(self, clients=True, components=False):
2146 1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	461 """retrieve profiles list
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	462
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	463 @param clients(bool): if True return clients profiles
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	464 @param components(bool): if True return components profiles
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	465 @return (list[unicode]): selected profiles
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	466 """
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	467 if not clients and not components:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	468 log.warning(_("requesting no profiles at all"))
2146 1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	469 return []
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	470 profiles = self.storage.get_profiles_list()
2146 1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	471 if clients and components:
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	472 return sorted(profiles)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	473 is_component = self.storage.profile_is_component
2146 1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	474 if clients:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	475 p_filter = lambda p: not is_component(p)
2146 1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	476 else:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	477 p_filter = lambda p: is_component(p)
2146 1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	478
1bb9bf1b4150 core, frontends: getProfilesList renamed to profilesGetList + behaviour change: Goffi <goffi@goffi.org> parents: 2144 diff changeset	479 return sorted(p for p in profiles if p_filter(p))
60 9764e027ecc0 SàT: multi-profile parameters, first draft Goffi <goffi@goffi.org> parents: 57 diff changeset	480
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	481 def get_profile_name(self, profile_key, return_profile_keys=False):
62 93cb45a7420f SàT multi-profile: connection using profiles Goffi <goffi@goffi.org> parents: 61 diff changeset	482 """Return name of profile from keyword
1263 cfd636203e8f core: misc improvments: Goffi <goffi@goffi.org> parents: 1258 diff changeset	483
1519 fbe86b5d156f core (memory, params): minor docstrings updates Goffi <goffi@goffi.org> parents: 1474 diff changeset	484 @param profile_key: can be the profile name or a keyword (like @DEFAULT@)
1263 cfd636203e8f core: misc improvments: Goffi <goffi@goffi.org> parents: 1258 diff changeset	485 @param return_profile_keys: if True, return unmanaged profile keys (like "@ALL@"). This keys must be managed by the caller
1519 fbe86b5d156f core (memory, params): minor docstrings updates Goffi <goffi@goffi.org> parents: 1474 diff changeset	486 @return: requested profile name
1460 c7fd121a6180 core: getProfileName no raise ProfileUnknownError + minor doc fixes Goffi <goffi@goffi.org> parents: 1447 diff changeset	487 @raise exceptions.ProfileUnknownError if profile doesn't exists
1263 cfd636203e8f core: misc improvments: Goffi <goffi@goffi.org> parents: 1258 diff changeset	488 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	489 return self.params.get_profile_name(profile_key, return_profile_keys)
62 93cb45a7420f SàT multi-profile: connection using profiles Goffi <goffi@goffi.org> parents: 61 diff changeset	490
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	491 def profile_set_default(self, profile):
1595 a3d0cfa5b7a6 core, bridge: added a profileSetDefault method Goffi <goffi@goffi.org> parents: 1591 diff changeset	492 """Set default profile
a3d0cfa5b7a6 core, bridge: added a profileSetDefault method Goffi <goffi@goffi.org> parents: 1591 diff changeset	493
a3d0cfa5b7a6 core, bridge: added a profileSetDefault method Goffi <goffi@goffi.org> parents: 1591 diff changeset	494 @param profile: %(doc_profile)s
a3d0cfa5b7a6 core, bridge: added a profileSetDefault method Goffi <goffi@goffi.org> parents: 1591 diff changeset	495 """
a3d0cfa5b7a6 core, bridge: added a profileSetDefault method Goffi <goffi@goffi.org> parents: 1591 diff changeset	496 # we want to be sure that the profile exists
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	497 profile = self.get_profile_name(profile)
1595 a3d0cfa5b7a6 core, bridge: added a profileSetDefault method Goffi <goffi@goffi.org> parents: 1591 diff changeset	498
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	499 self.memory_data["Profile_default"] = profile
1595 a3d0cfa5b7a6 core, bridge: added a profileSetDefault method Goffi <goffi@goffi.org> parents: 1591 diff changeset	500
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	501 def create_profile(self, name, password, component=None):
420 acd908528ef7 core: profile creation/deletion through database Goffi <goffi@goffi.org> parents: 418 diff changeset	502 """Create a new profile
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	503
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	504 @param name(unicode): profile name
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	505 @param password(unicode): profile password
1695 5a93f13c1e76 core (memory): asyncCreateProfile fix: a fake session is created to set general password param Goffi <goffi@goffi.org> parents: 1694 diff changeset	506 Can be empty to disable password
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	507 @param component(None, unicode): set to entry point if this is a component
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	508 @return: Deferred
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	509 @raise exceptions.NotFound: component is not a known plugin import name
420 acd908528ef7 core: profile creation/deletion through database Goffi <goffi@goffi.org> parents: 418 diff changeset	510 """
1263 cfd636203e8f core: misc improvments: Goffi <goffi@goffi.org> parents: 1258 diff changeset	511 if not name:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	512 raise ValueError("Empty profile name")
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	513 if name[0] == "@":
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	514 raise ValueError("A profile name can't start with a '@'")
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	515 if "\n" in name:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	516 raise ValueError("A profile name can't contain line feed ('\\n')")
1682 61391d863709 plugin XEP-0054: fixed vcard-update callback which was updating avatar when hash was empty, resulting in a really slow start Goffi <goffi@goffi.org> parents: 1652 diff changeset	517
1695 5a93f13c1e76 core (memory): asyncCreateProfile fix: a fake session is created to set general password param Goffi <goffi@goffi.org> parents: 1694 diff changeset	518 if name in self._entities_cache:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	519 raise exceptions.ConflictError("A session for this profile exists")
1695 5a93f13c1e76 core (memory): asyncCreateProfile fix: a fake session is created to set general password param Goffi <goffi@goffi.org> parents: 1694 diff changeset	520
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	521 if component:
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	522 if not component in self.host.plugins:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	523 raise exceptions.NotFound(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	524 _(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	525 "Can't find component {component} entry point".format(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	526 component=component
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	527 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	528 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	529 )
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	530 # FIXME: PLUGIN_INFO is not currently accessible after import, but type shoul be tested here
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	531 # if self.host.plugins[component].PLUGIN_INFO[u"type"] != C.PLUG_TYPE_ENTRY_POINT:
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	532 # raise ValueError(_(u"Plugin {component} is not an entry point !".format(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	533 # component = component)))
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	534
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	535 d = self.params.create_profile(name, component)
1682 61391d863709 plugin XEP-0054: fixed vcard-update callback which was updating avatar when hash was empty, resulting in a really slow start Goffi <goffi@goffi.org> parents: 1652 diff changeset	536
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	537 def init_personal_key(__):
1652 fd7f41d8cbdf memory: fixes asyncCreateProfile to not overwrite the personal key souliane <souliane@mailoo.org> parents: 1595 diff changeset	538 # be sure to call this after checking that the profile doesn't exist yet
3040 fee60f17ebac jp: jp asyncio port: Goffi <goffi@goffi.org> parents: 3031 diff changeset	539
fee60f17ebac jp: jp asyncio port: Goffi <goffi@goffi.org> parents: 3031 diff changeset	540 # generated once for all and saved in a PersistentDict
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	541 personal_key = BlockCipher.get_random_key(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	542 base64=True
3040 fee60f17ebac jp: jp asyncio port: Goffi <goffi@goffi.org> parents: 3031 diff changeset	543 ).decode('utf-8')
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	544 self.auth_sessions.new_session(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	545 {C.MEMORY_CRYPTO_KEY: personal_key}, profile=name
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	546 ) # will be encrypted by param_set
1652 fd7f41d8cbdf memory: fixes asyncCreateProfile to not overwrite the personal key souliane <souliane@mailoo.org> parents: 1595 diff changeset	547
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	548 def start_fake_session(__):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	549 # avoid ProfileNotConnected exception in param_set
1695 5a93f13c1e76 core (memory): asyncCreateProfile fix: a fake session is created to set general password param Goffi <goffi@goffi.org> parents: 1694 diff changeset	550 self._entities_cache[name] = None
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	551 self.params.load_ind_params(name)
1695 5a93f13c1e76 core (memory): asyncCreateProfile fix: a fake session is created to set general password param Goffi <goffi@goffi.org> parents: 1694 diff changeset	552
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	553 def stop_fake_session(__):
1695 5a93f13c1e76 core (memory): asyncCreateProfile fix: a fake session is created to set general password param Goffi <goffi@goffi.org> parents: 1694 diff changeset	554 del self._entities_cache[name]
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	555 self.params.purge_profile(name)
1695 5a93f13c1e76 core (memory): asyncCreateProfile fix: a fake session is created to set general password param Goffi <goffi@goffi.org> parents: 1694 diff changeset	556
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	557 d.addCallback(init_personal_key)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	558 d.addCallback(start_fake_session)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	559 d.addCallback(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	560 lambda __: self.param_set(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	561 C.PROFILE_PASS_PATH[1], password, C.PROFILE_PASS_PATH[0], profile_key=name
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	562 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	563 )
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	564 d.addCallback(stop_fake_session)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	565 d.addCallback(lambda __: self.auth_sessions.profile_del_unique(name))
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	566 return d
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	567
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	568 def profile_delete_async(self, name, force=False):
68 9b842086d915 multiple profiles update Goffi <goffi@goffi.org> parents: 66 diff changeset	569 """Delete an existing profile
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	570
894 57c32d8ec847 core (memory): asyncDeleteProfile can force the deletion of a profile, even if it's connected (when called from the backend only) souliane <souliane@mailoo.org> parents: 893 diff changeset	571 @param name: Name of the profile
57c32d8ec847 core (memory): asyncDeleteProfile can force the deletion of a profile, even if it's connected (when called from the backend only) souliane <souliane@mailoo.org> parents: 893 diff changeset	572 @param force: force the deletion even if the profile is connected.
57c32d8ec847 core (memory): asyncDeleteProfile can force the deletion of a profile, even if it's connected (when called from the backend only) souliane <souliane@mailoo.org> parents: 893 diff changeset	573 To be used for direct calls only (not through the bridge).
57c32d8ec847 core (memory): asyncDeleteProfile can force the deletion of a profile, even if it's connected (when called from the backend only) souliane <souliane@mailoo.org> parents: 893 diff changeset	574 @return: a Deferred instance
57c32d8ec847 core (memory): asyncDeleteProfile can force the deletion of a profile, even if it's connected (when called from the backend only) souliane <souliane@mailoo.org> parents: 893 diff changeset	575 """
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	576
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	577 def clean_memory(__):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	578 self.auth_sessions.profile_del_unique(name)
1704 292f9c2712f2 core (memory): fixed bad memory cleaning on asyncDeleteProfile Goffi <goffi@goffi.org> parents: 1695 diff changeset	579 try:
292f9c2712f2 core (memory): fixed bad memory cleaning on asyncDeleteProfile Goffi <goffi@goffi.org> parents: 1695 diff changeset	580 del self._entities_cache[name]
292f9c2712f2 core (memory): fixed bad memory cleaning on asyncDeleteProfile Goffi <goffi@goffi.org> parents: 1695 diff changeset	581 except KeyError:
292f9c2712f2 core (memory): fixed bad memory cleaning on asyncDeleteProfile Goffi <goffi@goffi.org> parents: 1695 diff changeset	582 pass
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	583
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	584 d = self.params.profile_delete_async(name, force)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	585 d.addCallback(clean_memory)
1704 292f9c2712f2 core (memory): fixed bad memory cleaning on asyncDeleteProfile Goffi <goffi@goffi.org> parents: 1695 diff changeset	586 return d
60 9764e027ecc0 SàT: multi-profile parameters, first draft Goffi <goffi@goffi.org> parents: 57 diff changeset	587
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	588 def is_component(self, profile_name):
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	589 """Tell if a profile is a component
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	590
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	591 @param profile_name(unicode): name of the profile
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	592 @return (bool): True if profile is a component
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	593 @raise exceptions.NotFound: profile doesn't exist
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	594 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	595 return self.storage.profile_is_component(profile_name)
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	596
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	597 def get_entry_point(self, profile_name):
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	598 """Get a component entry point
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	599
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	600 @param profile_name(unicode): name of the profile
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	601 @return (bool): True if profile is a component
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	602 @raise exceptions.NotFound: profile doesn't exist
1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	603 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	604 return self.storage.get_entry_point(profile_name)
2144 1d3f73e065e1 core, jp: component handling + client handling refactoring: Goffi <goffi@goffi.org> parents: 2052 diff changeset	605
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	606 ## History ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	607
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	608 def add_to_history(self, client, data):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	609 return self.storage.add_to_history(data, client.profile)
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	610
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	611 def _history_get_serialise(self, history_data):
3170 39d7327583e1 core: use serialised dict for `extra` in messageNew and historyGet Goffi <goffi@goffi.org> parents: 3163 diff changeset	612 return [
39d7327583e1 core: use serialised dict for `extra` in messageNew and historyGet Goffi <goffi@goffi.org> parents: 3163 diff changeset	613 (uid, timestamp, from_jid, to_jid, message, subject, mess_type,
39d7327583e1 core: use serialised dict for `extra` in messageNew and historyGet Goffi <goffi@goffi.org> parents: 3163 diff changeset	614 data_format.serialise(extra)) for uid, timestamp, from_jid, to_jid, message,
39d7327583e1 core: use serialised dict for `extra` in messageNew and historyGet Goffi <goffi@goffi.org> parents: 3163 diff changeset	615 subject, mess_type, extra in history_data
39d7327583e1 core: use serialised dict for `extra` in messageNew and historyGet Goffi <goffi@goffi.org> parents: 3163 diff changeset	616 ]
39d7327583e1 core: use serialised dict for `extra` in messageNew and historyGet Goffi <goffi@goffi.org> parents: 3163 diff changeset	617
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	618 def _history_get(self, from_jid_s, to_jid_s, limit=C.HISTORY_LIMIT_NONE, between=True,
2698 5060cbeec01e core: minor style/typos fixes Goffi <goffi@goffi.org> parents: 2624 diff changeset	619 filters=None, profile=C.PROF_KEY_NONE):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	620 d = self.history_get(jid.JID(from_jid_s), jid.JID(to_jid_s), limit, between,
2698 5060cbeec01e core: minor style/typos fixes Goffi <goffi@goffi.org> parents: 2624 diff changeset	621 filters, profile)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	622 d.addCallback(self._history_get_serialise)
3170 39d7327583e1 core: use serialised dict for `extra` in messageNew and historyGet Goffi <goffi@goffi.org> parents: 3163 diff changeset	623 return d
1963 a2bc5089c2eb backend, frontends: message refactoring (huge commit): Goffi <goffi@goffi.org> parents: 1955 diff changeset	624
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	625 def history_get(self, from_jid, to_jid, limit=C.HISTORY_LIMIT_NONE, between=True,
2698 5060cbeec01e core: minor style/typos fixes Goffi <goffi@goffi.org> parents: 2624 diff changeset	626 filters=None, profile=C.PROF_KEY_NONE):
1222 e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	627 """Retrieve messages in history
1955 633b5c21aefd backend, frontend: messages refactoring (huge commit, not finished): Goffi <goffi@goffi.org> parents: 1934 diff changeset	628
1222 e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	629 @param from_jid (JID): source JID (full, or bare for catchall)
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	630 @param to_jid (JID): dest JID (full, or bare for catchall)
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	631 @param limit (int): maximum number of messages to get:
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	632 - 0 for no message (returns the empty list)
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	633 - C.HISTORY_LIMIT_NONE or None for unlimited
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	634 - C.HISTORY_LIMIT_DEFAULT to use the HISTORY_LIMIT parameter value
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	635 @param between (bool): confound source and dest (ignore the direction)
2698 5060cbeec01e core: minor style/typos fixes Goffi <goffi@goffi.org> parents: 2624 diff changeset	636 @param filters (dict[unicode, unicode]): pattern to filter the history results
5060cbeec01e core: minor style/typos fixes Goffi <goffi@goffi.org> parents: 2624 diff changeset	637 (see bridge API for details)
1222 e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	638 @param profile (str): %(doc_profile)s
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	639 @return (D(list)): list of message data as in [message_new]
1222 e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	640 """
916 1a759096ccbd core: use of Const for profile_key + replaced '@DEFAULT@' default profile_key by '@NONE@' Goffi <goffi@goffi.org> parents: 914 diff changeset	641 assert profile != C.PROF_KEY_NONE
1222 e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	642 if limit == C.HISTORY_LIMIT_DEFAULT:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	643 limit = int(self.param_get_a(C.HISTORY_LIMIT, "General", profile_key=profile))
1222 e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	644 elif limit == C.HISTORY_LIMIT_NONE:
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	645 limit = None
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	646 if limit == 0:
e6e0ea4dc835 memory: add Parameter "Chat history limit" souliane <souliane@mailoo.org> parents: 1221 diff changeset	647 return defer.succeed([])
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	648 return self.storage.history_get(from_jid, to_jid, limit, between, filters, profile)
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	649
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	650 ## Statuses ##
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	651
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	652 def _get_presence_statuses(self, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	653 ret = self.presence_statuses_get(profile_key)
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	654 return {entity.full(): data for entity, data in ret.items()}
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	655
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	656 def presence_statuses_get(self, profile_key):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	657 """Get all the presence statuses of a profile
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	658
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	659 @param profile_key: %(doc_profile_key)s
71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	660 @return: presence data: key=entity JID, value=presence data for this entity
71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	661 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	662 client = self.host.get_client(profile_key)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	663 profile_cache = self._get_profile_cache(client)
484 23cbdf0a0777 core: presence status + last resource refactored and kept in entitiesCache in memory.py, profile cache is purged on disconnection Goffi <goffi@goffi.org> parents: 480 diff changeset	664 entities_presence = {}
23cbdf0a0777 core: presence status + last resource refactored and kept in entitiesCache in memory.py, profile cache is purged on disconnection Goffi <goffi@goffi.org> parents: 480 diff changeset	665
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	666 for entity_jid, entity_data in profile_cache.items():
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	667 for resource, resource_data in entity_data.items():
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	668 full_jid = copy.copy(entity_jid)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	669 full_jid.resource = resource
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	670 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	671 presence_data = self.get_entity_datum(client, full_jid, "presence")
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	672 except KeyError:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	673 continue
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	674 entities_presence.setdefault(entity_jid, {})[
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	675 resource or ""
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	676 ] = presence_data
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	677
484 23cbdf0a0777 core: presence status + last resource refactored and kept in entitiesCache in memory.py, profile cache is purged on disconnection Goffi <goffi@goffi.org> parents: 480 diff changeset	678 return entities_presence
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	679
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	680 def set_presence_status(self, entity_jid, show, priority, statuses, profile_key):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	681 """Change the presence status of an entity
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	682
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	683 @param entity_jid: jid.JID of the entity
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	684 @param show: show status
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	685 @param priority: priority
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	686 @param statuses: dictionary of statuses
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	687 @param profile_key: %(doc_profile_key)s
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	688 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	689 client = self.host.get_client(profile_key)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	690 presence_data = PresenceTuple(show, priority, statuses)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	691 self.update_entity_data(
3254 6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	692 client, entity_jid, "presence", presence_data
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	693 )
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	694 if entity_jid.resource and show != C.PRESENCE_UNAVAILABLE:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	695 # If a resource is available, bare jid should not have presence information
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	696 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	697 self.del_entity_datum(client, entity_jid.userhostJID(), "presence")
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	698 except (KeyError, exceptions.UnknownEntityError):
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	699 pass
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	700
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	701 ## Resources ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	702
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	703 def _get_all_resource(self, jid_s, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	704 client = self.host.get_client(profile_key)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	705 jid_ = jid.JID(jid_s)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	706 return self.get_all_resources(client, jid_)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	707
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	708 def get_all_resources(self, client, entity_jid):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	709 """Return all resource from jid for which we have had data in this session
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	710
2533 8d82a62fa098 core (disco), plugin XEP-0115: client use + capabilities hash improvment: Goffi <goffi@goffi.org> parents: 2526 diff changeset	711 @param entity_jid: bare jid of the entity
3206 ae09989e9feb core, bridge: new `devicesInfosGet` method to get infos on known devices of an entity Goffi <goffi@goffi.org> parents: 3170 diff changeset	712 return (set[unicode]): set of resources
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	713
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	714 @raise exceptions.UnknownEntityError: if entity is not in cache
1689 a40124e03baf core (memory): catch exceptions.UnknownEntityError in getMainResource Goffi <goffi@goffi.org> parents: 1684 diff changeset	715 @raise ValueError: entity_jid has a resource
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	716 """
2597 9446f1ea9eac core: discoFindByFeatures now return only available resources Goffi <goffi@goffi.org> parents: 2562 diff changeset	717 # FIXME: is there a need to keep cache data for resources which are not connected anymore?
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	718 if entity_jid.resource:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	719 raise ValueError(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	720 "get_all_resources must be used with a bare jid (got {})".format(entity_jid)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	721 )
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	722 profile_cache = self._get_profile_cache(client)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	723 try:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	724 entity_data = profile_cache[entity_jid.userhostJID()]
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	725 except KeyError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	726 raise exceptions.UnknownEntityError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	727 "Entity {} not in cache".format(entity_jid)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	728 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	729 resources = set(entity_data.keys())
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	730 resources.discard(None)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	731 return resources
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	732
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	733 def get_available_resources(self, client, entity_jid):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	734 """Return available resource for entity_jid
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	735
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	736 This method differs from get_all_resources by returning only available resources
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	737 @param entity_jid: bare jid of the entit
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	738 return (list[unicode]): list of available resources
1251 51a85e8f599a memory: add method isContactConnected souliane <souliane@mailoo.org> parents: 1247 diff changeset	739
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	740 @raise exceptions.UnknownEntityError: if entity is not in cache
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	741 """
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	742 available = []
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	743 for resource in self.get_all_resources(client, entity_jid):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	744 full_jid = copy.copy(entity_jid)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	745 full_jid.resource = resource
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	746 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	747 presence_data = self.get_entity_datum(client, full_jid, "presence")
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	748 except KeyError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	749 log.debug("Can't get presence data for {}".format(full_jid))
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	750 else:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	751 if presence_data.show != C.PRESENCE_UNAVAILABLE:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	752 available.append(resource)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	753 return available
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	754
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	755 def _get_main_resource(self, jid_s, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	756 client = self.host.get_client(profile_key)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	757 jid_ = jid.JID(jid_s)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	758 return self.main_resource_get(client, jid_) or ""
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	759
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	760 def main_resource_get(self, client, entity_jid):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	761 """Return the main resource used by an entity
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	762
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	763 @param entity_jid: bare entity jid
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	764 @return (unicode): main resource or None
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	765 """
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	766 if entity_jid.resource:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	767 raise ValueError(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	768 "main_resource_get must be used with a bare jid (got {})".format(entity_jid)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	769 )
1392 c7082457d03f memory, plugin XEP-0045: getMainResource returns None when asking a MUC entity + fixes /whois on a MUC (bare) entity souliane <souliane@mailoo.org> parents: 1375 diff changeset	770 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	771 if self.host.plugins["XEP-0045"].is_joined_room(client, entity_jid):
1392 c7082457d03f memory, plugin XEP-0045: getMainResource returns None when asking a MUC entity + fixes /whois on a MUC (bare) entity souliane <souliane@mailoo.org> parents: 1375 diff changeset	772 return None # MUC rooms have no main resource
c7082457d03f memory, plugin XEP-0045: getMainResource returns None when asking a MUC entity + fixes /whois on a MUC (bare) entity souliane <souliane@mailoo.org> parents: 1375 diff changeset	773 except KeyError: # plugin not found
c7082457d03f memory, plugin XEP-0045: getMainResource returns None when asking a MUC entity + fixes /whois on a MUC (bare) entity souliane <souliane@mailoo.org> parents: 1375 diff changeset	774 pass
1689 a40124e03baf core (memory): catch exceptions.UnknownEntityError in getMainResource Goffi <goffi@goffi.org> parents: 1684 diff changeset	775 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	776 resources = self.get_all_resources(client, entity_jid)
1689 a40124e03baf core (memory): catch exceptions.UnknownEntityError in getMainResource Goffi <goffi@goffi.org> parents: 1684 diff changeset	777 except exceptions.UnknownEntityError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	778 log.warning("Entity is not in cache, we can't find any resource")
1689 a40124e03baf core (memory): catch exceptions.UnknownEntityError in getMainResource Goffi <goffi@goffi.org> parents: 1684 diff changeset	779 return None
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	780 priority_resources = []
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	781 for resource in resources:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	782 full_jid = copy.copy(entity_jid)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	783 full_jid.resource = resource
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	784 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	785 presence_data = self.get_entity_datum(client, full_jid, "presence")
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	786 except KeyError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	787 log.debug("No presence information for {}".format(full_jid))
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	788 continue
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	789 priority_resources.append((resource, presence_data.priority))
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	790 try:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	791 return max(priority_resources, key=lambda res_tuple: res_tuple[1])[0]
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	792 except ValueError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	793 log.warning("No resource found at all for {}".format(entity_jid))
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	794 return None
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	795
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	796 ## Entities data ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	797
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	798 def _get_profile_cache(self, client):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	799 """Check profile validity and return its cache
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	800
2533 8d82a62fa098 core (disco), plugin XEP-0115: client use + capabilities hash improvment: Goffi <goffi@goffi.org> parents: 2526 diff changeset	801 @param client: SatXMPPClient
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	802 @return (dict): profile cache
1251 51a85e8f599a memory: add method isContactConnected souliane <souliane@mailoo.org> parents: 1247 diff changeset	803 """
2533 8d82a62fa098 core (disco), plugin XEP-0115: client use + capabilities hash improvment: Goffi <goffi@goffi.org> parents: 2526 diff changeset	804 return self._entities_cache[client.profile]
1251 51a85e8f599a memory: add method isContactConnected souliane <souliane@mailoo.org> parents: 1247 diff changeset	805
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	806 def set_signal_on_update(self, key, signal=True):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	807 """Set a signal flag on the key
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	808
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	809 When the key will be updated, a signal will be sent to frontends
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	810 @param key: key to signal
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	811 @param signal(boolean): if True, do the signal
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	812 """
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	813 if signal:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	814 self._key_signals.add(key)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	815 else:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	816 self._key_signals.discard(key)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	817
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	818 def get_all_entities_iter(self, client, with_bare=False):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	819 """Return an iterator of full jids of all entities in cache
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	820
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	821 @param with_bare: if True, include bare jids
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	822 @return (list[unicode]): list of jids
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	823 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	824 profile_cache = self._get_profile_cache(client)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	825 # we construct a list of all known full jids (bare jid of entities x resources)
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	826 for bare_jid, entity_data in profile_cache.items():
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	827 for resource in entity_data.keys():
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	828 if resource is None:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	829 continue
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	830 full_jid = copy.copy(bare_jid)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	831 full_jid.resource = resource
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	832 yield full_jid
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	833
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	834 def update_entity_data(
3254 6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	835 self, client, entity_jid, key, value, silent=False
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	836 ):
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	837 """Set a misc data for an entity
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	838
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	839 If key was registered with set_signal_on_update, a signal will be sent to frontends
2994 94708a7d3ecf core, plugin XEP-0045: fixed message type autodetection + ENTITY_TYPE_MUC constant: Goffi <goffi@goffi.org> parents: 2928 diff changeset	840 @param entity_jid: JID of the entity, C.ENTITY_ALL_RESOURCES for all resources of
94708a7d3ecf core, plugin XEP-0045: fixed message type autodetection + ENTITY_TYPE_MUC constant: Goffi <goffi@goffi.org> parents: 2928 diff changeset	841 all entities, C.ENTITY_ALL for all entities (all resources + bare jids)
94708a7d3ecf core, plugin XEP-0045: fixed message type autodetection + ENTITY_TYPE_MUC constant: Goffi <goffi@goffi.org> parents: 2928 diff changeset	842 @param key: key to set (eg: C.ENTITY_TYPE)
94708a7d3ecf core, plugin XEP-0045: fixed message type autodetection + ENTITY_TYPE_MUC constant: Goffi <goffi@goffi.org> parents: 2928 diff changeset	843 @param value: value for this key (eg: C.ENTITY_TYPE_MUC)
94708a7d3ecf core, plugin XEP-0045: fixed message type autodetection + ENTITY_TYPE_MUC constant: Goffi <goffi@goffi.org> parents: 2928 diff changeset	844 @param silent(bool): if True, doesn't send signal to frontend, even if there is a
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	845 signal flag (see set_signal_on_update)
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	846 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	847 profile_cache = self._get_profile_cache(client)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	848 if entity_jid in (C.ENTITY_ALL_RESOURCES, C.ENTITY_ALL):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	849 entities = self.get_all_entities_iter(client, entity_jid == C.ENTITY_ALL)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	850 else:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	851 entities = (entity_jid,)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	852
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	853 for jid_ in entities:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	854 entity_data = profile_cache.setdefault(jid_.userhostJID(), {}).setdefault(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	855 jid_.resource, {}
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	856 )
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	857
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	858 entity_data[key] = value
1315 be3a301540c0 core (memory): updateEntityData now accept a "silent" argument to avoid sending signal to frontends when updating an attribute with "signalOnUpdate" flag. Goffi <goffi@goffi.org> parents: 1314 diff changeset	859 if key in self._key_signals and not silent:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	860 self.host.bridge.entity_data_updated(
3254 6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	861 jid_.full(),
6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	862 key,
6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	863 data_format.serialise(value),
6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	864 client.profile
6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	865 )
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	866
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	867 def del_entity_datum(self, client, entity_jid, key):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	868 """Delete a data for an entity
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	869
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	870 @param entity_jid: JID of the entity, C.ENTITY_ALL_RESOURCES for all resources of all entities,
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	871 C.ENTITY_ALL for all entities (all resources + bare jids)
2994 94708a7d3ecf core, plugin XEP-0045: fixed message type autodetection + ENTITY_TYPE_MUC constant: Goffi <goffi@goffi.org> parents: 2928 diff changeset	872 @param key: key to delete (eg: C.ENTITY_TYPE)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	873
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	874 @raise exceptions.UnknownEntityError: if entity is not in cache
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	875 @raise KeyError: key is not in cache
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	876 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	877 profile_cache = self._get_profile_cache(client)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	878 if entity_jid in (C.ENTITY_ALL_RESOURCES, C.ENTITY_ALL):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	879 entities = self.get_all_entities_iter(client, entity_jid == C.ENTITY_ALL)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	880 else:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	881 entities = (entity_jid,)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	882
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	883 for jid_ in entities:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	884 try:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	885 entity_data = profile_cache[jid_.userhostJID()][jid_.resource]
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	886 except KeyError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	887 raise exceptions.UnknownEntityError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	888 "Entity {} not in cache".format(jid_)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	889 )
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	890 try:
71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	891 del entity_data[key]
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	892 except KeyError as e:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	893 if entity_jid in (C.ENTITY_ALL_RESOURCES, C.ENTITY_ALL):
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	894 continue # we ignore KeyError when deleting keys from several entities
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	895 else:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	896 raise e
399 3ed53803b3b3 core: added getLastResource method Goffi <goffi@goffi.org> parents: 398 diff changeset	897
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	898 def _get_entities_data(self, entities_jids, keys_list, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	899 client = self.host.get_client(profile_key)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	900 ret = self.entities_data_get(
3254 6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	901 client, [jid.JID(jid_) for jid_ in entities_jids], keys_list
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	902 )
3254 6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	903 return {
6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	904 jid_.full(): {k: data_format.serialise(v) for k,v in data.items()}
6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	905 for jid_, data in ret.items()
6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	906 }
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	907
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	908 def entities_data_get(self, client, entities_jids, keys_list=None):
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	909 """Get a list of cached values for several entities at once
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	910
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	911 @param entities_jids: jids of the entities, or empty list for all entities in cache
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	912 @param keys_list (iterable,None): list of keys to get, None for everything
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	913 @param profile_key: %(doc_profile_key)s
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	914 @return: dict withs values for each key in keys_list.
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	915 if there is no value of a given key, resulting dict will
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	916 have nothing with that key nether
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	917 if an entity doesn't exist in cache, it will not appear
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	918 in resulting dict
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	919
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	920 @raise exceptions.UnknownEntityError: if entity is not in cache
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	921 """
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	922
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	923 def fill_entity_data(entity_cache_data):
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	924 entity_data = {}
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	925 if keys_list is None:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	926 entity_data = entity_cache_data
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	927 else:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	928 for key in keys_list:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	929 try:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	930 entity_data[key] = entity_cache_data[key]
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	931 except KeyError:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	932 continue
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	933 return entity_data
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	934
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	935 profile_cache = self._get_profile_cache(client)
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	936 ret_data = {}
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	937 if entities_jids:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	938 for entity in entities_jids:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	939 try:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	940 entity_cache_data = profile_cache[entity.userhostJID()][
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	941 entity.resource
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	942 ]
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	943 except KeyError:
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	944 continue
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	945 ret_data[entity.full()] = fill_entity_data(entity_cache_data, keys_list)
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	946 else:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	947 for bare_jid, data in profile_cache.items():
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	948 for resource, entity_cache_data in data.items():
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	949 full_jid = copy.copy(bare_jid)
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	950 full_jid.resource = resource
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	951 ret_data[full_jid] = fill_entity_data(entity_cache_data)
1314 bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	952
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	953 return ret_data
bb9c32249778 core: added getEntitiesData which get cache data for several entities at once Goffi <goffi@goffi.org> parents: 1290 diff changeset	954
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	955 def _get_entity_data(self, entity_jid_s, keys_list=None, profile=C.PROF_KEY_NONE):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	956 return self.entity_data_get(
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	957 self.host.get_client(profile), jid.JID(entity_jid_s), keys_list)
3254 6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	958
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	959 def entity_data_get(self, client, entity_jid, keys_list=None):
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	960 """Get a list of cached values for entity
944 e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	961
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	962 @param entity_jid: JID of the entity
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	963 @param keys_list (iterable,None): list of keys to get, None for everything
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	964 @param profile_key: %(doc_profile_key)s
0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	965 @return: dict withs values for each key in keys_list.
504 65ecbb473cbb core, quick frontend, plugin xep-0054, bridge: use of memory's entities data for vcard: Goffi <goffi@goffi.org> parents: 494 diff changeset	966 if there is no value of a given key, resulting dict will
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	967 have nothing with that key nether
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	968
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	969 @raise exceptions.UnknownEntityError: if entity is not in cache
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	970 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	971 profile_cache = self._get_profile_cache(client)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	972 try:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	973 entity_data = profile_cache[entity_jid.userhostJID()][entity_jid.resource]
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	974 except KeyError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	975 raise exceptions.UnknownEntityError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	976 "Entity {} not in cache (was requesting {})".format(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	977 entity_jid, keys_list
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	978 )
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	979 )
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	980 if keys_list is None:
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	981 return entity_data
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	982
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	983 return {key: entity_data[key] for key in keys_list if key in entity_data}
47 9aa2d9dd4045 memory methods improvement Goffi <goffi@goffi.org> parents: 41 diff changeset	984
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	985 def get_entity_datum(self, client, entity_jid, key):
944 e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	986 """Get a datum from entity
e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	987
e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	988 @param entity_jid: JID of the entity
3254 6cf4bd6972c2 core, frontends: avatar refactoring: Goffi <goffi@goffi.org> parents: 3206 diff changeset	989 @param key: key to get
944 e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	990 @return: requested value
e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	991
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	992 @raise exceptions.UnknownEntityError: if entity is not in cache
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	993 @raise KeyError: if there is no value for this key and this entity
944 e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	994 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	995 return self.entity_data_get(client, entity_jid, (key,))[key]
944 e1842ebcb2f3 core, plugin XEP-0115: discovery refactoring: Goffi <goffi@goffi.org> parents: 943 diff changeset	996
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	997 def del_entity_cache(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	998 self, entity_jid, delete_all_resources=True, profile_key=C.PROF_KEY_NONE
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	999 ):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1000 """Remove all cached data for entity
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1001
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	1002 @param entity_jid: JID of the entity to delete
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1003 @param delete_all_resources: if True also delete all known resources from cache (a bare jid must be given in this case)
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	1004 @param profile_key: %(doc_profile_key)s
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1005
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1006 @raise exceptions.UnknownEntityError: if entity is not in cache
507 f98bef71a918 frontends, core, plugin XEP-0045: leave implementation + better nick change Goffi <goffi@goffi.org> parents: 504 diff changeset	1007 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1008 client = self.host.get_client(profile_key)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1009 profile_cache = self._get_profile_cache(client)
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	1010
71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	1011 if delete_all_resources:
71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	1012 if entity_jid.resource:
71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	1013 raise ValueError(_("Need a bare jid to delete all resources"))
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1014 try:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1015 del profile_cache[entity_jid]
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1016 except KeyError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1017 raise exceptions.UnknownEntityError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1018 "Entity {} not in cache".format(entity_jid)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1019 )
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1020 else:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1021 try:
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1022 del profile_cache[entity_jid.userhostJID()][entity_jid.resource]
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1023 except KeyError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1024 raise exceptions.UnknownEntityError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1025 "Entity {} not in cache".format(entity_jid)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1026 )
943 71926ec2114d core (memory): entities cache improvments: Goffi <goffi@goffi.org> parents: 935 diff changeset	1027
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1028 ## Encryption ##
507 f98bef71a918 frontends, core, plugin XEP-0045: leave implementation + better nick change Goffi <goffi@goffi.org> parents: 504 diff changeset	1029
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1030 def encrypt_value(self, value, profile):
1090 594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1031 """Encrypt a value for the given profile. The personal key must be loaded
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1032 already in the profile session, that should be the case if the profile is
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1033 already authenticated.
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1034
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1035 @param value (str): the value to encrypt
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1036 @param profile (str): %(doc_profile)s
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1037 @return: the deferred encrypted value
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1038 """
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1039 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1040 personal_key = self.auth_sessions.profile_get_unique(profile)[
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1041 C.MEMORY_CRYPTO_KEY
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1042 ]
1090 594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1043 except TypeError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1044 raise exceptions.InternalError(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1045 _("Trying to encrypt a value for %s while the personal key is undefined!")
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1046 % profile
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1047 )
1090 594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1048 return BlockCipher.encrypt(personal_key, value)
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1049
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1050 def decrypt_value(self, value, profile):
1090 594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1051 """Decrypt a value for the given profile. The personal key must be loaded
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1052 already in the profile session, that should be the case if the profile is
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1053 already authenticated.
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1054
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1055 @param value (str): the value to decrypt
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1056 @param profile (str): %(doc_profile)s
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1057 @return: the deferred decrypted value
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1058 """
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1059 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1060 personal_key = self.auth_sessions.profile_get_unique(profile)[
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1061 C.MEMORY_CRYPTO_KEY
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1062 ]
1090 594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1063 except TypeError:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1064 raise exceptions.InternalError(
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1065 _("Trying to decrypt a value for %s while the personal key is undefined!")
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1066 % profile
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1067 )
1090 594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1068 return BlockCipher.decrypt(personal_key, value)
594fbdda4a87 memory: add helper methods encryptValue and decryptValue souliane <souliane@mailoo.org> parents: 1064 diff changeset	1069
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1070 def encrypt_personal_data(self, data_key, data_value, crypto_key, profile):
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1071 """Re-encrypt a personal data (saved to a PersistentDict).
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1072
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1073 @param data_key: key for the individual PersistentDict instance
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1074 @param data_value: the value to be encrypted
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1075 @param crypto_key: the key to encrypt the value
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1076 @param profile: %(profile_doc)s
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1077 @return: a deferred None value
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1078 """
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1079
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1080 def got_ind_memory(data):
3160 330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	1081 data[data_key] = BlockCipher.encrypt(crypto_key, data_value)
330a5f1d9eea core (memory/crypto): replaced `PyCrypto` by `cryptography`: Goffi <goffi@goffi.org> parents: 3148 diff changeset	1082 return data.force(data_key)
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1083
2765 378188abe941 misc: replaced all "dummy" by the more conventional and readable "__" ("_" being used for gettext) Goffi <goffi@goffi.org> parents: 2698 diff changeset	1084 def done(__):
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1085 log.debug(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1086 _("Personal data (%(ns)s, %(key)s) has been successfuly encrypted")
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1087 % {"ns": C.MEMORY_CRYPTO_NAMESPACE, "key": data_key}
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1088 )
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1089
15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1090 d = PersistentDict(C.MEMORY_CRYPTO_NAMESPACE, profile).load()
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1091 return d.addCallback(got_ind_memory).addCallback(done)
1030 15f43b54d697 core, memory, bridge: added profile password + password encryption: souliane <souliane@mailoo.org> parents: 1029 diff changeset	1092
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1093 ## Subscription requests ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1094
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1095 def add_waiting_sub(self, type_, entity_jid, profile_key):
47 9aa2d9dd4045 memory methods improvement Goffi <goffi@goffi.org> parents: 41 diff changeset	1096 """Called when a subcription request is received"""
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1097 profile = self.get_profile_name(profile_key)
592 e5a875a3311b Fix pep8 support in src/memory. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 588 diff changeset	1098 assert profile
e5a875a3311b Fix pep8 support in src/memory. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 588 diff changeset	1099 if profile not in self.subscriptions:
65 d35c5edab53f SàT: multi-profile: memory & dbus bridge's methods profile management Goffi <goffi@goffi.org> parents: 64 diff changeset	1100 self.subscriptions[profile] = {}
722 04aabc3f2684 core (memory): fixed setDefault behaviour + minor refactoring Goffi <goffi@goffi.org> parents: 679 diff changeset	1101 self.subscriptions[profile][entity_jid] = type_
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1102
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1103 def del_waiting_sub(self, entity_jid, profile_key):
47 9aa2d9dd4045 memory methods improvement Goffi <goffi@goffi.org> parents: 41 diff changeset	1104 """Called when a subcription request is finished"""
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1105 profile = self.get_profile_name(profile_key)
592 e5a875a3311b Fix pep8 support in src/memory. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 588 diff changeset	1106 assert profile
e5a875a3311b Fix pep8 support in src/memory. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 588 diff changeset	1107 if profile in self.subscriptions and entity_jid in self.subscriptions[profile]:
486 0d9908ac775e core: entity cache misc data management + error moved to core.exceptions in memory Goffi <goffi@goffi.org> parents: 484 diff changeset	1108 del self.subscriptions[profile][entity_jid]
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1109
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1110 def sub_waiting_get(self, profile_key):
47 9aa2d9dd4045 memory methods improvement Goffi <goffi@goffi.org> parents: 41 diff changeset	1111 """Called to get a list of currently waiting subscription requests"""
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1112 profile = self.get_profile_name(profile_key)
65 d35c5edab53f SàT: multi-profile: memory & dbus bridge's methods profile management Goffi <goffi@goffi.org> parents: 64 diff changeset	1113 if not profile:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1114 log.error(_("Asking waiting subscriptions for a non-existant profile"))
65 d35c5edab53f SàT: multi-profile: memory & dbus bridge's methods profile management Goffi <goffi@goffi.org> parents: 64 diff changeset	1115 return {}
592 e5a875a3311b Fix pep8 support in src/memory. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 588 diff changeset	1116 if profile not in self.subscriptions:
65 d35c5edab53f SàT: multi-profile: memory & dbus bridge's methods profile management Goffi <goffi@goffi.org> parents: 64 diff changeset	1117 return {}
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1118
65 d35c5edab53f SàT: multi-profile: memory & dbus bridge's methods profile management Goffi <goffi@goffi.org> parents: 64 diff changeset	1119 return self.subscriptions[profile]
0 c4bc297b82f0 sat: goffi@necton2 parents: diff changeset	1120
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1121 ## Parameters ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1122
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1123 def get_string_param_a(self, name, category, attr="value", profile_key=C.PROF_KEY_NONE):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1124 return self.params.get_string_param_a(name, category, attr, profile_key)
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1125
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1126 def param_get_a(self, name, category, attr="value", profile_key=C.PROF_KEY_NONE):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1127 return self.params.param_get_a(name, category, attr, profile_key=profile_key)
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1128
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1129 def param_get_a_async(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1130 self,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1131 name,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1132 category,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1133 attr="value",
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1134 security_limit=C.NO_SECURITY_LIMIT,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1135 profile_key=C.PROF_KEY_NONE,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1136 ):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1137 return self.params.param_get_a_async(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1138 name, category, attr, security_limit, profile_key
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1139 )
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1140
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1141 def _get_params_values_from_category(
3123 130f9cb6e0ab core (memory/params): added `extra` argument to filter out params notably in `getParamsUI`: Goffi <goffi@goffi.org> parents: 3053 diff changeset	1142 self, category, security_limit, app, extra_s, profile_key
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1143 ):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1144 return self.params._get_params_values_from_category(
3123 130f9cb6e0ab core (memory/params): added `extra` argument to filter out params notably in `getParamsUI`: Goffi <goffi@goffi.org> parents: 3053 diff changeset	1145 category, security_limit, app, extra_s, profile_key
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1146 )
1587 698d6755d62a core, bridge (params): added asyncGetParamsValuesFromCategory (yes that's a long name!) method to retrive params names and values for a given category Goffi <goffi@goffi.org> parents: 1586 diff changeset	1147
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1148 def async_get_string_param_a(
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1149 self, name, category, attribute="value", security_limit=C.NO_SECURITY_LIMIT,
3123 130f9cb6e0ab core (memory/params): added `extra` argument to filter out params notably in `getParamsUI`: Goffi <goffi@goffi.org> parents: 3053 diff changeset	1150 profile_key=C.PROF_KEY_NONE):
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1151
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1152 profile = self.get_profile_name(profile_key)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1153 return defer.ensureDeferred(self.params.async_get_string_param_a(
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1154 name, category, attribute, security_limit, profile
3123 130f9cb6e0ab core (memory/params): added `extra` argument to filter out params notably in `getParamsUI`: Goffi <goffi@goffi.org> parents: 3053 diff changeset	1155 ))
130f9cb6e0ab core (memory/params): added `extra` argument to filter out params notably in `getParamsUI`: Goffi <goffi@goffi.org> parents: 3053 diff changeset	1156
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1157 def _get_params_ui(self, security_limit, app, extra_s, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1158 return self.params._get_params_ui(security_limit, app, extra_s, profile_key)
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1159
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1160 def params_categories_get(self):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1161 return self.params.params_categories_get()
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1162
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1163 def param_set(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1164 self,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1165 name,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1166 value,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1167 category,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1168 security_limit=C.NO_SECURITY_LIMIT,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1169 profile_key=C.PROF_KEY_NONE,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1170 ):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1171 return self.params.param_set(name, value, category, security_limit, profile_key)
19 f2a745ca0fbc refactoring: using xml params part III (parameters import) Goffi <goffi@goffi.org> parents: 18 diff changeset	1172
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1173 def update_params(self, xml):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1174 return self.params.update_params(xml)
587 952322b1d490 Remove trailing whitespaces. Emmanuel Gil Peyrot <linkmauve@linkmauve.fr> parents: 574 diff changeset	1175
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1176 def params_register_app(self, xml, security_limit=C.NO_SECURITY_LIMIT, app=""):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1177 return self.params.params_register_app(xml, security_limit, app)
777 5642939d254e core, bridge: new method paramsRegisterApp to register frontend's specific parameters souliane <souliane@mailoo.org> parents: 771 diff changeset	1178
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1179 def set_default(self, name, category, callback, errback=None):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1180 return self.params.set_default(name, category, callback, errback)
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1181
3163 d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1182 ## Private Data ##
d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1183
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1184 def _private_data_set(self, namespace, key, data_s, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1185 client = self.host.get_client(profile_key)
3163 d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1186 # we accept any type
d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1187 data = data_format.deserialise(data_s, type_check=None)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1188 return defer.ensureDeferred(self.storage.set_private_value(
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1189 namespace, key, data, binary=True, profile=client.profile))
3163 d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1190
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1191 def _private_data_get(self, namespace, key, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1192 client = self.host.get_client(profile_key)
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1193 d = defer.ensureDeferred(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1194 self.storage.get_privates(
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1195 namespace, [key], binary=True, profile=client.profile)
888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1196 )
3163 d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1197 d.addCallback(lambda data_dict: data_format.serialise(data_dict.get(key)))
d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1198 return d
d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1199
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1200 def _private_data_delete(self, namespace, key, profile_key):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1201 client = self.host.get_client(profile_key)
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1202 return defer.ensureDeferred(self.storage.del_private_value(
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1203 namespace, key, binary=True, profile=client.profile))
3163 d10b2368684e bridge: added methods to let frontends store/retrieve/delete private data Goffi <goffi@goffi.org> parents: 3160 diff changeset	1204
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1205 ## Files ##
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1206
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1207 def check_file_permission(
3313 624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1208 self,
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1209 file_data: dict,
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1210 peer_jid: Optional[jid.JID],
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1211 perms_to_check: Optional[Tuple[str]],
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1212 set_affiliation: bool = False
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1213 ) -> None:
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1214 """Check that an entity has the right permission on a file
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1215
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1216 @param file_data: data of one file, as returned by get_files
3313 624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1217 @param peer_jid: entity trying to access the file
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1218 @param perms_to_check: permissions to check
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1219 tuple of C.ACCESS_PERM_*
3313 624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1220 @param check_parents: if True, also check all parents until root node
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1221 @parma set_affiliation: if True, "affiliation" metadata will be set
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1222 @raise exceptions.PermissionError: peer_jid doesn't have all permission
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1223 in perms_to_check for file_data
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1224 @raise exceptions.InternalError: perms_to_check is invalid
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1225 """
3313 624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1226 # TODO: knowing if user is owner is not enough, we need to check permission
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1227 # to see if user can modify/delete files, and set corresponding affiliation (publisher, member)
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1228 if peer_jid is None and perms_to_check is None:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1229 return
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1230 peer_jid = peer_jid.userhostJID()
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1231 if peer_jid == file_data["owner"]:
3313 624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1232 if set_affiliation:
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1233 file_data['affiliation'] = 'owner'
624c60293deb memory: new "affiliation" metadata for files: Goffi <goffi@goffi.org> parents: 3300 diff changeset	1234 # the owner has all rights, nothing to check
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1235 return
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1236 if not C.ACCESS_PERMS.issuperset(perms_to_check):
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1237 raise exceptions.InternalError(_("invalid permission"))
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1238
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1239 for perm in perms_to_check:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1240 # we check each perm and raise PermissionError as soon as one condition is not valid
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1241 # we must never return here, we only return after the loop if nothing was blocking the access
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1242 try:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1243 perm_data = file_data["access"][perm]
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1244 perm_type = perm_data["type"]
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1245 except KeyError:
3317 83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1246 # No permission is set.
83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1247 # If we are in a root file/directory, we deny access
83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1248 # otherwise, we use public permission, as the parent directory will
83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1249 # block anyway, this avoid to have to recursively change permissions for
83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1250 # all sub directories/files when modifying a permission
83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1251 if not file_data.get('parent'):
83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1252 raise exceptions.PermissionError()
83f25da66bec core (memory): files are now public by default except for those in root directory: Goffi <goffi@goffi.org> parents: 3313 diff changeset	1253 else:
3349 2a7e36b69fd2 core (memory/memory): fixed assignations Goffi <goffi@goffi.org> parents: 3346 diff changeset	1254 perm_type = C.ACCESS_TYPE_PUBLIC
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1255 if perm_type == C.ACCESS_TYPE_PUBLIC:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1256 continue
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1257 elif perm_type == C.ACCESS_TYPE_WHITELIST:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1258 try:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1259 jids = perm_data["jids"]
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1260 except KeyError:
2926 4cd7545c4ebb core (memory): raise PermissionError directly instead of using failureFailure, as it could not be catched correctly in every case. Goffi <goffi@goffi.org> parents: 2924 diff changeset	1261 raise exceptions.PermissionError()
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1262 if peer_jid.full() in jids:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1263 continue
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1264 else:
2926 4cd7545c4ebb core (memory): raise PermissionError directly instead of using failureFailure, as it could not be catched correctly in every case. Goffi <goffi@goffi.org> parents: 2924 diff changeset	1265 raise exceptions.PermissionError()
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1266 else:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1267 raise exceptions.InternalError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1268 _("unknown access type: {type}").format(type=perm_type)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1269 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1270
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1271 async def check_permission_to_root(self, client, file_data, peer_jid, perms_to_check):
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1272 """do check_file_permission on file_data and all its parents until root"""
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1273 current = file_data
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1274 while True:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1275 self.check_file_permission(current, peer_jid, perms_to_check)
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1276 parent = current["parent"]
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1277 if not parent:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1278 break
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1279 files_data = await self.get_files(
3040 fee60f17ebac jp: jp asyncio port: Goffi <goffi@goffi.org> parents: 3031 diff changeset	1280 client, peer_jid=None, file_id=parent, perms_to_check=None
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1281 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1282 try:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1283 current = files_data[0]
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1284 except IndexError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1285 raise exceptions.DataError("Missing parent")
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1286
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1287 async def _get_parent_dir(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1288 self, client, path, parent, namespace, owner, peer_jid, perms_to_check
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1289 ):
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1290 """Retrieve parent node from a path, or last existing directory
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1291
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1292 each directory of the path will be retrieved, until the last existing one
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1293 @return (tuple[unicode, list[unicode])): parent, remaining path elements:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1294 - parent is the id of the last retrieved directory (or u'' for root)
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1295 - remaining path elements are the directories which have not been retrieved
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1296 (i.e. which don't exist)
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1297 """
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1298 # if path is set, we have to retrieve parent directory of the file(s) from it
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1299 if parent is not None:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1300 raise exceptions.ConflictError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1301 _("You can't use path and parent at the same time")
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1302 )
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1303 path_elts = [_f for _f in path.split("/") if _f]
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1304 if {"..", "."}.intersection(path_elts):
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1305 raise ValueError(_('".." or "." can\'t be used in path'))
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1306
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1307 # we retrieve all directories from path until we get the parent container
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1308 # non existing directories will be created
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1309 parent = ""
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1310 for idx, path_elt in enumerate(path_elts):
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1311 directories = await self.storage.get_files(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1312 client,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1313 parent=parent,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1314 type_=C.FILE_TYPE_DIRECTORY,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1315 name=path_elt,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1316 namespace=namespace,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1317 owner=owner,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1318 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1319 if not directories:
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1320 return (parent, path_elts[idx:])
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1321 # from this point, directories don't exist anymore, we have to create them
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1322 elif len(directories) > 1:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1323 raise exceptions.InternalError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1324 _("Several directories found, this should not happen")
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1325 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1326 else:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1327 directory = directories[0]
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1328 self.check_file_permission(directory, peer_jid, perms_to_check)
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1329 parent = directory["id"]
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1330 return (parent, [])
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1331
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1332 def get_file_affiliations(self, file_data: dict) -> Dict[jid.JID, str]:
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1333 """Convert file access to pubsub like affiliations"""
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1334 affiliations = {}
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1335 access_data = file_data['access']
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1336
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1337 read_data = access_data.get(C.ACCESS_PERM_READ, {})
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1338 if read_data.get('type') == C.ACCESS_TYPE_WHITELIST:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1339 for entity_jid_s in read_data['jids']:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1340 entity_jid = jid.JID(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1341 affiliations[entity_jid] = 'member'
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1342
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1343 write_data = access_data.get(C.ACCESS_PERM_WRITE, {})
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1344 if write_data.get('type') == C.ACCESS_TYPE_WHITELIST:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1345 for entity_jid_s in write_data['jids']:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1346 entity_jid = jid.JID(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1347 affiliations[entity_jid] = 'publisher'
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1348
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1349 owner = file_data.get('owner')
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1350 if owner:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1351 affiliations[owner] = 'owner'
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1352
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1353 return affiliations
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1354
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1355 def _set_file_affiliations_update(
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1356 self,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1357 access: dict,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1358 file_data: dict,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1359 affiliations: Dict[jid.JID, str]
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1360 ) -> None:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1361 read_data = access.setdefault(C.ACCESS_PERM_READ, {})
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1362 if read_data.get('type') != C.ACCESS_TYPE_WHITELIST:
3349 2a7e36b69fd2 core (memory/memory): fixed assignations Goffi <goffi@goffi.org> parents: 3346 diff changeset	1363 read_data['type'] = C.ACCESS_TYPE_WHITELIST
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1364 if 'jids' not in read_data:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1365 read_data['jids'] = []
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1366 read_whitelist = read_data['jids']
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1367 write_data = access.setdefault(C.ACCESS_PERM_WRITE, {})
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1368 if write_data.get('type') != C.ACCESS_TYPE_WHITELIST:
3349 2a7e36b69fd2 core (memory/memory): fixed assignations Goffi <goffi@goffi.org> parents: 3346 diff changeset	1369 write_data['type'] = C.ACCESS_TYPE_WHITELIST
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1370 if 'jids' not in write_data:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1371 write_data['jids'] = []
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1372 write_whitelist = write_data['jids']
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1373 for entity_jid, affiliation in affiliations.items():
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1374 entity_jid_s = entity_jid.full()
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1375 if affiliation == "none":
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1376 try:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1377 read_whitelist.remove(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1378 except ValueError:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1379 log.warning(
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1380 "removing affiliation from an entity without read permission: "
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1381 f"{entity_jid}"
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1382 )
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1383 try:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1384 write_whitelist.remove(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1385 except ValueError:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1386 pass
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1387 elif affiliation == "publisher":
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1388 if entity_jid_s not in read_whitelist:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1389 read_whitelist.append(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1390 if entity_jid_s not in write_whitelist:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1391 write_whitelist.append(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1392 elif affiliation == "member":
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1393 if entity_jid_s not in read_whitelist:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1394 read_whitelist.append(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1395 try:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1396 write_whitelist.remove(entity_jid_s)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1397 except ValueError:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1398 pass
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1399 elif affiliation == "owner":
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1400 raise NotImplementedError('"owner" affiliation can\'t be set')
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1401 else:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1402 raise ValueError(f"unknown affiliation: {affiliation!r}")
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1403
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1404 async def set_file_affiliations(
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1405 self,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1406 client,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1407 file_data: dict,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1408 affiliations: Dict[jid.JID, str]
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1409 ) -> None:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1410 """Apply pubsub like affiliation to file_data
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1411
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1412 Affiliations are converted to access types, then set in a whitelist.
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1413 Affiliation are mapped as follow:
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1414 - "owner" can't be set (for now)
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1415 - "publisher" gives read and write permissions
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1416 - "member" gives read permission only
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1417 - "none" removes both read and write permissions
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1418 """
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1419 file_id = file_data['id']
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1420 await self.file_update(
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1421 file_id,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1422 'access',
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1423 update_cb=partial(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1424 self._set_file_affiliations_update,
3318 460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1425 file_data=file_data,
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1426 affiliations=affiliations
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1427 ),
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1428 )
460606155bec core (memory): `getFileAffiliations` and `setFileAffiliations` implementations: Goffi <goffi@goffi.org> parents: 3317 diff changeset	1429
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1430 def _set_file_access_model_update(
3319 3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1431 self,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1432 access: dict,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1433 file_data: dict,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1434 access_model: str
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1435 ) -> None:
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1436 read_data = access.setdefault(C.ACCESS_PERM_READ, {})
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1437 if access_model == "open":
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1438 requested_type = C.ACCESS_TYPE_PUBLIC
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1439 elif access_model == "whitelist":
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1440 requested_type = C.ACCESS_TYPE_WHITELIST
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1441 else:
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1442 raise ValueError(f"unknown access model: {access_model}")
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1443
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1444 read_data['type'] = requested_type
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1445 if requested_type == C.ACCESS_TYPE_WHITELIST and 'jids' not in read_data:
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1446 read_data['jids'] = []
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1447
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1448 async def set_file_access_model(
3319 3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1449 self,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1450 client,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1451 file_data: dict,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1452 access_model: str,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1453 ) -> None:
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1454 """Apply pubsub like access_model to file_data
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1455
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1456 Only 2 access models are supported so far:
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1457 - "open": set public access to file/dir
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1458 - "whitelist": set whitelist to file/dir
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1459 """
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1460 file_id = file_data['id']
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1461 await self.file_update(
3319 3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1462 file_id,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1463 'access',
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1464 update_cb=partial(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1465 self._set_file_access_model_update,
3319 3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1466 file_data=file_data,
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1467 access_model=access_model
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1468 ),
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1469 )
3a15e76a694e core (memory): `setFileAccessModel` implementation: Goffi <goffi@goffi.org> parents: 3318 diff changeset	1470
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1471 def get_files_owner(
3499 a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1472 self,
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1473 client,
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1474 owner: Optional[jid.JID],
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1475 peer_jid: Optional[jid.JID],
3523 30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1476 file_id: Optional[str] = None,
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1477 parent: Optional[str] = None
3499 a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1478 ) -> jid.JID:
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1479 """Get owner to use for a file operation
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1480
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1481 if owner is not explicitely set, a suitable one will be used (client.jid for
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1482 clients, peer_jid for components).
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1483 @raise exception.InternalError: we are one a component, and neither owner nor
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1484 peer_jid are set
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1485 """
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1486 if owner is not None:
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1487 return owner.userhostJID()
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1488 if client is None:
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1489 # client may be None when looking for file with public_id
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1490 return None
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1491 if file_id or parent:
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1492 # owner has already been filtered on parent file
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1493 return None
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1494 if not client.is_component:
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1495 return client.jid.userhostJID()
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1496 if peer_jid is None:
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1497 raise exceptions.InternalError(
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1498 "Owner must be set for component if peer_jid is None"
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1499 )
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1500 return peer_jid.userhostJID()
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1501
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1502 async def get_files(
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1503 self, client, peer_jid, file_id=None, version=None, parent=None, path=None,
59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1504 type_=None, file_hash=None, hash_algo=None, name=None, namespace=None,
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1505 mime_type=None, public_id=None, owner=None, access=None, projection=None,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1506 unique=False, perms_to_check=(C.ACCESS_PERM_READ,)):
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1507 """Retrieve files with with given filters
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1508
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1509 @param peer_jid(jid.JID, None): jid trying to access the file
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1510 needed to check permission.
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1511 Use None to ignore permission (perms_to_check must be None too)
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1512 @param file_id(unicode, None): id of the file
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1513 None to ignore
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1514 @param version(unicode, None): version of the file
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1515 None to ignore
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1516 empty string to look for current version
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1517 @param parent(unicode, None): id of the directory containing the files
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1518 None to ignore
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1519 empty string to look for root files/directories
3358 b14e95f7034f core (memory/memory): use `str` for `path` in `getFiles` and `setFile` to allow use of `Path` instances Goffi <goffi@goffi.org> parents: 3349 diff changeset	1520 @param path(Path, unicode, None): path to the directory containing the files
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1521 @param type_(unicode, None): type of file filter, can be one of C.FILE_TYPE_*
59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1522 @param file_hash(unicode, None): hash of the file to retrieve
59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1523 @param hash_algo(unicode, None): algorithm use for file_hash
59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1524 @param name(unicode, None): name of the file to retrieve
59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1525 @param namespace(unicode, None): namespace of the files to retrieve
59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1526 @param mime_type(unicode, None): filter on this mime type
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1527 @param public_id(unicode, None): filter on this public id
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1528 @param owner(jid.JID, None): if not None, only get files from this owner
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1529 @param access(dict, None): get file with given access (see [set_file])
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1530 @param projection(list[unicode], None): name of columns to retrieve
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1531 None to retrieve all
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1532 @param unique(bool): if True will remove duplicates
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1533 @param perms_to_check(tuple[unicode],None): permission to check
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1534 must be a tuple of C.ACCESS_PERM_* or None
3499 a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1535 if None, permission will no be checked (peer_jid must be None too in this
a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1536 case)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1537 other params are the same as for [set_file]
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1538 @return (list[dict]): files corresponding to filters
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1539 @raise exceptions.NotFound: parent directory not found (when path is specified)
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1540 @raise exceptions.PermissionError: peer_jid can't use perms_to_check for one of
59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1541 the file
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1542 on the path
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1543 """
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1544 if peer_jid is None and perms_to_check or perms_to_check is None and peer_jid:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1545 raise exceptions.InternalError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1546 "if you want to disable permission check, both peer_jid and "
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1547 "perms_to_check must be None"
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1548 )
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1549 owner = self.get_files_owner(client, owner, peer_jid, file_id, parent)
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1550 if path is not None:
3358 b14e95f7034f core (memory/memory): use `str` for `path` in `getFiles` and `setFile` to allow use of `Path` instances Goffi <goffi@goffi.org> parents: 3349 diff changeset	1551 path = str(path)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1552 # permission are checked by _get_parent_dir
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1553 parent, remaining_path_elts = await self._get_parent_dir(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1554 client, path, parent, namespace, owner, peer_jid, perms_to_check
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1555 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1556 if remaining_path_elts:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1557 # if we have remaining path elements,
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1558 # the parent directory is not found
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1559 raise failure.Failure(exceptions.NotFound())
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1560 if parent and peer_jid:
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1561 # if parent is given directly and permission check is requested,
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1562 # we need to check all the parents
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1563 parent_data = await self.storage.get_files(client, file_id=parent)
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1564 try:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1565 parent_data = parent_data[0]
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1566 except IndexError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1567 raise exceptions.DataError("mising parent")
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1568 await self.check_permission_to_root(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1569 client, parent_data, peer_jid, perms_to_check
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1570 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1571
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1572 files = await self.storage.get_files(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1573 client,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1574 file_id=file_id,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1575 version=version,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1576 parent=parent,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1577 type_=type_,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1578 file_hash=file_hash,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1579 hash_algo=hash_algo,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1580 name=name,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1581 namespace=namespace,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1582 mime_type=mime_type,
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1583 public_id=public_id,
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1584 owner=owner,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1585 access=access,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1586 projection=projection,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1587 unique=unique,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1588 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1589
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1590 if peer_jid:
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1591 # if permission are checked, we must remove all file that user can't access
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1592 to_remove = []
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1593 for file_data in files:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1594 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1595 self.check_file_permission(
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1596 file_data, peer_jid, perms_to_check, set_affiliation=True
888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1597 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1598 except exceptions.PermissionError:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1599 to_remove.append(file_data)
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1600 for file_data in to_remove:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1601 files.remove(file_data)
3541 888109774673 core: various changes and fixes to work with new storage and D-Bus bridge: Goffi <goffi@goffi.org> parents: 3537 diff changeset	1602 return files
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1603
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1604 async def set_file(
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1605 self, client, name, file_id=None, version="", parent=None, path=None,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1606 type_=C.FILE_TYPE_FILE, file_hash=None, hash_algo=None, size=None,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1607 namespace=None, mime_type=None, public_id=None, created=None, modified=None,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1608 owner=None, access=None, extra=None, peer_jid=None,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1609 perms_to_check=(C.ACCESS_PERM_WRITE,)
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1610 ):
2924 59aea54e74a8 memory: minor style change Goffi <goffi@goffi.org> parents: 2909 diff changeset	1611 """Set a file metadata
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1612
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1613 @param name(unicode): basename of the file
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1614 @param file_id(unicode): unique id of the file
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1615 @param version(unicode): version of this file
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1616 empty string for current version or when there is no versioning
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1617 @param parent(unicode, None): id of the directory containing the files
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1618 @param path(unicode, None): virtual path of the file in the namespace
2909 90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1619 if set, parent must be None. All intermediate directories will be created
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1620 if needed, using current access.
3361 43e60c40de65 core (memory/memory): fixed directory creation in setFile Goffi <goffi@goffi.org> parents: 3358 diff changeset	1621 @param type_(str, None): type of file filter, can be one of C.FILE_TYPE_*
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1622 @param file_hash(unicode): unique hash of the payload
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1623 @param hash_algo(unicode): algorithm used for hashing the file (usually sha-256)
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1624 @param size(int): size in bytes
2909 90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1625 @param namespace(unicode, None): identifier (human readable is better) to group
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1626 files
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1627 For instance, namespace could be used to group files in a specific photo album
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1628 @param mime_type(unicode): MIME type of the file, or None if not known/guessed
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1629 @param public_id(unicode): id used to share publicly the file via HTTP
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1630 @param created(int): UNIX time of creation
2909 90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1631 @param modified(int,None): UNIX time of last modification, or None to use
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1632 created date
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1633 @param owner(jid.JID, None): jid of the owner of the file (mainly useful for
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1634 component)
2518 e4de2f16a284 core (memory): use bare jid for owner in setFiles: Goffi <goffi@goffi.org> parents: 2508 diff changeset	1635 will be used to check permission (only bare jid is used, don't use with MUC).
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1636 Use None to ignore permission (perms_to_check must be None too)
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1637 @param access(dict, None): serialisable dictionary with access rules.
2909 90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1638 None (or empty dict) to use private access, i.e. allow only profile's jid to
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1639 access the file
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1640 key can be on on C.ACCESS_PERM_*,
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1641 then a sub dictionary with a type key is used (one of C.ACCESS_TYPE_*).
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1642 According to type, extra keys can be used:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1643 - C.ACCESS_TYPE_PUBLIC: the permission is granted for everybody
2909 90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1644 - C.ACCESS_TYPE_WHITELIST: the permission is granted for jids (as unicode)
90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1645 in the 'jids' key
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1646 will be encoded to json in database
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1647 @param extra(dict, None): serialisable dictionary of any extra data
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1648 will be encoded to json in database
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1649 @param perms_to_check(tuple[unicode],None): permission to check
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1650 must be a tuple of C.ACCESS_PERM_* or None
3499 a83a04b7394b memory: new `getFilesOwner` method: Goffi <goffi@goffi.org> parents: 3480 diff changeset	1651 if None, permission will not be checked (peer_jid must be None too in this
2909 90146552cde5 core (memory), plugin XEP-0329, plugin invitation: minor style improvments Goffi <goffi@goffi.org> parents: 2771 diff changeset	1652 case)
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1653 @param profile(unicode): profile owning the file
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1654 """
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1655 if "/" in name:
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1656 raise ValueError('name must not contain a slash ("/")')
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1657 if file_id is None:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1658 file_id = shortuuid.uuid()
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1659 if (
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1660 file_hash is not None
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1661 and hash_algo is None
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1662 or hash_algo is not None
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1663 and file_hash is None
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1664 ):
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1665 raise ValueError("file_hash and hash_algo must be set at the same time")
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1666 if mime_type is None:
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1667 mime_type, __ = mimetypes.guess_type(name)
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1668 else:
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1669 mime_type = mime_type.lower()
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1670 if public_id is not None:
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1671 assert len(public_id)>0
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1672 if created is None:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1673 created = time.time()
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1674 if namespace is not None:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1675 namespace = namespace.strip() or None
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1676 if type_ == C.FILE_TYPE_DIRECTORY:
3361 43e60c40de65 core (memory/memory): fixed directory creation in setFile Goffi <goffi@goffi.org> parents: 3358 diff changeset	1677 if any((version, file_hash, size, mime_type)):
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1678 raise ValueError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1679 "version, file_hash, size and mime_type can't be set for a directory"
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1680 )
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1681 owner = self.get_files_owner(client, owner, peer_jid, file_id, parent)
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1682
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1683 if path is not None:
3358 b14e95f7034f core (memory/memory): use `str` for `path` in `getFiles` and `setFile` to allow use of `Path` instances Goffi <goffi@goffi.org> parents: 3349 diff changeset	1684 path = str(path)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1685 # _get_parent_dir will check permissions if peer_jid is set, so we use owner
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1686 parent, remaining_path_elts = await self._get_parent_dir(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1687 client, path, parent, namespace, owner, owner, perms_to_check
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1688 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1689 # if remaining directories don't exist, we have to create them
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1690 for new_dir in remaining_path_elts:
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1691 new_dir_id = shortuuid.uuid()
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1692 await self.storage.set_file(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1693 client,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1694 name=new_dir,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1695 file_id=new_dir_id,
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1696 version="",
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1697 parent=parent,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1698 type_=C.FILE_TYPE_DIRECTORY,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1699 namespace=namespace,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1700 created=time.time(),
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1701 owner=owner,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1702 access=access,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1703 extra={},
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1704 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1705 parent = new_dir_id
3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1706 elif parent is None:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1707 parent = ""
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1708
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1709 await self.storage.set_file(
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1710 client,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1711 file_id=file_id,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1712 version=version,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1713 parent=parent,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1714 type_=type_,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1715 file_hash=file_hash,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1716 hash_algo=hash_algo,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1717 name=name,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1718 size=size,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1719 namespace=namespace,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1720 mime_type=mime_type,
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1721 public_id=public_id,
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1722 created=created,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1723 modified=modified,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1724 owner=owner,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1725 access=access,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1726 extra=extra,
56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1727 )
2501 3b67fe672206 core (memory): file metadata handling methods: Goffi <goffi@goffi.org> parents: 2483 diff changeset	1728
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1729 async def file_get_used_space(
3523 30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1730 self,
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1731 client,
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1732 peer_jid: jid.JID,
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1733 owner: Optional[jid.JID] = None
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1734 ) -> int:
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1735 """Get space taken by all files owned by an entity
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1736
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1737 @param peer_jid: entity requesting the size
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1738 @param owner: entity owning the file to check. If None, will be determined by
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1739 get_files_owner
3523 30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1740 @return: size of total space used by files of this owner
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1741 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1742 owner = self.get_files_owner(client, owner, peer_jid)
3523 30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1743 if peer_jid.userhostJID() != owner and client.profile not in self.admins:
30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1744 raise exceptions.PermissionError("You are not allowed to check this size")
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1745 return await self.storage.file_get_used_space(client, owner)
3523 30779935c0aa core (memory, sqlite): new `fileGetUsedSpace` method Goffi <goffi@goffi.org> parents: 3499 diff changeset	1746
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1747 def file_update(self, file_id, column, update_cb):
2926 4cd7545c4ebb core (memory): raise PermissionError directly instead of using failureFailure, as it could not be catched correctly in every case. Goffi <goffi@goffi.org> parents: 2924 diff changeset	1748 """Update a file column taking care of race condition
2526 35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1749
35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1750 access is NOT checked in this method, it must be checked beforehand
35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1751 @param file_id(unicode): id of the file to update
35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1752 @param column(unicode): one of "access" or "extra"
35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1753 @param update_cb(callable): method to update the value of the colum
35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1754 the method will take older value as argument, and must update it in place
35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1755 Note that the callable must be thread-safe
35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1756 """
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1757 return self.storage.file_update(file_id, column, update_cb)
2526 35d591086974 core (memory, sqlite): added fileUpdate method to update "extra" and "access" avoiding race condition Goffi <goffi@goffi.org> parents: 2518 diff changeset	1758
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1759 @defer.inlineCallbacks
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1760 def _delete_file(
3288 780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1761 self,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1762 client,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1763 peer_jid: jid.JID,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1764 recursive: bool,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1765 files_path: Path,
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1766 file_data: dict
780fb8dd07ef core (memory/sqlite): new database schema (v9): Goffi <goffi@goffi.org> parents: 3281 diff changeset	1767 ):
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1768 """Internal method to delete files/directories recursively
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1769
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1770 @param peer_jid(jid.JID): entity requesting the deletion (must be owner of files
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1771 to delete)
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1772 @param recursive(boolean): True if recursive deletion is needed
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1773 @param files_path(unicode): path of the directory containing the actual files
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1774 @param file_data(dict): data of the file to delete
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1775 """
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1776 if file_data['owner'] != peer_jid:
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1777 raise exceptions.PermissionError(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1778 "file {file_name} can't be deleted, {peer_jid} is not the owner"
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1779 .format(file_name=file_data['name'], peer_jid=peer_jid.full()))
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1780 if file_data['type'] == C.FILE_TYPE_DIRECTORY:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1781 sub_files = yield self.get_files(client, peer_jid, parent=file_data['id'])
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1782 if sub_files and not recursive:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1783 raise exceptions.DataError(_("Can't delete directory, it is not empty"))
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1784 # we first delete the sub-files
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1785 for sub_file_data in sub_files:
3300 b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1786 if sub_file_data['type'] == C.FILE_TYPE_DIRECTORY:
b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1787 sub_file_path = files_path / sub_file_data['name']
b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1788 else:
b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1789 sub_file_path = files_path
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1790 yield self._delete_file(
3300 b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1791 client, peer_jid, recursive, sub_file_path, sub_file_data)
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1792 # then the directory itself
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1793 yield self.storage.file_delete(file_data['id'])
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1794 elif file_data['type'] == C.FILE_TYPE_FILE:
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1795 log.info(_("deleting file {name} with hash {file_hash}").format(
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1796 name=file_data['name'], file_hash=file_data['file_hash']))
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1797 yield self.storage.file_delete(file_data['id'])
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1798 references = yield self.get_files(
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1799 client, peer_jid, file_hash=file_data['file_hash'])
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1800 if references:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1801 log.debug("there are still references to the file, we keep it")
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1802 else:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1803 file_path = os.path.join(files_path, file_data['file_hash'])
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1804 log.info(_("no reference left to {file_path}, deleting").format(
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1805 file_path=file_path))
3300 b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1806 try:
b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1807 os.unlink(file_path)
b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1808 except FileNotFoundError:
b56e4c6b13fc core (memory): fixed recursive file deletion + log an error and continue when deleting a missing file Goffi <goffi@goffi.org> parents: 3288 diff changeset	1809 log.error(f"file at {file_path!r} doesn't exist but it was referenced in files database")
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1810 else:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1811 raise exceptions.InternalError('Unexpected file type: {file_type}'
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1812 .format(file_type=file_data['type']))
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1813
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1814 async def file_delete(self, client, peer_jid, file_id, recursive=False):
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1815 """Delete a single file or a directory and all its sub-files
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1816
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1817 @param file_id(unicode): id of the file to delete
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1818 @param peer_jid(jid.JID): entity requesting the deletion,
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1819 must be owner of all files to delete
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1820 @param recursive(boolean): must be True to delete a directory and all sub-files
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1821 """
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1822 # FIXME: we only allow owner of file to delete files for now, but WRITE access
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1823 # should be checked too
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1824 files_data = await self.get_files(client, peer_jid, file_id)
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1825 if not files_data:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1826 raise exceptions.NotFound("Can't find the file with id {file_id}".format(
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1827 file_id=file_id))
c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1828 file_data = files_data[0]
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1829 if file_data["type"] != C.FILE_TYPE_DIRECTORY and recursive:
ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1830 raise ValueError("recursive can only be set for directories")
3932 7af29260ecb8 core: fix and renamed getLocalPath -> get_local_path: Goffi <goffi@goffi.org> parents: 3782 diff changeset	1831 files_path = self.host.get_local_path(None, C.FILES_DIR)
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1832 await self._delete_file(client, peer_jid, recursive, files_path, file_data)
2928 c0f6fd75af5f core (memory, memory/sqlite): implemented fileDelete Goffi <goffi@goffi.org> parents: 2926 diff changeset	1833
3371 e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1834 ## Cache ##
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1835
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1836 def get_cache_path(self, namespace: str, *args: str) -> Path:
3371 e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1837 """Get path to use to get a common path for a namespace
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1838
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1839 This can be used by plugins to manage permanent data. It's the responsability
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1840 of plugins to clean this directory from unused data.
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1841 @param namespace: unique namespace to use
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1842 @param args: extra identifier which will be added to the path
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1843 """
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1844 namespace = namespace.strip().lower()
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1845 return Path(
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1846 self._cache_path,
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1847 regex.path_escape(namespace),
524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1848 *(regex.path_escape(a) for a in args)
3371 e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1849 )
e8d74ac7c479 core (memory/memory): added `getCachePath` method to get a cache dir from a namespace. Goffi <goffi@goffi.org> parents: 3364 diff changeset	1850
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1851 ## Misc ##
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1852
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1853 def is_entity_available(self, client, entity_jid):
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1854 """Tell from the presence information if the given entity is available.
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1855
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1856 @param entity_jid (JID): the entity to check (if bare jid is used, all resources are tested)
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1857 @return (bool): True if entity is available
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1858 """
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1859 if not entity_jid.resource:
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1860 return bool(
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1861 self.get_available_resources(client, entity_jid)
2624 56f94936df1e code style reformatting using black Goffi <goffi@goffi.org> parents: 2597 diff changeset	1862 ) # is any resource is available, entity is available
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1863 try:
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1864 presence_data = self.get_entity_datum(client, entity_jid, "presence")
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1865 except KeyError:
3028 ab2696e34d29 Python 3 port: Goffi <goffi@goffi.org> parents: 2994 diff changeset	1866 log.debug("No presence information for {}".format(entity_jid))
1290 faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1867 return False
faa1129559b8 core, frontends: refactoring to base Libervia on QuickFrontend (big mixed commit): Goffi <goffi@goffi.org> parents: 1263 diff changeset	1868 return presence_data.show != C.PRESENCE_UNAVAILABLE
3777 001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1869
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1870 def is_admin(self, profile: str) -> bool:
3777 001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1871 """Tell if given profile has administrator privileges"""
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1872 return profile in self.admins
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1873
4037 524856bd7b19 massive refactoring to switch from camelCase to snake_case: Goffi <goffi@goffi.org> parents: 3932 diff changeset	1874 def is_admin_jid(self, entity: jid.JID) -> bool:
3777 001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1875 """Tells if an entity jid correspond to an admin one
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1876
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1877 It is sometime not possible to use the profile alone to check if an entity is an
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1878 admin (e.g. a request managed by a component). In this case we check if the JID
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1879 correspond to an admin profile
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1880 """
001ea5f4a2f9 core: method to know if a profile/entity is an admin: Goffi <goffi@goffi.org> parents: 3582 diff changeset	1881 return entity.userhostJID() in self.admin_jids

Mercurial > libervia-backend

annotate libervia/backend/memory/memory.py @ 4094:c3b68fdc2de7