YunoHost/yunohost
1
0
Fork 0
mirror of https://github.com/YunoHost/yunohost.git synced 2024-09-03 20:06:10 +02:00
Code Issues Projects Releases Packages Wiki Activity

Add semantic of YunohostValidationError for all exceptions which are related to validating stuff

Browse source
This commit is contained in:
Alexandre Aubin 2021-03-11 01:39:52 +01:00
parent b85d959d7e
commit 01ccab5252
19 changed files with 187 additions and 178 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

74
src/yunohost/app.py
View file

@ -54,7 +54,7 @@ from moulinette.utils.filesystem import (
from yunohost.service import service_status, _run_service_command
from yunohost.utils import packages
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from yunohost.log import is_unit_operation, OperationLogger
logger = getActionLogger("yunohost.app")
@ -192,7 +192,7 @@ def app_info(app, full=False):
from yunohost.permission import user_permission_list
if not _is_installed(app):
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app, all_apps=_get_all_installed_apps_id()
)
@ -321,7 +321,7 @@ def app_map(app=None, raw=False, user=None):
if app is not None:
if not _is_installed(app):
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app, all_apps=_get_all_installed_apps_id()
)
apps = [
@ -421,14 +421,14 @@ def app_change_url(operation_logger, app, domain, path):
installed = _is_installed(app)
if not installed:
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app, all_apps=_get_all_installed_apps_id()
)
if not os.path.exists(
os.path.join(APPS_SETTING_PATH, app, "scripts", "change_url")
):
raise YunohostError("app_change_url_no_script", app_name=app)
raise YunohostValidationError("app_change_url_no_script", app_name=app)
old_domain = app_setting(app, "domain")
old_path = app_setting(app, "path")
@ -438,7 +438,7 @@ def app_change_url(operation_logger, app, domain, path):
domain, path = _normalize_domain_path(domain, path)
if (domain, path) == (old_domain, old_path):
raise YunohostError(
raise YunohostValidationError(
"app_change_url_identical_domains", domain=domain, path=path
)
@ -551,12 +551,12 @@ def app_upgrade(app=[], url=None, file=None, force=False):
# Abort if any of those app is in fact not installed..
for app in [app_ for app_ in apps if not _is_installed(app_)]:
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app, all_apps=_get_all_installed_apps_id()
)
if len(apps) == 0:
raise YunohostError("apps_already_up_to_date")
raise YunohostValidationError("apps_already_up_to_date")
if len(apps) > 1:
logger.info(m18n.n("app_upgrade_several_apps", apps=", ".join(apps)))
@ -880,11 +880,11 @@ def app_install(
confirm_install("thirdparty")
manifest, extracted_app_folder = _extract_app_from_file(app)
else:
raise YunohostError("app_unknown")
raise YunohostValidationError("app_unknown")
# Check ID
if "id" not in manifest or "__" in manifest["id"]:
raise YunohostError("app_id_invalid")
raise YunohostValidationError("app_id_invalid")
app_id = manifest["id"]
label = label if label else manifest["name"]
@ -897,7 +897,7 @@ def app_install(
instance_number = _installed_instance_number(app_id, last=True) + 1
if instance_number > 1:
if "multi_instance" not in manifest or not is_true(manifest["multi_instance"]):
raise YunohostError("app_already_installed", app=app_id)
raise YunohostValidationError("app_already_installed", app=app_id)
# Change app_id to the forked app id
app_instance_name = app_id + "__" + str(instance_number)
@ -1209,7 +1209,7 @@ def app_remove(operation_logger, app):
)
if not _is_installed(app):
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app, all_apps=_get_all_installed_apps_id()
)
@ -1372,10 +1372,10 @@ def app_makedefault(operation_logger, app, domain=None):
domain = app_domain
operation_logger.related_to.append(("domain", domain))
elif domain not in domain_list()["domains"]:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
if "/" in app_map(raw=True)[domain]:
raise YunohostError(
raise YunohostValidationError(
"app_make_default_location_already_used",
app=app,
domain=app_domain,
@ -1578,7 +1578,7 @@ def app_register_url(app, domain, path):
if _is_installed(app):
settings = _get_app_settings(app)
if "path" in settings.keys() and "domain" in settings.keys():
raise YunohostError("app_already_installed_cant_change_url")
raise YunohostValidationError("app_already_installed_cant_change_url")
# Check the url is available
_assert_no_conflicting_apps(domain, path)
@ -1694,7 +1694,7 @@ def app_change_label(app, new_label):
installed = _is_installed(app)
if not installed:
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app, all_apps=_get_all_installed_apps_id()
)
logger.warning(m18n.n("app_label_deprecated"))
@ -1730,7 +1730,7 @@ def app_action_run(operation_logger, app, action, args=None):
actions = {x["id"]: x for x in actions}
if action not in actions:
raise YunohostError(
raise YunohostValidationError(
"action '%s' not available for app '%s', available actions are: %s"
% (action, app, ", ".join(actions.keys())),
raw_msg=True,
@ -1884,7 +1884,7 @@ def app_config_apply(operation_logger, app, args):
installed = _is_installed(app)
if not installed:
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app, all_apps=_get_all_installed_apps_id()
)
@ -2199,7 +2199,7 @@ def _get_app_settings(app_id):
"""
if not _is_installed(app_id):
raise YunohostError(
raise YunohostValidationError(
"app_not_installed", app=app_id, all_apps=_get_all_installed_apps_id()
)
try:
@ -2546,9 +2546,9 @@ def _fetch_app_from_git(app):
app_id, _ = _parse_app_instance_name(app)
if app_id not in app_dict:
raise YunohostError("app_unknown")
raise YunohostValidationError("app_unknown")
elif "git" not in app_dict[app_id]:
raise YunohostError("app_unsupported_remote_type")
raise YunohostValidationError("app_unsupported_remote_type")
app_info = app_dict[app_id]
url = app_info["git"]["url"]
@ -2684,7 +2684,7 @@ def _check_manifest_requirements(manifest, app_instance_name):
packaging_format = int(manifest.get("packaging_format", 0))
if packaging_format not in [0, 1]:
raise YunohostError("app_packaging_format_not_supported")
raise YunohostValidationError("app_packaging_format_not_supported")
requirements = manifest.get("requirements", dict())
@ -2697,7 +2697,7 @@ def _check_manifest_requirements(manifest, app_instance_name):
for pkgname, spec in requirements.items():
if not packages.meets_version_specifier(pkgname, spec):
version = packages.ynh_packages_version()[pkgname]["version"]
raise YunohostError(
raise YunohostValidationError(
"app_requirements_unmeet",
pkgname=pkgname,
version=version,
@ -2796,7 +2796,7 @@ class YunoHostArgumentFormatParser(object):
# we don't have an answer, check optional and default_value
if question.value is None or question.value == "":
if not question.optional and question.default is None:
raise YunohostError("app_argument_required", name=question.name)
raise YunohostValidationError("app_argument_required", name=question.name)
else:
question.value = (
getattr(self, "default_value", None)
@ -2816,7 +2816,7 @@ class YunoHostArgumentFormatParser(object):
return (question.value, self.argument_type)
def _raise_invalid_answer(self, question):
raise YunohostError(
raise YunohostValidationError(
"app_argument_choice_invalid",
name=question.name,
choices=", ".join(question.choices),
@ -2854,13 +2854,13 @@ class PasswordArgumentParser(YunoHostArgumentFormatParser):
)
if question.default is not None:
raise YunohostError("app_argument_password_no_default", name=question.name)
raise YunohostValidationError("app_argument_password_no_default", name=question.name)
return question
def _post_parse_value(self, question):
if any(char in question.value for char in self.forbidden_chars):
raise YunohostError(
raise YunohostValidationError(
"pattern_password_app", forbidden_chars=self.forbidden_chars
)
@ -2913,7 +2913,7 @@ class BooleanArgumentParser(YunoHostArgumentFormatParser):
if str(question.value).lower() in ["0", "no", "n", "false"]:
return 0
raise YunohostError(
raise YunohostValidationError(
"app_argument_choice_invalid",
name=question.name,
choices="yes, no, y, n, 1, 0",
@ -2938,7 +2938,7 @@ class DomainArgumentParser(YunoHostArgumentFormatParser):
return question
def _raise_invalid_answer(self, question):
raise YunohostError(
raise YunohostValidationError(
"app_argument_invalid", name=question.name, error=m18n.n("domain_unknown")
)
@ -2964,7 +2964,7 @@ class UserArgumentParser(YunoHostArgumentFormatParser):
return question
def _raise_invalid_answer(self, question):
raise YunohostError(
raise YunohostValidationError(
"app_argument_invalid",
name=question.name,
error=m18n.n("user_unknown", user=question.value),
@ -2992,7 +2992,7 @@ class NumberArgumentParser(YunoHostArgumentFormatParser):
if isinstance(question.value, str) and question.value.isdigit():
return int(question.value)
raise YunohostError(
raise YunohostValidationError(
"app_argument_invalid", name=question.name, error=m18n.n("invalid_number")
)
@ -3123,7 +3123,7 @@ def _get_conflicting_apps(domain, path, ignore_app=None):
# Abort if domain is unknown
if domain not in domain_list()["domains"]:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
# Fetch apps map
apps_map = app_map(raw=True)
@ -3162,9 +3162,9 @@ def _assert_no_conflicting_apps(domain, path, ignore_app=None, full_domain=False
)
if full_domain:
raise YunohostError("app_full_domain_unavailable", domain=domain)
raise YunohostValidationError("app_full_domain_unavailable", domain=domain)
else:
raise YunohostError("app_location_unavailable", apps="\n".join(apps))
raise YunohostValidationError("app_location_unavailable", apps="\n".join(apps))
def _make_environment_for_app_script(app, args={}, args_prefix="APP_ARG_"):
@ -3469,7 +3469,7 @@ def _assert_system_is_sane_for_app(manifest, when):
faulty_services = [s for s in services if service_status(s)["status"] != "running"]
if faulty_services:
if when == "pre":
raise YunohostError(
raise YunohostValidationError(
"app_action_cannot_be_ran_because_required_services_down",
services=", ".join(faulty_services),
)
@ -3480,7 +3480,7 @@ def _assert_system_is_sane_for_app(manifest, when):
if packages.dpkg_is_broken():
if when == "pre":
raise YunohostError("dpkg_is_broken")
raise YunohostValidationError("dpkg_is_broken")
elif when == "post":
raise YunohostError("this_action_broke_dpkg")
@ -3659,7 +3659,7 @@ def _patch_legacy_helpers(app_folder):
# couldn't patch the deprecated helper in the previous lines. In
# that case, abort the install or whichever step is performed
if helper in content and infos["important"]:
raise YunohostError(
raise YunohostValidationError(
"This app is likely pretty old and uses deprecated / outdated helpers that can't be migrated easily. It can't be installed anymore.",
raw_msg=True,
)

28
src/yunohost/backup.py
View file

@ -348,7 +348,7 @@ class BackupManager:
# Try to recursively unmount stuff (from a previously failed backup ?)
if not _recursive_umount(self.work_dir):
raise YunohostError("backup_output_directory_not_empty")
raise YunohostValidationError("backup_output_directory_not_empty")
else:
# If umount succeeded, remove the directory (we checked that
# we're in /home/yunohost.backup/tmp so that should be okay...
@ -1027,7 +1027,7 @@ class RestoreManager:
already_installed = [app for app in to_be_restored if _is_installed(app)]
if already_installed != []:
if already_installed == to_be_restored:
raise YunohostError(
raise YunohostValidationError(
"restore_already_installed_apps", apps=", ".join(already_installed)
)
else:
@ -1133,14 +1133,14 @@ class RestoreManager:
return True
elif free_space > needed_space:
# TODO Add --force options to avoid the error raising
raise YunohostError(
raise YunohostValidationError(
"restore_may_be_not_enough_disk_space",
free_space=free_space,
needed_space=needed_space,
margin=margin,
)
else:
raise YunohostError(
raise YunohostValidationError(
"restore_not_enough_disk_space",
free_space=free_space,
needed_space=needed_space,
@ -1729,7 +1729,7 @@ class BackupMethod(object):
free_space,
backup_size,
)
raise YunohostError("not_enough_disk_space", path=self.repo)
raise YunohostValidationError("not_enough_disk_space", path=self.repo)
def _organize_files(self):
"""
@ -2186,7 +2186,7 @@ def backup_create(
# Validate there is no archive with the same name
if name and name in backup_list()["archives"]:
raise YunohostError("backup_archive_name_exists")
raise YunohostValidationError("backup_archive_name_exists")
# By default we backup using the tar method
if not methods:
@ -2201,14 +2201,14 @@ def backup_create(
r"^/(|(bin|boot|dev|etc|lib|root|run|sbin|sys|usr|var)(|/.*))$",
output_directory,
):
raise YunohostError("backup_output_directory_forbidden")
raise YunohostValidationError("backup_output_directory_forbidden")
if "copy" in methods:
if not output_directory:
raise YunohostError("backup_output_directory_required")
raise YunohostValidationError("backup_output_directory_required")
# Check that output directory is empty
elif os.path.isdir(output_directory) and os.listdir(output_directory):
raise YunohostError("backup_output_directory_not_empty")
raise YunohostValidationError("backup_output_directory_not_empty")
# If no --system or --apps given, backup everything
if system is None and apps is None:
@ -2381,7 +2381,7 @@ def backup_download(name):
if not os.path.lexists(archive_file):
archive_file += ".gz"
if not os.path.lexists(archive_file):
raise YunohostError("backup_archive_name_unknown", name=name)
raise YunohostValidationError("backup_archive_name_unknown", name=name)
# If symlink, retrieve the real path
if os.path.islink(archive_file):
@ -2389,7 +2389,7 @@ def backup_download(name):
# Raise exception if link is broken (e.g. on unmounted external storage)
if not os.path.exists(archive_file):
raise YunohostError("backup_archive_broken_link", path=archive_file)
raise YunohostValidationError("backup_archive_broken_link", path=archive_file)
# We return a raw bottle HTTPresponse (instead of serializable data like
# list/dict, ...), which is gonna be picked and used directly by moulinette
@ -2415,7 +2415,7 @@ def backup_info(name, with_details=False, human_readable=False):
if not os.path.lexists(archive_file):
archive_file += ".gz"
if not os.path.lexists(archive_file):
raise YunohostError("backup_archive_name_unknown", name=name)
raise YunohostValidationError("backup_archive_name_unknown", name=name)
# If symlink, retrieve the real path
if os.path.islink(archive_file):
@ -2423,7 +2423,7 @@ def backup_info(name, with_details=False, human_readable=False):
# Raise exception if link is broken (e.g. on unmounted external storage)
if not os.path.exists(archive_file):
raise YunohostError("backup_archive_broken_link", path=archive_file)
raise YunohostValidationError("backup_archive_broken_link", path=archive_file)
info_file = "%s/%s.info.json" % (ARCHIVES_PATH, name)
@ -2531,7 +2531,7 @@ def backup_delete(name):
"""
if name not in backup_list()["archives"]:
raise YunohostError("backup_archive_name_unknown", name=name)
raise YunohostValidationError("backup_archive_name_unknown", name=name)
hook_callback("pre_backup_delete", args=[name])

24
src/yunohost/certificate.py
View file

@ -37,7 +37,7 @@ from moulinette.utils.log import getActionLogger
from moulinette.utils.filesystem import read_file
from yunohost.vendor.acme_tiny.acme_tiny import get_crt as sign_certificate
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from yunohost.utils.network import get_public_ip
from yunohost.diagnosis import Diagnoser
@ -90,7 +90,7 @@ def certificate_status(domain_list, full=False):
for domain in domain_list:
# Is it in Yunohost domain list?
if domain not in yunohost_domains_list:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
certificates = {}
@ -166,7 +166,7 @@ def _certificate_install_selfsigned(domain_list, force=False):
status = _get_status(domain)
if status["summary"]["code"] in ("good", "great"):
raise YunohostError(
raise YunohostValidationError(
"certmanager_attempt_to_replace_valid_cert", domain=domain
)
@ -267,12 +267,12 @@ def _certificate_install_letsencrypt(
for domain in domain_list:
yunohost_domains_list = yunohost.domain.domain_list()["domains"]
if domain not in yunohost_domains_list:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
# Is it self-signed?
status = _get_status(domain)
if not force and status["CA_type"]["code"] != "self-signed":
raise YunohostError(
raise YunohostValidationError(
"certmanager_domain_cert_not_selfsigned", domain=domain
)
@ -370,25 +370,25 @@ def certificate_renew(
# Is it in Yunohost dmomain list?
if domain not in yunohost.domain.domain_list()["domains"]:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
status = _get_status(domain)
# Does it expire soon?
if status["validity"] > VALIDITY_LIMIT and not force:
raise YunohostError(
raise YunohostValidationError(
"certmanager_attempt_to_renew_valid_cert", domain=domain
)
# Does it have a Let's Encrypt cert?
if status["CA_type"]["code"] != "lets-encrypt":
raise YunohostError(
raise YunohostValidationError(
"certmanager_attempt_to_renew_nonLE_cert", domain=domain
)
# Check ACME challenge configured for given domain
if not _check_acme_challenge_configuration(domain):
raise YunohostError(
raise YunohostValidationError(
"certmanager_acme_not_configured_for_domain", domain=domain
)
@ -898,20 +898,20 @@ def _check_domain_is_ready_for_ACME(domain):
)
if not dnsrecords or not httpreachable:
raise YunohostError("certmanager_domain_not_diagnosed_yet", domain=domain)
raise YunohostValidationError("certmanager_domain_not_diagnosed_yet", domain=domain)
# Check if IP from DNS matches public IP
if not dnsrecords.get("status") in [
"SUCCESS",
"WARNING",
]: # Warning is for missing IPv6 record which ain't critical for ACME
raise YunohostError(
raise YunohostValidationError(
"certmanager_domain_dns_ip_differs_from_public_ip", domain=domain
)
# Check if domain seems to be accessible through HTTP?
if not httpreachable.get("status") == "SUCCESS":
raise YunohostError("certmanager_domain_http_not_working", domain=domain)
raise YunohostValidationError("certmanager_domain_http_not_working", domain=domain)
# FIXME / TODO : ideally this should not be needed. There should be a proper

4
src/yunohost/data_migrations/0017_postgresql_9p6_to_11.py
View file

@ -23,7 +23,7 @@ class MyMigration(Migration):
return
if not self.package_is_installed("postgresql-11"):
raise YunohostError("migration_0017_postgresql_11_not_installed")
raise YunohostValidationError("migration_0017_postgresql_11_not_installed")
# Make sure there's a 9.6 cluster
try:
@ -37,7 +37,7 @@ class MyMigration(Migration):
if not space_used_by_directory(
"/var/lib/postgresql/9.6"
) > free_space_in_directory("/var/lib/postgresql"):
raise YunohostError(
raise YunohostValidationError(
"migration_0017_not_enough_space", path="/var/lib/postgresql/"
)

18
src/yunohost/diagnosis.py
View file

@ -37,7 +37,7 @@ from moulinette.utils.filesystem import (
write_to_yaml,
)
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from yunohost.hook import hook_list, hook_exec
logger = log.getActionLogger("yunohost.diagnosis")
@ -59,11 +59,11 @@ def diagnosis_get(category, item):
all_categories_names = [c for c, _ in all_categories]
if category not in all_categories_names:
raise YunohostError("diagnosis_unknown_categories", categories=category)
raise YunohostValidationError("diagnosis_unknown_categories", categories=category)
if isinstance(item, list):
if any("=" not in criteria for criteria in item):
raise YunohostError(
raise YunohostValidationError(
"Criterias should be of the form key=value (e.g. domain=yolo.test)"
)
@ -91,7 +91,7 @@ def diagnosis_show(
else:
unknown_categories = [c for c in categories if c not in all_categories_names]
if unknown_categories:
raise YunohostError(
raise YunohostValidationError(
"diagnosis_unknown_categories", categories=", ".join(unknown_categories)
)
@ -181,7 +181,7 @@ def diagnosis_run(
else:
unknown_categories = [c for c in categories if c not in all_categories_names]
if unknown_categories:
raise YunohostError(
raise YunohostValidationError(
"diagnosis_unknown_categories", categories=", ".join(unknown_categories)
)
@ -270,14 +270,14 @@ def diagnosis_ignore(add_filter=None, remove_filter=None, list=False):
# Sanity checks for the provided arguments
if len(filter_) == 0:
raise YunohostError(
raise YunohostValidationError(
"You should provide at least one criteria being the diagnosis category to ignore"
)
category = filter_[0]
if category not in all_categories_names:
raise YunohostError("%s is not a diagnosis category" % category)
raise YunohostValidationError("%s is not a diagnosis category" % category)
if any("=" not in criteria for criteria in filter_[1:]):
raise YunohostError(
raise YunohostValidationError(
"Criterias should be of the form key=value (e.g. domain=yolo.test)"
)
@ -331,7 +331,7 @@ def diagnosis_ignore(add_filter=None, remove_filter=None, list=False):
configuration["ignore_filters"][category] = []
if criterias not in configuration["ignore_filters"][category]:
raise YunohostError("This filter does not exists.")
raise YunohostValidationError("This filter does not exists.")
configuration["ignore_filters"][category].remove(criterias)
_diagnosis_write_configuration(configuration)

29
src/yunohost/domain.py
View file

@ -101,16 +101,14 @@ def domain_add(operation_logger, domain, dyndns=False):
from yunohost.utils.ldap import _get_ldap_interface
if domain.startswith("xmpp-upload."):
raise YunohostError("domain_cannot_add_xmpp_upload")
raise YunohostValidationError("domain_cannot_add_xmpp_upload")
ldap = _get_ldap_interface()
try:
ldap.validate_uniqueness({"virtualdomain": domain})
except MoulinetteError:
raise YunohostError("domain_exists")
operation_logger.start()
raise YunohostValidationError("domain_exists")
# Lower domain to avoid some edge cases issues
# See: https://forum.yunohost.org/t/invalid-domain-causes-diagnosis-web-to-fail-fr-on-demand/11765
@ -119,17 +117,21 @@ def domain_add(operation_logger, domain, dyndns=False):
# DynDNS domain
if dyndns:
from yunohost.dyndns import dyndns_subscribe, _dyndns_provides, _guess_current_dyndns_domain
from yunohost.dyndns import _dyndns_provides, _guess_current_dyndns_domain
# Do not allow to subscribe to multiple dyndns domains...
if _guess_current_dyndns_domain("dyndns.yunohost.org") != (None, None):
raise YunohostError('domain_dyndns_already_subscribed')
raise YunohostValidationError('domain_dyndns_already_subscribed')
# Check that this domain can effectively be provided by
# dyndns.yunohost.org. (i.e. is it a nohost.me / noho.st)
if not _dyndns_provides("dyndns.yunohost.org", domain):
raise YunohostError("domain_dyndns_root_unknown")
raise YunohostValidationError("domain_dyndns_root_unknown")
operation_logger.start()
if dyndns:
from yunohost.dyndns import dndns_subscribe
# Actually subscribe
dyndns_subscribe(domain=domain)
@ -197,7 +199,7 @@ def domain_remove(operation_logger, domain, remove_apps=False, force=False):
# we don't want to check the domain exists because the ldap add may have
# failed
if not force and domain not in domain_list()['domains']:
raise YunohostError('domain_name_unknown', domain=domain)
raise YunohostValidationError('domain_name_unknown', domain=domain)
# Check domain is not the main domain
if domain == _get_maindomain():
@ -205,13 +207,13 @@ def domain_remove(operation_logger, domain, remove_apps=False, force=False):
other_domains.remove(domain)
if other_domains:
raise YunohostError(
raise YunohostValidationError(
"domain_cannot_remove_main",
domain=domain,
other_domains="\n * " + ("\n * ".join(other_domains)),
)
else:
raise YunohostError("domain_cannot_remove_main_add_new_one", domain=domain)
raise YunohostValidationError("domain_cannot_remove_main_add_new_one", domain=domain)
# Check if apps are installed on the domain
apps_on_that_domain = []
@ -234,9 +236,10 @@ def domain_remove(operation_logger, domain, remove_apps=False, force=False):
for app, _ in apps_on_that_domain:
app_remove(app)
else:
raise YunohostError('domain_uninstall_app_first', apps="\n".join([x[1] for x in apps_on_that_domain]))
raise YunohostValidationError('domain_uninstall_app_first', apps="\n".join([x[1] for x in apps_on_that_domain]))
operation_logger.start()
ldap = _get_ldap_interface()
try:
ldap.remove("virtualdomain=" + domain + ",ou=domains")
@ -288,7 +291,7 @@ def domain_dns_conf(domain, ttl=None):
"""
if domain not in domain_list()["domains"]:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
ttl = 3600 if ttl is None else ttl
@ -345,7 +348,7 @@ def domain_main_domain(operation_logger, new_main_domain=None):
# Check domain exists
if new_main_domain not in domain_list()["domains"]:
raise YunohostError("domain_name_unknown", domain=new_main_domain)
raise YunohostValidationError("domain_name_unknown", domain=new_main_domain)
operation_logger.related_to.append(("domain", new_main_domain))
operation_logger.start()

12
src/yunohost/dyndns.py
View file

@ -36,7 +36,7 @@ from moulinette.utils.log import getActionLogger
from moulinette.utils.filesystem import write_to_file, read_file
from moulinette.utils.network import download_json
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from yunohost.domain import _get_maindomain, _build_dns_conf
from yunohost.utils.network import get_public_ip, dig
from yunohost.log import is_unit_operation
@ -124,7 +124,7 @@ def dyndns_subscribe(
"""
if _guess_current_dyndns_domain(subscribe_host) != (None, None):
raise YunohostError('domain_dyndns_already_subscribed')
raise YunohostValidationError('domain_dyndns_already_subscribed')
if domain is None:
domain = _get_maindomain()
@ -132,13 +132,13 @@ def dyndns_subscribe(
# Verify if domain is provided by subscribe_host
if not _dyndns_provides(subscribe_host, domain):
raise YunohostError(
raise YunohostValidationError(
"dyndns_domain_not_provided", domain=domain, provider=subscribe_host
)
# Verify if domain is available
if not _dyndns_available(subscribe_host, domain):
raise YunohostError("dyndns_unavailable", domain=domain)
raise YunohostValidationError("dyndns_unavailable", domain=domain)
operation_logger.start()
@ -231,7 +231,7 @@ def dyndns_update(
(domain, key) = _guess_current_dyndns_domain(dyn_host)
if domain is None:
raise YunohostError('dyndns_no_domain_registered')
raise YunohostValidationError('dyndns_no_domain_registered')
# If key is not given, pick the first file we find with the domain given
else:
@ -239,7 +239,7 @@ def dyndns_update(
keys = glob.glob("/etc/yunohost/dyndns/K{0}.+*.private".format(domain))
if not keys:
raise YunohostError("dyndns_key_not_found")
raise YunohostValidationError("dyndns_key_not_found")
key = keys[0]

4
src/yunohost/firewall.py
View file

@ -28,7 +28,7 @@ import yaml
import miniupnpc
from moulinette import m18n
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from moulinette.utils import process
from moulinette.utils.log import getActionLogger
from moulinette.utils.text import prependlines
@ -366,7 +366,7 @@ def firewall_upnp(action="status", no_refresh=False):
if action == "status":
no_refresh = True
else:
raise YunohostError("action_invalid", action=action)
raise YunohostValidationError("action_invalid", action=action)
# Refresh port mapping using UPnP
if not no_refresh:

8
src/yunohost/hook.py
View file

@ -32,7 +32,7 @@ from glob import iglob
from importlib import import_module
from moulinette import m18n, msettings
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from moulinette.utils import log
from moulinette.utils.filesystem import read_json
@ -117,7 +117,7 @@ def hook_info(action, name):
)
if not hooks:
raise YunohostError("hook_name_unknown", name=name)
raise YunohostValidationError("hook_name_unknown", name=name)
return {
"action": action,
"name": name,
@ -186,7 +186,7 @@ def hook_list(action, list_by="name", show_info=False):
d.add(name)
else:
raise YunohostError("hook_list_by_invalid")
raise YunohostValidationError("hook_list_by_invalid")
def _append_folder(d, folder):
# Iterate over and add hook from a folder
@ -273,7 +273,7 @@ def hook_callback(
try:
hl = hooks_names[n]
except KeyError:
raise YunohostError("hook_name_unknown", n)
raise YunohostValidationError("hook_name_unknown", n)
# Iterate over hooks with this name
for h in hl:
# Update hooks dict

2
src/yunohost/log.py
View file

@ -191,7 +191,7 @@ def log_show(
log_path = base_path + LOG_FILE_EXT
if not os.path.exists(md_path) and not os.path.exists(log_path):
raise YunohostError("log_does_exists", log=path)
raise YunohostValidationError("log_does_exists", log=path)
infos = {}

24
src/yunohost/permission.py
View file

@ -31,7 +31,7 @@ import random
from moulinette import m18n
from moulinette.utils.log import getActionLogger
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from yunohost.log import is_unit_operation
logger = getActionLogger("yunohost.user")
@ -175,14 +175,14 @@ def user_permission_update(
# Refuse to add "visitors" to mail, xmpp ... they require an account to make sense.
if add and "visitors" in add and permission.split(".")[0] in SYSTEM_PERMS:
raise YunohostError("permission_require_account", permission=permission)
raise YunohostValidationError("permission_require_account", permission=permission)
# Refuse to add "visitors" to protected permission
if (
(add and "visitors" in add and existing_permission["protected"])
or (remove and "visitors" in remove and existing_permission["protected"])
) and not force:
raise YunohostError("permission_protected", permission=permission)
raise YunohostValidationError("permission_protected", permission=permission)
# Fetch currently allowed groups for this permission
@ -198,7 +198,7 @@ def user_permission_update(
groups_to_add = [add] if not isinstance(add, list) else add
for group in groups_to_add:
if group not in all_existing_groups:
raise YunohostError("group_unknown", group=group)
raise YunohostValidationError("group_unknown", group=group)
if group in current_allowed_groups:
logger.warning(
m18n.n(
@ -326,7 +326,7 @@ def user_permission_info(permission):
permission, None
)
if existing_permission is None:
raise YunohostError("permission_not_found", permission=permission)
raise YunohostValidationError("permission_not_found", permission=permission)
return existing_permission
@ -391,7 +391,7 @@ def permission_create(
if ldap.get_conflict(
{"cn": permission}, base_dn="ou=permission,dc=yunohost,dc=org"
):
raise YunohostError("permission_already_exist", permission=permission)
raise YunohostValidationError("permission_already_exist", permission=permission)
# Get random GID
all_gid = {x.gr_gid for x in grp.getgrall()}
@ -427,7 +427,7 @@ def permission_create(
all_existing_groups = user_group_list()["groups"].keys()
for group in allowed or []:
if group not in all_existing_groups:
raise YunohostError("group_unknown", group=group)
raise YunohostValidationError("group_unknown", group=group)
operation_logger.related_to.append(("app", permission.split(".")[0]))
operation_logger.start()
@ -594,7 +594,7 @@ def permission_delete(operation_logger, permission, force=False, sync_perm=True)
permission = permission + ".main"
if permission.endswith(".main") and not force:
raise YunohostError("permission_cannot_remove_main")
raise YunohostValidationError("permission_cannot_remove_main")
from yunohost.utils.ldap import _get_ldap_interface
@ -861,7 +861,7 @@ def _validate_and_sanitize_permission_url(url, app_base_path, app):
try:
re.compile(regex)
except Exception:
raise YunohostError("invalid_regex", regex=regex)
raise YunohostValidationError("invalid_regex", regex=regex)
if url.startswith("re:"):
@ -874,12 +874,12 @@ def _validate_and_sanitize_permission_url(url, app_base_path, app):
# regex with domain
if "/" not in url:
raise YunohostError("regex_with_only_domain")
raise YunohostValidationError("regex_with_only_domain")
domain, path = url[3:].split("/", 1)
path = "/" + path
if domain.replace("%", "").replace("\\", "") not in domains:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
validate_regex(path)
@ -914,7 +914,7 @@ def _validate_and_sanitize_permission_url(url, app_base_path, app):
sanitized_url = domain + path
if domain not in domains:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
_assert_no_conflicting_apps(domain, path, ignore_app=app)

12
src/yunohost/service.py
View file

@ -34,7 +34,7 @@ from glob import glob
from datetime import datetime
from moulinette import m18n
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from moulinette.utils.process import check_output
from moulinette.utils.log import getActionLogger
from moulinette.utils.filesystem import read_file, append_to_file, write_to_file
@ -145,7 +145,7 @@ def service_remove(name):
services = _get_services()
if name not in services:
raise YunohostError("service_unknown", service=name)
raise YunohostValidationError("service_unknown", service=name)
del services[name]
try:
@ -325,7 +325,7 @@ def service_status(names=[]):
# Validate service names requested
for name in names:
if name not in services.keys():
raise YunohostError("service_unknown", service=name)
raise YunohostValidationError("service_unknown", service=name)
# Filter only requested servivces
services = {k: v for k, v in services.items() if k in names}
@ -484,7 +484,7 @@ def service_log(name, number=50):
number = int(number)
if name not in services.keys():
raise YunohostError("service_unknown", service=name)
raise YunohostValidationError("service_unknown", service=name)
log_list = services[name].get("log", [])
@ -545,7 +545,7 @@ def service_regen_conf(
for name in names:
if name not in services.keys():
raise YunohostError("service_unknown", service=name)
raise YunohostValidationError("service_unknown", service=name)
if names is []:
names = list(services.keys())
@ -568,7 +568,7 @@ def _run_service_command(action, service):
"""
services = _get_services()
if service not in services.keys():
raise YunohostError("service_unknown", service=service)
raise YunohostValidationError("service_unknown", service=service)
possible_actions = [
"start",

22
src/yunohost/settings.py
View file

@ -6,7 +6,7 @@ from datetime import datetime
from collections import OrderedDict
from moulinette import m18n
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from moulinette.utils.log import getActionLogger
from yunohost.regenconf import regen_conf
@ -109,7 +109,7 @@ def settings_get(key, full=False):
settings = _get_settings()
if key not in settings:
raise YunohostError("global_settings_key_doesnt_exists", settings_key=key)
raise YunohostValidationError("global_settings_key_doesnt_exists", settings_key=key)
if full:
return settings[key]
@ -137,7 +137,7 @@ def settings_set(key, value):
settings = _get_settings()
if key not in settings:
raise YunohostError("global_settings_key_doesnt_exists", settings_key=key)
raise YunohostValidationError("global_settings_key_doesnt_exists", settings_key=key)
key_type = settings[key]["type"]
@ -146,7 +146,7 @@ def settings_set(key, value):
if boolean_value[0]:
value = boolean_value[1]
else:
raise YunohostError(
raise YunohostValidationError(
"global_settings_bad_type_for_setting",
setting=key,
received_type=type(value).__name__,
@ -158,14 +158,14 @@ def settings_set(key, value):
try:
value = int(value)
except Exception:
raise YunohostError(
raise YunohostValidationError(
"global_settings_bad_type_for_setting",
setting=key,
received_type=type(value).__name__,
expected_type=key_type,
)
else:
raise YunohostError(
raise YunohostValidationError(
"global_settings_bad_type_for_setting",
setting=key,
received_type=type(value).__name__,
@ -173,7 +173,7 @@ def settings_set(key, value):
)
elif key_type == "string":
if not isinstance(value, str):
raise YunohostError(
raise YunohostValidationError(
"global_settings_bad_type_for_setting",
setting=key,
received_type=type(value).__name__,
@ -181,14 +181,14 @@ def settings_set(key, value):
)
elif key_type == "enum":
if value not in settings[key]["choices"]:
raise YunohostError(
raise YunohostValidationError(
"global_settings_bad_choice_for_enum",
setting=key,
choice=str(value),
available_choices=", ".join(settings[key]["choices"]),
)
else:
raise YunohostError(
raise YunohostValidationError(
"global_settings_unknown_type", setting=key, unknown_type=key_type
)
@ -214,7 +214,7 @@ def settings_reset(key):
settings = _get_settings()
if key not in settings:
raise YunohostError("global_settings_key_doesnt_exists", settings_key=key)
raise YunohostValidationError("global_settings_key_doesnt_exists", settings_key=key)
settings[key]["value"] = settings[key]["default"]
_save_settings(settings)
@ -304,7 +304,7 @@ def _get_settings():
)
unknown_settings[key] = value
except Exception as e:
raise YunohostError("global_settings_cant_open_settings", reason=e)
raise YunohostValidationError("global_settings_cant_open_settings", reason=e)
if unknown_settings:
try:

6
src/yunohost/ssh.py
View file

@ -5,7 +5,7 @@ import os
import pwd
import subprocess
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from moulinette.utils.filesystem import read_file, write_to_file, chown, chmod, mkdir
SSHD_CONFIG_PATH = "/etc/ssh/sshd_config"
@ -21,7 +21,7 @@ def user_ssh_allow(username):
# TODO it would be good to support different kind of shells
if not _get_user_for_ssh(username):
raise YunohostError("user_unknown", user=username)
raise YunohostValidationError("user_unknown", user=username)
from yunohost.utils.ldap import _get_ldap_interface
@ -43,7 +43,7 @@ def user_ssh_disallow(username):
# TODO it would be good to support different kind of shells
if not _get_user_for_ssh(username):
raise YunohostError("user_unknown", user=username)
raise YunohostValidationError("user_unknown", user=username)
from yunohost.utils.ldap import _get_ldap_interface

36
src/yunohost/tools.py
View file

@ -51,7 +51,7 @@ from yunohost.utils.packages import (
_list_upgradable_apt_packages,
ynh_packages_version,
)
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from yunohost.log import is_unit_operation, OperationLogger
# FIXME this is a duplicate from apps.py
@ -156,7 +156,7 @@ def tools_adminpw(new_password, check_strength=True):
# UNIX seems to not like password longer than 127 chars ...
# e.g. SSH login gets broken (or even 'su admin' when entering the password)
if len(new_password) >= 127:
raise YunohostError("admin_password_too_long")
raise YunohostValidationError("admin_password_too_long")
new_hash = _hash_user_password(new_password)
@ -285,10 +285,10 @@ def tools_postinstall(
# Do some checks at first
if os.path.isfile("/etc/yunohost/installed"):
raise YunohostError("yunohost_already_installed")
raise YunohostValidationError("yunohost_already_installed")
if os.path.isdir("/etc/yunohost/apps") and os.listdir("/etc/yunohost/apps") != []:
raise YunohostError(
raise YunohostValidationError(
"It looks like you're trying to re-postinstall a system that was already working previously ... If you recently had some bug or issues with your installation, please first discuss with the team on how to fix the situation instead of savagely re-running the postinstall ...",
raw_msg=True,
)
@ -301,7 +301,7 @@ def tools_postinstall(
)
GB = 1024 ** 3
if not force_diskspace and main_space < 10 * GB:
raise YunohostError("postinstall_low_rootfsspace")
raise YunohostValidationError("postinstall_low_rootfsspace")
# Check password
if not force_password:
@ -331,14 +331,14 @@ def tools_postinstall(
dyndns = True
# If not, abort the postinstall
else:
raise YunohostError("dyndns_unavailable", domain=domain)
raise YunohostValidationError("dyndns_unavailable", domain=domain)
else:
dyndns = False
else:
dyndns = False
if os.system("iptables -V >/dev/null 2>/dev/null") != 0:
raise YunohostError(
raise YunohostValidationError(
"iptables/nftables does not seems to be working on your setup. You may be in a container or your kernel does have the proper modules loaded. Sometimes, rebooting the machine may solve the issue.",
raw_msg=True,
)
@ -530,17 +530,17 @@ def tools_upgrade(
from yunohost.utils import packages
if packages.dpkg_is_broken():
raise YunohostError("dpkg_is_broken")
raise YunohostValidationError("dpkg_is_broken")
# Check for obvious conflict with other dpkg/apt commands already running in parallel
if not packages.dpkg_lock_available():
raise YunohostError("dpkg_lock_not_available")
raise YunohostValidationError("dpkg_lock_not_available")
if system is not False and apps is not None:
raise YunohostError("tools_upgrade_cant_both")
raise YunohostValidationError("tools_upgrade_cant_both")
if system is False and apps is None:
raise YunohostError("tools_upgrade_at_least_one")
raise YunohostValidationError("tools_upgrade_at_least_one")
#
# Apps
@ -825,7 +825,7 @@ def tools_migrations_list(pending=False, done=False):
# Check for option conflict
if pending and done:
raise YunohostError("migrations_list_conflict_pending_done")
raise YunohostValidationError("migrations_list_conflict_pending_done")
# Get all migrations
migrations = _get_migrations_list()
@ -875,17 +875,17 @@ def tools_migrations_run(
if m.id == target or m.name == target or m.id.split("_")[0] == target:
return m
raise YunohostError("migrations_no_such_migration", id=target)
raise YunohostValidationError("migrations_no_such_migration", id=target)
# auto, skip and force are exclusive options
if auto + skip + force_rerun > 1:
raise YunohostError("migrations_exclusive_options")
raise YunohostValidationError("migrations_exclusive_options")
# If no target specified
if not targets:
# skip, revert or force require explicit targets
if skip or force_rerun:
raise YunohostError("migrations_must_provide_explicit_targets")
raise YunohostValidationError("migrations_must_provide_explicit_targets")
# Otherwise, targets are all pending migrations
targets = [m for m in all_migrations if m.state == "pending"]
@ -897,11 +897,11 @@ def tools_migrations_run(
pending = [t.id for t in targets if t.state == "pending"]
if skip and done:
raise YunohostError("migrations_not_pending_cant_skip", ids=", ".join(done))
raise YunohostValidationError("migrations_not_pending_cant_skip", ids=", ".join(done))
if force_rerun and pending:
raise YunohostError("migrations_pending_cant_rerun", ids=", ".join(pending))
raise YunohostValidationError("migrations_pending_cant_rerun", ids=", ".join(pending))
if not (skip or force_rerun) and done:
raise YunohostError("migrations_already_ran", ids=", ".join(done))
raise YunohostValidationError("migrations_already_ran", ids=", ".join(done))
# So, is there actually something to do ?
if not targets:

52
src/yunohost/user.py
View file

@ -37,7 +37,7 @@ from moulinette import msignals, msettings, m18n
from moulinette.utils.log import getActionLogger
from moulinette.utils.process import check_output
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostError, YunohostValidationError
from yunohost.service import service_status
from yunohost.log import is_unit_operation
@ -125,7 +125,7 @@ def user_create(
# Validate domain used for email address/xmpp account
if domain is None:
if msettings.get("interface") == "api":
raise YunohostError("Invalide usage, specify domain argument")
raise YunohostValidationError("Invalid usage, you should specify a domain argument")
else:
# On affiche les differents domaines possibles
msignals.display(m18n.n("domains_available"))
@ -141,24 +141,24 @@ def user_create(
# Check that the domain exists
if domain not in domain_list()["domains"]:
raise YunohostError("domain_name_unknown", domain=domain)
raise YunohostValidationError("domain_name_unknown", domain=domain)
mail = username + "@" + domain
ldap = _get_ldap_interface()
if username in user_list()["users"]:
raise YunohostError("user_already_exists", user=username)
raise YunohostValidationError("user_already_exists", user=username)
# Validate uniqueness of username and mail in LDAP
try:
ldap.validate_uniqueness({"uid": username, "mail": mail, "cn": username})
except Exception as e:
raise YunohostError("user_creation_failed", user=username, error=e)
raise YunohostValidationError("user_creation_failed", user=username, error=e)
# Validate uniqueness of username in system users
all_existing_usernames = {x.pw_name for x in pwd.getpwall()}
if username in all_existing_usernames:
raise YunohostError("system_username_exists")
raise YunohostValidationError("system_username_exists")
main_domain = _get_maindomain()
aliases = [
@ -170,7 +170,7 @@ def user_create(
]
if mail in aliases:
raise YunohostError("mail_unavailable")
raise YunohostValidationError("mail_unavailable")
operation_logger.start()
@ -264,7 +264,7 @@ def user_delete(operation_logger, username, purge=False):
from yunohost.utils.ldap import _get_ldap_interface
if username not in user_list()["users"]:
raise YunohostError("user_unknown", user=username)
raise YunohostValidationError("user_unknown", user=username)
operation_logger.start()
@ -347,7 +347,7 @@ def user_update(
attrs=attrs_to_fetch,
)
if not result:
raise YunohostError("user_unknown", user=username)
raise YunohostValidationError("user_unknown", user=username)
user = result[0]
env_dict = {"YNH_USER_USERNAME": username}
@ -396,13 +396,13 @@ def user_update(
try:
ldap.validate_uniqueness({"mail": mail})
except Exception as e:
raise YunohostError("user_update_failed", user=username, error=e)
raise YunohostValidationError("user_update_failed", user=username, error=e)
if mail[mail.find("@") + 1 :] not in domains:
raise YunohostError(
raise YunohostValidationError(
"mail_domain_unknown", domain=mail[mail.find("@") + 1 :]
)
if mail in aliases:
raise YunohostError("mail_unavailable")
raise YunohostValidationError("mail_unavailable")
del user["mail"][0]
new_attr_dict["mail"] = [mail] + user["mail"]
@ -414,9 +414,9 @@ def user_update(
try:
ldap.validate_uniqueness({"mail": mail})
except Exception as e:
raise YunohostError("user_update_failed", user=username, error=e)
raise YunohostValidationError("user_update_failed", user=username, error=e)
if mail[mail.find("@") + 1 :] not in domains:
raise YunohostError(
raise YunohostValidationError(
"mail_domain_unknown", domain=mail[mail.find("@") + 1 :]
)
user["mail"].append(mail)
@ -429,7 +429,7 @@ def user_update(
if len(user["mail"]) > 1 and mail in user["mail"][1:]:
user["mail"].remove(mail)
else:
raise YunohostError("mail_alias_remove_failed", mail=mail)
raise YunohostValidationError("mail_alias_remove_failed", mail=mail)
new_attr_dict["mail"] = user["mail"]
if "mail" in new_attr_dict:
@ -451,7 +451,7 @@ def user_update(
if len(user["maildrop"]) > 1 and mail in user["maildrop"][1:]:
user["maildrop"].remove(mail)
else:
raise YunohostError("mail_forward_remove_failed", mail=mail)
raise YunohostValidationError("mail_forward_remove_failed", mail=mail)
new_attr_dict["maildrop"] = user["maildrop"]
if "maildrop" in new_attr_dict:
@ -500,7 +500,7 @@ def user_info(username):
if result:
user = result[0]
else:
raise YunohostError("user_unknown", user=username)
raise YunohostValidationError("user_unknown", user=username)
result_dict = {
"username": user["uid"][0],
@ -638,7 +638,7 @@ def user_group_create(
{"cn": groupname}, base_dn="ou=groups,dc=yunohost,dc=org"
)
if conflict:
raise YunohostError("group_already_exist", group=groupname)
raise YunohostValidationError("group_already_exist", group=groupname)
# Validate uniqueness of groupname in system group
all_existing_groupnames = {x.gr_name for x in grp.getgrall()}
@ -651,7 +651,7 @@ def user_group_create(
"sed --in-place '/^%s:/d' /etc/group" % groupname, shell=True
)
else:
raise YunohostError("group_already_exist_on_system", group=groupname)
raise YunohostValidationError("group_already_exist_on_system", group=groupname)
if not gid:
# Get random GID
@ -705,7 +705,7 @@ def user_group_delete(operation_logger, groupname, force=False, sync_perm=True):
existing_groups = list(user_group_list()["groups"].keys())
if groupname not in existing_groups:
raise YunohostError("group_unknown", group=groupname)
raise YunohostValidationError("group_unknown", group=groupname)
# Refuse to delete primary groups of a user (e.g. group 'sam' related to user 'sam')
# without the force option...
@ -714,7 +714,7 @@ def user_group_delete(operation_logger, groupname, force=False, sync_perm=True):
existing_users = list(user_list()["users"].keys())
undeletable_groups = existing_users + ["all_users", "visitors"]
if groupname in undeletable_groups and not force:
raise YunohostError("group_cannot_be_deleted", group=groupname)
raise YunohostValidationError("group_cannot_be_deleted", group=groupname)
operation_logger.start()
ldap = _get_ldap_interface()
@ -756,11 +756,11 @@ def user_group_update(
# We also can't edit "all_users" without the force option because that's a special group...
if not force:
if groupname == "all_users":
raise YunohostError("group_cannot_edit_all_users")
raise YunohostValidationError("group_cannot_edit_all_users")
elif groupname == "visitors":
raise YunohostError("group_cannot_edit_visitors")
raise YunohostValidationError("group_cannot_edit_visitors")
elif groupname in existing_users:
raise YunohostError("group_cannot_edit_primary_group", group=groupname)
raise YunohostValidationError("group_cannot_edit_primary_group", group=groupname)
# We extract the uid for each member of the group to keep a simple flat list of members
current_group = user_group_info(groupname)["members"]
@ -771,7 +771,7 @@ def user_group_update(
for user in users_to_add:
if user not in existing_users:
raise YunohostError("user_unknown", user=user)
raise YunohostValidationError("user_unknown", user=user)
if user in current_group:
logger.warning(
@ -843,7 +843,7 @@ def user_group_info(groupname):
)
if not result:
raise YunohostError("group_unknown", group=groupname)
raise YunohostValidationError("group_unknown", group=groupname)
infos = result[0]

4
src/yunohost/utils/error.py
View file

@ -49,3 +49,7 @@ class YunohostError(MoulinetteError):
return super(YunohostError, self).content()
else:
return {"error": self.strerror, "log_ref": self.log_ref}
class YunohostValidationError(YunohostError):
pass

4
src/yunohost/utils/password.py
View file

@ -90,11 +90,11 @@ class PasswordValidator(object):
# on top (at least not the moulinette ones)
# because the moulinette needs to be correctly initialized
# as well as modules available in python's path.
from yunohost.utils.error import YunohostError
from yunohost.utils.error import YunohostValidationError
status, msg = self.validation_summary(password)
if status == "error":
raise YunohostError(msg)
raise YunohostValidationError(msg)
def validation_summary(self, password):
"""

2
tests/test_i18n_keys.py
View file

@ -25,9 +25,11 @@ def find_expected_string_keys():
# Try to find :
# m18n.n( "foo"
# YunohostError("foo"
# YunohostValidationError("foo"
# # i18n: foo
p1 = re.compile(r"m18n\.n\(\n*\s*[\"\'](\w+)[\"\']")
p2 = re.compile(r"YunohostError\(\n*\s*[\'\"](\w+)[\'\"]")
p2 = re.compile(r"YunohostValidationError\(\n*\s*[\'\"](\w+)[\'\"]")
p3 = re.compile(r"# i18n: [\'\"]?(\w+)[\'\"]?")
python_files = glob.glob("src/yunohost/*.py")