From 4ba309a2217389622f0362f5b10e550e2180b88e Mon Sep 17 00:00:00 2001
From: Irina LAMBLA <irina@singularity.fr>
Date: Fri, 7 Dec 2018 23:56:57 +0100
Subject: [PATCH] modif MoulinetteError to YunohostError

---
 src/yunohost/app.py                           | 132 +++++++++---------
 src/yunohost/backup.py                        |  82 +++++------
 src/yunohost/certificate.py                   |  42 +++---
 .../0002_migrate_to_tsig_sha256.py            |   8 +-
 .../0003_migrate_to_stretch.py                |  12 +-
 .../0005_postgresql_9p4_to_9p6.py             |   6 +-
 .../0006_sync_admin_and_root_passwords.py     |   2 +-
 src/yunohost/domain.py                        |  22 +--
 src/yunohost/dyndns.py                        |  26 ++--
 src/yunohost/firewall.py                      |  10 +-
 src/yunohost/hook.py                          |  16 +--
 src/yunohost/log.py                           |   6 +-
 src/yunohost/monitor.py                       |  26 ++--
 src/yunohost/service.py                       |  26 ++--
 src/yunohost/settings.py                      |  24 ++--
 src/yunohost/ssh.py                           |   6 +-
 src/yunohost/tests/test_appslist.py           |  12 +-
 src/yunohost/tests/test_appurl.py             |   8 +-
 src/yunohost/tests/test_backuprestore.py      |  23 +--
 src/yunohost/tests/test_changeurl.py          |   4 +-
 src/yunohost/tests/test_settings.py           |  28 ++--
 src/yunohost/tools.py                         |  38 ++---
 src/yunohost/user.py                          |  36 ++---
 src/yunohost/utils/error.py                   |   1 +
 src/yunohost/utils/password.py                |   4 +-
 src/yunohost/utils/yunopaste.py               |   8 +-
 26 files changed, 305 insertions(+), 303 deletions(-)

diff --git a/src/yunohost/app.py b/src/yunohost/app.py
index 96c235835..f4e48de45 100644
--- a/src/yunohost/app.py
+++ b/src/yunohost/app.py
@@ -39,7 +39,7 @@ from collections import OrderedDict
 from datetime import datetime
 
 from moulinette import msignals, m18n, msettings
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import read_json
 
@@ -125,12 +125,12 @@ def app_fetchlist(url=None, name=None):
             appslists_to_be_fetched = [name]
             operation_logger.success()
         else:
-            raise MoulinetteError('custom_appslist_name_required')
+            raise YunohostError('custom_appslist_name_required')
 
     # If a name is given, look for an appslist with that name and fetch it
     elif name is not None:
         if name not in appslists.keys():
-            raise MoulinetteError('appslist_unknown', appslist=name)
+            raise YunohostError('appslist_unknown', appslist=name)
         else:
             appslists_to_be_fetched = [name]
 
@@ -184,7 +184,7 @@ def app_fetchlist(url=None, name=None):
             with open(list_file, "w") as f:
                 f.write(appslist)
         except Exception as e:
-            raise MoulinetteError("Error while writing appslist %s: %s" % (name, str(e)))
+            raise YunohostError("Error while writing appslist %s: %s" % (name, str(e)))
 
         now = int(time.time())
         appslists[name]["lastUpdate"] = now
@@ -208,7 +208,7 @@ def app_removelist(operation_logger, name):
 
     # Make sure we know this appslist
     if name not in appslists.keys():
-        raise MoulinetteError('appslist_unknown', appslist=name)
+        raise YunohostError('appslist_unknown', appslist=name)
 
     operation_logger.start()
 
@@ -339,7 +339,7 @@ def app_info(app, show_status=False, raw=False):
 
     """
     if not _is_installed(app):
-        raise MoulinetteError('app_not_installed', app=app)
+        raise YunohostError('app_not_installed', app=app)
 
     app_setting_path = APPS_SETTING_PATH + app
 
@@ -397,7 +397,7 @@ def app_map(app=None, raw=False, user=None):
 
     if app is not None:
         if not _is_installed(app):
-            raise MoulinetteError('app_not_installed', app=app)
+            raise YunohostError('app_not_installed', app=app)
         apps = [app, ]
     else:
         apps = os.listdir(APPS_SETTING_PATH)
@@ -449,10 +449,10 @@ def app_change_url(operation_logger, auth, app, domain, path):
 
     installed = _is_installed(app)
     if not installed:
-        raise MoulinetteError('app_not_installed', app=app)
+        raise YunohostError('app_not_installed', app=app)
 
     if not os.path.exists(os.path.join(APPS_SETTING_PATH, app, "scripts", "change_url")):
-        raise MoulinetteError("app_change_no_change_url_script", app_name=app)
+        raise YunohostError("app_change_no_change_url_script", app_name=app)
 
     old_domain = app_setting(app, "domain")
     old_path = app_setting(app, "path")
@@ -464,7 +464,7 @@ def app_change_url(operation_logger, auth, app, domain, path):
     path = normalize_url_path(path)
 
     if (domain, path) == (old_domain, old_path):
-        raise MoulinetteError("app_change_url_identical_domains", domain=domain, path=path)
+        raise YunohostError("app_change_url_identical_domains", domain=domain, path=path)
 
     # WARNING / FIXME : checkurl will modify the settings
     # (this is a non intuitive behavior that should be changed)
@@ -540,7 +540,7 @@ def app_change_url(operation_logger, auth, app, domain, path):
                                                stderr=subprocess.STDOUT,
                                                shell=True).rstrip()
 
-        raise MoulinetteError("app_change_url_failed_nginx_reload", nginx_errors=nginx_errors)
+        raise YunohostError("app_change_url_failed_nginx_reload", nginx_errors=nginx_errors)
 
     logger.success(m18n.n("app_change_url_success",
                          app=app, domain=domain, path=path))
@@ -565,8 +565,8 @@ def app_upgrade(auth, app=[], url=None, file=None):
 
     try:
         app_list()
-    except MoulinetteError:
-        raise MoulinetteError('app_no_upgrade')
+    except YunohostError:
+        raise YunohostError('app_no_upgrade')
 
     upgraded_apps = []
 
@@ -586,7 +586,7 @@ def app_upgrade(auth, app=[], url=None, file=None):
         logger.info(m18n.n('app_upgrade_app_name', app=app_instance_name))
         installed = _is_installed(app_instance_name)
         if not installed:
-            raise MoulinetteError('app_not_installed', app=app_instance_name)
+            raise YunohostError('app_not_installed', app=app_instance_name)
 
         if app_instance_name in upgraded_apps:
             continue
@@ -676,7 +676,7 @@ def app_upgrade(auth, app=[], url=None, file=None):
             operation_logger.success()
 
     if not upgraded_apps:
-        raise MoulinetteError('app_no_upgrade')
+        raise YunohostError('app_no_upgrade')
 
     app_ssowatconf(auth)
 
@@ -722,12 +722,12 @@ def app_install(operation_logger, auth, app, label=None, args=None, no_remove_on
     elif os.path.exists(app):
         manifest, extracted_app_folder = _extract_app_from_file(app)
     else:
-        raise MoulinetteError('app_unknown')
+        raise YunohostError('app_unknown')
     status['remote'] = manifest.get('remote', {})
 
     # Check ID
     if 'id' not in manifest or '__' in manifest['id']:
-        raise MoulinetteError('app_id_invalid')
+        raise YunohostError('app_id_invalid')
 
     app_id = manifest['id']
 
@@ -738,7 +738,7 @@ def app_install(operation_logger, auth, app, label=None, args=None, no_remove_on
     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 MoulinetteError('app_already_installed', app=app_id)
+            raise YunohostError('app_already_installed', app=app_id)
 
         # Change app_id to the forked app id
         app_instance_name = app_id + '__' + str(instance_number)
@@ -841,9 +841,9 @@ def app_install(operation_logger, auth, app, label=None, args=None, no_remove_on
 
             if install_retcode == -1:
                 msg = m18n.n('operation_interrupted') + " " + error_msg
-                raise MoulinetteError(msg)
+                raise YunohostError(msg)
             msg = error_msg
-            raise MoulinetteError(msg)
+            raise YunohostError(msg)
 
     # Clean hooks and add new ones
     hook_remove(app_instance_name)
@@ -879,7 +879,7 @@ def app_remove(operation_logger, auth, app):
     """
     from yunohost.hook import hook_exec, hook_remove, hook_callback
     if not _is_installed(app):
-        raise MoulinetteError('app_not_installed', app=app)
+        raise YunohostError('app_not_installed', app=app)
 
     operation_logger.start()
 
@@ -969,7 +969,7 @@ def app_addaccess(auth, apps, users=[]):
                 if allowed_user not in allowed_users:
                     try:
                         user_info(auth, allowed_user)
-                    except MoulinetteError:
+                    except YunohostError:
                         logger.warning(m18n.n('user_unknown', user=allowed_user))
                         continue
                     allowed_users.add(allowed_user)
@@ -1129,17 +1129,17 @@ def app_makedefault(operation_logger, auth, app, domain=None):
         domain = app_domain
         operation_logger.related_to.append(('domain',domain))
     elif domain not in domain_list(auth)['domains']:
-        raise MoulinetteError('domain_unknown')
+        raise YunohostError('domain_unknown')
 
     operation_logger.start()
     if '/' in app_map(raw=True)[domain]:
-        raise MoulinetteError('app_make_default_location_already_used', app=app, domain=app_domain, other_app=app_map(raw=True)[domain]["/"]["id"])
+        raise YunohostError('app_make_default_location_already_used', app=app, domain=app_domain, other_app=app_map(raw=True)[domain]["/"]["id"])
 
     try:
         with open('/etc/ssowat/conf.json.persistent') as json_conf:
             ssowat_conf = json.loads(str(json_conf.read()))
     except ValueError as e:
-        raise MoulinetteError('ssowat_persistent_conf_read_error', error=e.strerror)
+        raise YunohostError('ssowat_persistent_conf_read_error', error=e.strerror)
     except IOError:
         ssowat_conf = {}
 
@@ -1152,7 +1152,7 @@ def app_makedefault(operation_logger, auth, app, domain=None):
         with open('/etc/ssowat/conf.json.persistent', 'w+') as f:
             json.dump(ssowat_conf, f, sort_keys=True, indent=4)
     except IOError as e:
-        raise MoulinetteError('ssowat_persistent_conf_write_error', error=e.strerror)
+        raise YunohostError('ssowat_persistent_conf_write_error', error=e.strerror)
 
     os.system('chmod 644 /etc/ssowat/conf.json.persistent')
 
@@ -1204,7 +1204,7 @@ def app_checkport(port):
     if tools_port_available(port):
         logger.success(m18n.n('port_available', port=int(port)))
     else:
-        raise MoulinetteError('port_unavailable', port=int(port))
+        raise YunohostError('port_unavailable', port=int(port))
 
 
 def app_register_url(auth, app, domain, path):
@@ -1231,7 +1231,7 @@ def app_register_url(auth, app, domain, path):
     if installed:
         settings = _get_app_settings(app)
         if "path" in settings.keys() and "domain" in settings.keys():
-            raise MoulinetteError('app_already_installed_cant_change_url')
+            raise YunohostError('app_already_installed_cant_change_url')
 
     # Check the url is available
     conflicts = _get_conflicting_apps(auth, domain, path)
@@ -1245,7 +1245,7 @@ def app_register_url(auth, app, domain, path):
                 app_label=app_label,
             ))
 
-        raise MoulinetteError('app_location_unavailable', apps="\n".join(apps))
+        raise YunohostError('app_location_unavailable', apps="\n".join(apps))
 
     app_setting(app, 'domain', value=domain)
     app_setting(app, 'path', value=path)
@@ -1283,7 +1283,7 @@ def app_checkurl(auth, url, app=None):
     apps_map = app_map(raw=True)
 
     if domain not in domain_list(auth)['domains']:
-        raise MoulinetteError('domain_unknown')
+        raise YunohostError('domain_unknown')
 
     if domain in apps_map:
         # Loop through apps
@@ -1293,10 +1293,10 @@ def app_checkurl(auth, url, app=None):
                 installed = True
                 continue
             if path == p:
-                raise MoulinetteError('app_location_already_used', app=a["id"], path=path)
+                raise YunohostError('app_location_already_used', app=a["id"], path=path)
             # can't install "/a/b/" if "/a/" exists
             elif path.startswith(p) or p.startswith(path):
-                raise MoulinetteError('app_location_install_failed', other_path=p, other_app=a['id'])
+                raise YunohostError('app_location_install_failed', other_path=p, other_app=a['id'])
 
     if app is not None and not installed:
         app_setting(app, 'domain', value=domain)
@@ -1328,10 +1328,10 @@ def app_initdb(user, password=None, db=None, sql=None):
     mysql_root_pwd = open('/etc/yunohost/mysql').read().rstrip()
     mysql_command = 'mysql -u root -p%s -e "CREATE DATABASE %s ; GRANT ALL PRIVILEGES ON %s.* TO \'%s\'@localhost IDENTIFIED BY \'%s\';"' % (mysql_root_pwd, db, db, user, password)
     if os.system(mysql_command) != 0:
-        raise MoulinetteError('mysql_db_creation_failed')
+        raise YunohostError('mysql_db_creation_failed')
     if sql is not None:
         if os.system('mysql -u %s -p%s %s < %s' % (user, password, db, sql)) != 0:
-            raise MoulinetteError('mysql_db_init_failed')
+            raise YunohostError('mysql_db_init_failed')
 
     if return_pwd:
         return password
@@ -1437,7 +1437,7 @@ def app_ssowatconf(auth):
 def app_change_label(auth, app, new_label):
     installed = _is_installed(app)
     if not installed:
-        raise MoulinetteError('app_not_installed', app=app)
+        raise YunohostError('app_not_installed', app=app)
 
     app_setting(app, "label", value=new_label)
 
@@ -1473,7 +1473,7 @@ def app_action_run(app, action, args=None):
     actions = {x["id"]: x for x in actions}
 
     if action not in actions:
-        raise MoulinetteError("action '%s' not available for app '%s', available actions are: %s" % (action, app, ", ".join(actions.keys())))
+        raise YunohostError("action '%s' not available for app '%s', available actions are: %s" % (action, app, ", ".join(actions.keys())))
 
     action_declaration = actions[action]
 
@@ -1511,7 +1511,7 @@ def app_action_run(app, action, args=None):
     )
 
     if retcode not in action_declaration.get("accepted_return_codes", [0]):
-        raise MoulinetteError(retcode, "Error while executing action '%s' of app '%s': return code %s" % (action, app, retcode))
+        raise YunohostError(retcode, "Error while executing action '%s' of app '%s': return code %s" % (action, app, retcode))
 
     os.remove(path)
 
@@ -1618,7 +1618,7 @@ def app_config_apply(app, args):
 
     installed = _is_installed(app)
     if not installed:
-        raise MoulinetteError('app_not_installed', app=app)
+        raise YunohostError('app_not_installed', app=app)
 
     config_panel = os.path.join(APPS_SETTING_PATH, app, 'config_panel.json')
     config_script = os.path.join(APPS_SETTING_PATH, app, 'scripts', 'config')
@@ -1676,7 +1676,7 @@ def _get_app_settings(app_id):
 
     """
     if not _is_installed(app_id):
-        raise MoulinetteError('app_not_installed', app=app_id)
+        raise YunohostError('app_not_installed', app=app_id)
     try:
         with open(os.path.join(
                 APPS_SETTING_PATH, app_id, 'settings.yml')) as f:
@@ -1714,7 +1714,7 @@ def _get_app_status(app_id, format_date=False):
     """
     app_setting_path = APPS_SETTING_PATH + app_id
     if not os.path.isdir(app_setting_path):
-        raise MoulinetteError('app_unknown')
+        raise YunohostError('app_unknown')
     status = {}
 
     try:
@@ -1779,7 +1779,7 @@ def _extract_app_from_file(path, remove=False):
         extract_result = 1
 
     if extract_result != 0:
-        raise MoulinetteError('app_extraction_failed')
+        raise YunohostError('app_extraction_failed')
 
     try:
         extracted_app_folder = APP_TMP_FOLDER
@@ -1790,9 +1790,9 @@ def _extract_app_from_file(path, remove=False):
             manifest = json.loads(str(json_manifest.read()))
             manifest['lastUpdate'] = int(time.time())
     except IOError:
-        raise MoulinetteError('app_install_files_invalid')
+        raise YunohostError('app_install_files_invalid')
     except ValueError as e:
-        raise MoulinetteError('app_manifest_invalid', error=e.strerror)
+        raise YunohostError('app_manifest_invalid', error=e.strerror)
 
     logger.debug(m18n.n('done'))
 
@@ -1860,7 +1860,7 @@ def _fetch_app_from_git(app):
                     'wget', '-qO', app_tmp_archive, tarball_url])
             except subprocess.CalledProcessError:
                 logger.exception('unable to download %s', tarball_url)
-                raise MoulinetteError('app_sources_fetch_failed')
+                raise YunohostError('app_sources_fetch_failed')
             else:
                 manifest, extracted_app_folder = _extract_app_from_file(
                     app_tmp_archive, remove=True)
@@ -1883,9 +1883,9 @@ def _fetch_app_from_git(app):
                 with open(extracted_app_folder + '/manifest.json') as f:
                     manifest = json.loads(str(f.read()))
             except subprocess.CalledProcessError:
-                raise MoulinetteError('app_sources_fetch_failed')
+                raise YunohostError('app_sources_fetch_failed')
             except ValueError as e:
-                raise MoulinetteError('app_manifest_invalid', error=e.strerror)
+                raise YunohostError('app_manifest_invalid', error=e.strerror)
             else:
                 logger.debug(m18n.n('done'))
 
@@ -1905,10 +1905,10 @@ def _fetch_app_from_git(app):
             app_info['manifest']['lastUpdate'] = app_info['lastUpdate']
             manifest = app_info['manifest']
         else:
-            raise MoulinetteError('app_unknown')
+            raise YunohostError('app_unknown')
 
         if 'git' not in app_info:
-            raise MoulinetteError('app_unsupported_remote_type')
+            raise YunohostError('app_unsupported_remote_type')
         url = app_info['git']['url']
 
         if 'github.com' in url:
@@ -1920,7 +1920,7 @@ def _fetch_app_from_git(app):
                     'wget', '-qO', app_tmp_archive, tarball_url])
             except subprocess.CalledProcessError:
                 logger.exception('unable to download %s', tarball_url)
-                raise MoulinetteError('app_sources_fetch_failed')
+                raise YunohostError('app_sources_fetch_failed')
             else:
                 manifest, extracted_app_folder = _extract_app_from_file(
                     app_tmp_archive, remove=True)
@@ -1936,9 +1936,9 @@ def _fetch_app_from_git(app):
                 with open(extracted_app_folder + '/manifest.json') as f:
                     manifest = json.loads(str(f.read()))
             except subprocess.CalledProcessError:
-                raise MoulinetteError('app_sources_fetch_failed')
+                raise YunohostError('app_sources_fetch_failed')
             except ValueError as e:
-                raise MoulinetteError('app_manifest_invalid', error=e.strerror)
+                raise YunohostError('app_manifest_invalid', error=e.strerror)
             else:
                 logger.debug(m18n.n('done'))
 
@@ -2057,7 +2057,7 @@ def _check_manifest_requirements(manifest, app_instance_name):
         yunohost_req = requirements.get('yunohost', None)
         if (not yunohost_req or
                 not packages.SpecifierSet(yunohost_req) & '>= 2.3.6'):
-            raise MoulinetteError('{0}{1}'.format(
+            raise YunohostError('{0}{1}'.format(
                 m18n.g('colon', m18n.n('app_incompatible'), app=app_instance_name),
                 m18n.n('app_package_need_update', app=app_instance_name)))
     elif not requirements:
@@ -2070,13 +2070,13 @@ def _check_manifest_requirements(manifest, app_instance_name):
         versions = packages.get_installed_version(
             *requirements.keys(), strict=True, as_dict=True)
     except packages.PackageException as e:
-        raise MoulinetteError('app_requirements_failed', error=str(e), app=app_instance_name)
+        raise YunohostError('app_requirements_failed', error=str(e), app=app_instance_name)
 
     # Iterate over requirements
     for pkgname, spec in requirements.items():
         version = versions[pkgname]
         if version not in packages.SpecifierSet(spec):
-            raise MoulinetteError(
+            raise YunohostError(
                 errno.EINVAL, m18n.n('app_requirements_unmeet',
                                      pkgname=pkgname, version=version,
                                      spec=spec, app=app_instance_name))
@@ -2203,27 +2203,27 @@ def _parse_action_args_in_yunohost_format(args, action_args, auth=None):
         # Validate argument value
         if (arg_value is None or arg_value == '') \
                 and not arg.get('optional', False):
-            raise MoulinetteError('app_argument_required', name=arg_name)
+            raise YunohostError('app_argument_required', name=arg_name)
         elif arg_value is None:
             args_dict[arg_name] = ''
             continue
 
         # Validate argument choice
         if arg_choices and arg_value not in arg_choices:
-            raise MoulinetteError('app_argument_choice_invalid', name=arg_name, choices=', '.join(arg_choices))
+            raise YunohostError('app_argument_choice_invalid', name=arg_name, choices=', '.join(arg_choices))
 
         # Validate argument type
         if arg_type == 'domain':
             if arg_value not in domain_list(auth)['domains']:
-                raise MoulinetteError('app_argument_invalid', name=arg_name, error=m18n.n('domain_unknown'))
+                raise YunohostError('app_argument_invalid', name=arg_name, error=m18n.n('domain_unknown'))
         elif arg_type == 'user':
             try:
                 user_info(auth, arg_value)
-            except MoulinetteError as e:
-                raise MoulinetteError('app_argument_invalid', name=arg_name, error=e.strerror)
+            except YunohostError as e:
+                raise YunohostError('app_argument_invalid', name=arg_name, error=e.strerror)
         elif arg_type == 'app':
             if not _is_installed(arg_value):
-                raise MoulinetteError('app_argument_invalid', name=arg_name, error=m18n.n('app_unknown'))
+                raise YunohostError('app_argument_invalid', name=arg_name, error=m18n.n('app_unknown'))
         elif arg_type == 'boolean':
             if isinstance(arg_value, bool):
                 arg_value = 1 if arg_value else 0
@@ -2233,7 +2233,7 @@ def _parse_action_args_in_yunohost_format(args, action_args, auth=None):
                 elif str(arg_value).lower() in ["0", "no", "n"]:
                     arg_value = 0
                 else:
-                    raise MoulinetteError('app_argument_choice_invalid', name=arg_name, choices='yes, no, y, n, 1, 0')
+                    raise YunohostError('app_argument_choice_invalid', name=arg_name, choices='yes, no, y, n, 1, 0')
         elif arg_type == 'password':
             from yunohost.utils.password import assert_password_is_strong_enough
             assert_password_is_strong_enough('user', arg_value)
@@ -2267,7 +2267,7 @@ def _parse_action_args_in_yunohost_format(args, action_args, auth=None):
                     app_label=app_label,
                 ))
 
-            raise MoulinetteError('app_location_unavailable', apps="\n".join(apps))
+            raise YunohostError('app_location_unavailable', apps="\n".join(apps))
 
         # (We save this normalized path so that the install script have a
         # standard path format to deal with no matter what the user inputted)
@@ -2417,7 +2417,7 @@ def _read_appslist_list():
     try:
         appslists = json.loads(appslists_json)
     except ValueError:
-        raise MoulinetteError('appslist_corrupted_json', filename=APPSLISTS_JSON)
+        raise YunohostError('appslist_corrupted_json', filename=APPSLISTS_JSON)
 
     return appslists
 
@@ -2432,7 +2432,7 @@ def _write_appslist_list(appslist_lists):
         with open(APPSLISTS_JSON, "w") as f:
             json.dump(appslist_lists, f)
     except Exception as e:
-        raise MoulinetteError("Error while writing list of appslist %s: %s" %
+        raise YunohostError("Error while writing list of appslist %s: %s" %
                               (APPSLISTS_JSON, str(e)))
 
 
@@ -2446,13 +2446,13 @@ def _register_new_appslist(url, name):
 
     # Check if name conflicts with an existing list
     if name in appslist_list:
-        raise MoulinetteError('appslist_name_already_tracked', name=name)
+        raise YunohostError('appslist_name_already_tracked', name=name)
 
     # Check if url conflicts with an existing list
     known_appslist_urls = [appslist["url"] for _, appslist in appslist_list.items()]
 
     if url in known_appslist_urls:
-        raise MoulinetteError('appslist_url_already_tracked', url=url)
+        raise YunohostError('appslist_url_already_tracked', url=url)
 
     logger.debug("Registering new appslist %s at %s" % (name, url))
 
diff --git a/src/yunohost/backup.py b/src/yunohost/backup.py
index 08544a1a6..24313d416 100644
--- a/src/yunohost/backup.py
+++ b/src/yunohost/backup.py
@@ -38,7 +38,7 @@ from glob import glob
 from collections import OrderedDict
 
 from moulinette import msignals, m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import filesystem
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import read_file
@@ -308,14 +308,14 @@ class BackupManager():
         Ensure the working directory exists and is empty
 
         exception:
-        backup_output_directory_not_empty -- (MoulinetteError) Raised if the
+        backup_output_directory_not_empty -- (YunohostError) Raised if the
             directory was given by the user and isn't empty
 
-        (TODO) backup_cant_clean_tmp_working_directory -- (MoulinetteError)
+        (TODO) backup_cant_clean_tmp_working_directory -- (YunohostError)
             Raised if the working directory isn't empty, is temporary and can't
             be automaticcaly cleaned
 
-        (TODO) backup_cant_create_working_directory -- (MoulinetteError) Raised
+        (TODO) backup_cant_create_working_directory -- (YunohostError) Raised
             if iyunohost can't create the working directory
         """
 
@@ -327,7 +327,7 @@ class BackupManager():
             logger.debug("temporary directory for backup '%s' already exists",
                          self.work_dir)
             # FIXME May be we should clean the workdir here
-            raise MoulinetteError('backup_output_directory_not_empty')
+            raise YunohostError('backup_output_directory_not_empty')
 
     ###########################################################################
     #   Backup target management                                              #
@@ -493,7 +493,7 @@ class BackupManager():
                       copied here
 
         Exceptions:
-        "backup_nothings_done" -- (MoulinetteError) This exception is raised if
+        "backup_nothings_done" -- (YunohostError) This exception is raised if
         nothing has been listed.
         """
 
@@ -506,7 +506,7 @@ class BackupManager():
 
         if not successfull_apps and not successfull_system:
             filesystem.rm(self.work_dir, True, True)
-            raise MoulinetteError('backup_nothings_done')
+            raise YunohostError('backup_nothings_done')
 
         # Add unlisted files from backup tmp dir
         self._add_to_list_to_backup('backup.csv')
@@ -856,7 +856,7 @@ class RestoreManager():
                 self.info["system"] = self.info["hooks"]
         except IOError:
             logger.debug("unable to load '%s'", info_file, exc_info=1)
-            raise MoulinetteError('backup_invalid_archive')
+            raise YunohostError('backup_invalid_archive')
         else:
             logger.debug("restoring from backup '%s' created on %s", self.name,
                          datetime.utcfromtimestamp(self.info['created_at']))
@@ -879,7 +879,7 @@ class RestoreManager():
                 logger.debug("unable to retrieve current_host from the backup",
                             exc_info=1)
                 # FIXME include the current_host by default ?
-                raise MoulinetteError('backup_invalid_archive')
+                raise YunohostError('backup_invalid_archive')
 
             logger.debug("executing the post-install...")
             tools_postinstall(domain, 'yunohost', True)
@@ -1008,7 +1008,7 @@ class RestoreManager():
                 subprocess.call(['rmdir', self.work_dir])
                 logger.debug("Unmount dir: {}".format(self.work_dir))
             else:
-                raise MoulinetteError('restore_removing_tmp_dir_failed')
+                raise YunohostError('restore_removing_tmp_dir_failed')
         elif os.path.isdir(self.work_dir):
             logger.debug("temporary restore directory '%s' already exists",
                          self.work_dir)
@@ -1016,7 +1016,7 @@ class RestoreManager():
             if ret == 0:
                 logger.debug("Delete dir: {}".format(self.work_dir))
             else:
-                raise MoulinetteError('restore_removing_tmp_dir_failed')
+                raise YunohostError('restore_removing_tmp_dir_failed')
 
         filesystem.mkdir(self.work_dir, parents=True)
 
@@ -1083,9 +1083,9 @@ class RestoreManager():
             return True
         elif free_space > needed_space:
             # TODO Add --force options to avoid the error raising
-            raise MoulinetteError('restore_may_be_not_enough_disk_space', free_space=free_space,  needed_space=needed_space, margin=margin)
+            raise YunohostError('restore_may_be_not_enough_disk_space', free_space=free_space,  needed_space=needed_space, margin=margin)
         else:
-            raise MoulinetteError('restore_not_enough_disk_space', free_space=free_space, needed_space=needed_space, margin=margin)
+            raise YunohostError('restore_not_enough_disk_space', free_space=free_space, needed_space=needed_space, margin=margin)
 
     ###########################################################################
     #   "Actual restore" (reverse step of the backup collect part)            #
@@ -1135,7 +1135,7 @@ class RestoreManager():
 
                     newlines.append(row)
         except (IOError, OSError, csv.Error) as e:
-            raise MoulinetteError('error_reading_file', file=backup_csv, error=str(e))
+            raise YunohostError('error_reading_file', file=backup_csv, error=str(e))
 
         if not contains_php5:
             return
@@ -1428,7 +1428,7 @@ class BackupMethod(object):
     @property
     def method_name(self):
         """Return the string name of a BackupMethod (eg "tar" or "copy")"""
-        raise MoulinetteError('backup_abstract_method')
+        raise YunohostError('backup_abstract_method')
 
     @property
     def name(self):
@@ -1510,7 +1510,7 @@ class BackupMethod(object):
         """
         if self.need_mount():
             if self._recursive_umount(self.work_dir) > 0:
-                raise MoulinetteError('backup_cleaning_failed')
+                raise YunohostError('backup_cleaning_failed')
 
         if self.manager.is_tmp_work_dir:
             filesystem.rm(self.work_dir, True, True)
@@ -1552,7 +1552,7 @@ class BackupMethod(object):
         if free_space < backup_size:
             logger.debug('Not enough space at %s (free: %s / needed: %d)',
                          self.repo, free_space, backup_size)
-            raise MoulinetteError('not_enough_disk_space', path=self.repo)
+            raise YunohostError('not_enough_disk_space', path=self.repo)
 
     def _organize_files(self):
         """
@@ -1640,10 +1640,10 @@ class BackupMethod(object):
                 i = msignals.prompt(m18n.n('backup_ask_for_copying_if_needed',
                                         answers='y/N', size=str(size)))
             except NotImplemented:
-                raise MoulinetteError('backup_unable_to_organize_files')
+                raise YunohostError('backup_unable_to_organize_files')
             else:
                 if i != 'y' and i != 'Y':
-                    raise MoulinetteError('backup_unable_to_organize_files')
+                    raise YunohostError('backup_unable_to_organize_files')
 
         # Copy unbinded path
         logger.debug(m18n.n('backup_copying_to_organize_the_archive',
@@ -1733,7 +1733,7 @@ class CopyBackupMethod(BackupMethod):
         super(CopyBackupMethod, self).mount()
 
         if not os.path.isdir(self.repo):
-            raise MoulinetteError('backup_no_uncompress_archive_dir')
+            raise YunohostError('backup_no_uncompress_archive_dir')
 
         filesystem.mkdir(self.work_dir, parent=True)
         ret = subprocess.call(["mount", "-r", "--rbind", self.repo,
@@ -1744,7 +1744,7 @@ class CopyBackupMethod(BackupMethod):
             logger.warning(m18n.n("bind_mouting_disable"))
             subprocess.call(["mountpoint", "-q", dest,
                             "&&", "umount", "-R", dest])
-            raise MoulinetteError('backup_cant_mount_uncompress_archive')
+            raise YunohostError('backup_cant_mount_uncompress_archive')
 
 
 class TarBackupMethod(BackupMethod):
@@ -1789,7 +1789,7 @@ class TarBackupMethod(BackupMethod):
         except:
             logger.debug("unable to open '%s' for writing",
                          self._archive_file, exc_info=1)
-            raise MoulinetteError('backup_archive_open_failed')
+            raise YunohostError('backup_archive_open_failed')
 
         # Add files to the archive
         try:
@@ -1800,7 +1800,7 @@ class TarBackupMethod(BackupMethod):
             tar.close()
         except IOError:
             logger.error(m18n.n('backup_archive_writing_error'), exc_info=1)
-            raise MoulinetteError('backup_creation_failed')
+            raise YunohostError('backup_creation_failed')
 
         # Move info file
         shutil.copy(os.path.join(self.work_dir, 'info.json'),
@@ -1828,7 +1828,7 @@ class TarBackupMethod(BackupMethod):
         except:
             logger.debug("cannot open backup archive '%s'",
                          self._archive_file, exc_info=1)
-            raise MoulinetteError('backup_archive_open_failed')
+            raise YunohostError('backup_archive_open_failed')
         tar.close()
 
         # Mount the tarball
@@ -1889,10 +1889,10 @@ class BorgBackupMethod(BackupMethod):
         super(CopyBackupMethod, self).backup()
 
         # TODO run borg create command
-        raise MoulinetteError('backup_borg_not_implemented')
+        raise YunohostError('backup_borg_not_implemented')
 
     def mount(self, mnt_path):
-        raise MoulinetteError('backup_borg_not_implemented')
+        raise YunohostError('backup_borg_not_implemented')
 
 
 class CustomBackupMethod(BackupMethod):
@@ -1938,7 +1938,7 @@ class CustomBackupMethod(BackupMethod):
         ret = hook_callback('backup_method', [self.method],
                             args=self._get_args('backup'))
         if ret['failed']:
-            raise MoulinetteError('backup_custom_backup_error')
+            raise YunohostError('backup_custom_backup_error')
 
     def mount(self, restore_manager):
         """
@@ -1951,7 +1951,7 @@ class CustomBackupMethod(BackupMethod):
         ret = hook_callback('backup_method', [self.method],
                             args=self._get_args('mount'))
         if ret['failed']:
-            raise MoulinetteError('backup_custom_mount_error')
+            raise YunohostError('backup_custom_mount_error')
 
     def _get_args(self, action):
         """Return the arguments to give to the custom script"""
@@ -1987,7 +1987,7 @@ def backup_create(name=None, description=None, methods=[],
 
     # Validate there is no archive with the same name
     if name and name in backup_list()['archives']:
-        raise MoulinetteError('backup_archive_name_exists')
+        raise YunohostError('backup_archive_name_exists')
 
     # Validate output_directory option
     if output_directory:
@@ -1997,14 +1997,14 @@ def backup_create(name=None, description=None, methods=[],
         if output_directory.startswith(ARCHIVES_PATH) or \
             re.match(r'^/(|(bin|boot|dev|etc|lib|root|run|sbin|sys|usr|var)(|/.*))$',
                  output_directory):
-            raise MoulinetteError('backup_output_directory_forbidden')
+            raise YunohostError('backup_output_directory_forbidden')
 
         # Check that output directory is empty
         if os.path.isdir(output_directory) and no_compress and \
                 os.listdir(output_directory):
-            raise MoulinetteError('backup_output_directory_not_empty')
+            raise YunohostError('backup_output_directory_not_empty')
     elif no_compress:
-        raise MoulinetteError('backup_output_directory_required')
+        raise YunohostError('backup_output_directory_required')
 
     # Define methods (retro-compat)
     if not methods:
@@ -2101,7 +2101,7 @@ def backup_restore(auth, name, system=[], apps=[], force=False):
                 if i == 'y' or i == 'Y':
                     force = True
             if not force:
-                raise MoulinetteError('restore_failed')
+                raise YunohostError('restore_failed')
 
     # TODO Partial app restore could not work if ldap is not restored before
     # TODO repair mysql if broken and it's a complete restore
@@ -2128,7 +2128,7 @@ def backup_restore(auth, name, system=[], apps=[], force=False):
     if restore_manager.success:
         logger.success(m18n.n('restore_complete'))
     else:
-        raise MoulinetteError('restore_nothings_done')
+        raise YunohostError('restore_nothings_done')
 
     return restore_manager.targets.results
 
@@ -2164,7 +2164,7 @@ def backup_list(with_info=False, human_readable=False):
         for a in result:
             try:
                 d[a] = backup_info(a, human_readable=human_readable)
-            except MoulinetteError, e:
+            except YunohostError, e:
                 logger.warning('%s: %s' % (a, e.strerror))
 
         result = d
@@ -2186,7 +2186,7 @@ def backup_info(name, with_details=False, human_readable=False):
 
     # Check file exist (even if it's a broken symlink)
     if not os.path.lexists(archive_file):
-        raise MoulinetteError('backup_archive_name_unknown', name=name)
+        raise YunohostError('backup_archive_name_unknown', name=name)
 
     # If symlink, retrieve the real path
     if os.path.islink(archive_file):
@@ -2194,7 +2194,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 MoulinetteError('backup_archive_broken_link',
+            raise YunohostError('backup_archive_broken_link',
                                          path=archive_file)
 
     info_file = "%s/%s.info.json" % (ARCHIVES_PATH, name)
@@ -2207,7 +2207,7 @@ def backup_info(name, with_details=False, human_readable=False):
         except KeyError:
             logger.debug("unable to retrieve '%s' inside the archive",
                          info_file, exc_info=1)
-            raise MoulinetteError('backup_invalid_archive')
+            raise YunohostError('backup_invalid_archive')
         else:
             shutil.move(os.path.join(info_dir, 'info.json'), info_file)
         finally:
@@ -2220,7 +2220,7 @@ def backup_info(name, with_details=False, human_readable=False):
             info = json.load(f)
     except:
         logger.debug("unable to load '%s'", info_file, exc_info=1)
-        raise MoulinetteError('backup_invalid_archive')
+        raise YunohostError('backup_invalid_archive')
 
     # Retrieve backup size
     size = info.get('size', 0)
@@ -2259,7 +2259,7 @@ def backup_delete(name):
 
     """
     if name not in backup_list()["archives"]:
-        raise MoulinetteError('backup_archive_name_unknown',
+        raise YunohostError('backup_archive_name_unknown',
                                                 name=name)
 
     hook_callback('pre_backup_delete', args=[name])
@@ -2287,7 +2287,7 @@ def _create_archive_dir():
     """ Create the YunoHost archives directory if doesn't exist """
     if not os.path.isdir(ARCHIVES_PATH):
         if os.path.lexists(ARCHIVES_PATH):
-            raise MoulinetteError('backup_output_symlink_dir_broken', path=ARCHIVES_PATH)
+            raise YunohostError('backup_output_symlink_dir_broken', path=ARCHIVES_PATH)
 
         os.mkdir(ARCHIVES_PATH, 0750)
 
diff --git a/src/yunohost/certificate.py b/src/yunohost/certificate.py
index e75aebcc7..ca27d59df 100644
--- a/src/yunohost/certificate.py
+++ b/src/yunohost/certificate.py
@@ -37,7 +37,7 @@ from datetime import datetime
 
 from yunohost.vendor.acme_tiny.acme_tiny import get_crt as sign_certificate
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.utils.network import get_public_ip
@@ -106,7 +106,7 @@ def certificate_status(auth, domain_list, full=False):
         for domain in domain_list:
             # Is it in Yunohost domain list?
             if domain not in yunohost_domains_list:
-                raise MoulinetteError('certmanager_domain_unknown', domain=domain)
+                raise YunohostError('certmanager_domain_unknown', domain=domain)
 
     certificates = {}
 
@@ -171,7 +171,7 @@ def _certificate_install_selfsigned(domain_list, force=False):
             status = _get_status(domain)
 
             if status["summary"]["code"] in ('good', 'great'):
-                raise MoulinetteError('certmanager_attempt_to_replace_valid_cert', domain=domain)
+                raise YunohostError('certmanager_attempt_to_replace_valid_cert', domain=domain)
 
         operation_logger.start()
 
@@ -201,7 +201,7 @@ def _certificate_install_selfsigned(domain_list, force=False):
 
             if p.returncode != 0:
                 logger.warning(out)
-                raise MoulinetteError('domain_cert_gen_failed')
+                raise YunohostError('domain_cert_gen_failed')
             else:
                 logger.debug(out)
 
@@ -259,12 +259,12 @@ def _certificate_install_letsencrypt(auth, domain_list, force=False, no_checks=F
         for domain in domain_list:
             yunohost_domains_list = yunohost.domain.domain_list(auth)['domains']
             if domain not in yunohost_domains_list:
-                raise MoulinetteError('certmanager_domain_unknown', domain=domain)
+                raise YunohostError('certmanager_domain_unknown', domain=domain)
 
             # Is it self-signed?
             status = _get_status(domain)
             if not force and status["CA_type"]["code"] != "self-signed":
-                raise MoulinetteError('certmanager_domain_cert_not_selfsigned', domain=domain)
+                raise YunohostError('certmanager_domain_cert_not_selfsigned', domain=domain)
 
     if staging:
         logger.warning(
@@ -344,21 +344,21 @@ def certificate_renew(auth, domain_list, force=False, no_checks=False, email=Fal
 
             # Is it in Yunohost dmomain list?
             if domain not in yunohost.domain.domain_list(auth)['domains']:
-                raise MoulinetteError('certmanager_domain_unknown', domain=domain)
+                raise YunohostError('certmanager_domain_unknown', domain=domain)
 
             status = _get_status(domain)
 
             # Does it expire soon?
             if status["validity"] > VALIDITY_LIMIT and not force:
-                raise MoulinetteError('certmanager_attempt_to_renew_valid_cert', domain=domain)
+                raise YunohostError('certmanager_attempt_to_renew_valid_cert', domain=domain)
 
             # Does it have a Let's Encrypt cert?
             if status["CA_type"]["code"] != "lets-encrypt":
-                raise MoulinetteError('certmanager_attempt_to_renew_nonLE_cert', domain=domain)
+                raise YunohostError('certmanager_attempt_to_renew_nonLE_cert', domain=domain)
 
             # Check ACME challenge configured for given domain
             if not _check_acme_challenge_configuration(domain):
-                raise MoulinetteError('certmanager_acme_not_configured_for_domain', domain=domain)
+                raise YunohostError('certmanager_acme_not_configured_for_domain', domain=domain)
 
     if staging:
         logger.warning(
@@ -475,7 +475,7 @@ location ^~ '/.well-known/acme-challenge/'
             contents = f.read()
 
         if '/.well-known/acme-challenge' in contents:
-            raise MoulinetteError('certmanager_conflicting_nginx_file', filepath=path)
+            raise YunohostError('certmanager_conflicting_nginx_file', filepath=path)
 
     # Write the conf
     if os.path.exists(nginx_conf_file):
@@ -553,22 +553,22 @@ def _fetch_and_enable_new_certificate(domain, staging=False, no_checks=False):
                                               CA=certification_authority)
     except ValueError as e:
         if "urn:acme:error:rateLimited" in str(e):
-            raise MoulinetteError('certmanager_hit_rate_limit', domain=domain)
+            raise YunohostError('certmanager_hit_rate_limit', domain=domain)
         else:
             logger.error(str(e))
             _display_debug_information(domain)
-            raise MoulinetteError('certmanager_cert_signing_failed')
+            raise YunohostError('certmanager_cert_signing_failed')
 
     except Exception as e:
         logger.error(str(e))
 
-        raise MoulinetteError('certmanager_cert_signing_failed')
+        raise YunohostError('certmanager_cert_signing_failed')
 
     import requests # lazy loading this module for performance reasons
     try:
         intermediate_certificate = requests.get(INTERMEDIATE_CERTIFICATE_URL, timeout=30).text
     except requests.exceptions.Timeout as e:
-        raise MoulinetteError('certmanager_couldnt_fetch_intermediate_cert')
+        raise YunohostError('certmanager_couldnt_fetch_intermediate_cert')
 
     # Now save the key and signed certificate
     logger.debug("Saving the key and signed certificate...")
@@ -611,7 +611,7 @@ def _fetch_and_enable_new_certificate(domain, staging=False, no_checks=False):
     status_summary = _get_status(domain)["summary"]
 
     if status_summary["code"] != "great":
-        raise MoulinetteError('certmanager_certificate_fetching_or_enabling_failed', domain=domain)
+        raise YunohostError('certmanager_certificate_fetching_or_enabling_failed', domain=domain)
 
 
 def _prepare_certificate_signing_request(domain, key_file, output_folder):
@@ -644,7 +644,7 @@ def _get_status(domain):
     cert_file = os.path.join(CERT_FOLDER, domain, "crt.pem")
 
     if not os.path.isfile(cert_file):
-        raise MoulinetteError('certmanager_no_cert_file', domain=domain, file=cert_file)
+        raise YunohostError('certmanager_no_cert_file', domain=domain, file=cert_file)
 
     from OpenSSL import crypto # lazy loading this module for performance reasons
     try:
@@ -653,7 +653,7 @@ def _get_status(domain):
     except Exception as exception:
         import traceback
         traceback.print_exc(file=sys.stdout)
-        raise MoulinetteError('certmanager_cannot_read_cert', domain=domain, file=cert_file, reason=exception)
+        raise YunohostError('certmanager_cannot_read_cert', domain=domain, file=cert_file, reason=exception)
 
     cert_subject = cert.get_subject().CN
     cert_issuer = cert.get_issuer().CN
@@ -814,11 +814,11 @@ def _check_domain_is_ready_for_ACME(domain):
 
     # Check if IP from DNS matches public IP
     if not _dns_ip_match_public_ip(public_ip, domain):
-        raise MoulinetteError('certmanager_domain_dns_ip_differs_from_public_ip', domain=domain)
+        raise YunohostError('certmanager_domain_dns_ip_differs_from_public_ip', domain=domain)
 
     # Check if domain seems to be accessible through HTTP?
     if not _domain_is_accessible_through_HTTP(public_ip, domain):
-        raise MoulinetteError('certmanager_domain_http_not_working', domain=domain)
+        raise YunohostError('certmanager_domain_http_not_working', domain=domain)
 
 
 def _get_dns_ip(domain):
@@ -827,7 +827,7 @@ def _get_dns_ip(domain):
         resolver.nameservers = DNS_RESOLVERS
         answers = resolver.query(domain, "A")
     except (dns.resolver.NoAnswer, dns.resolver.NXDOMAIN):
-        raise MoulinetteError('certmanager_error_no_A_record', domain=domain)
+        raise YunohostError('certmanager_error_no_A_record', domain=domain)
 
     return str(answers[0])
 
diff --git a/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py b/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py
index 188c1dffc..e81b20e5f 100644
--- a/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py
+++ b/src/yunohost/data_migrations/0002_migrate_to_tsig_sha256.py
@@ -7,7 +7,7 @@ import json
 import errno
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.tools import Migration
@@ -29,7 +29,7 @@ class MyMigration(Migration):
             try:
                 (domain, private_key_path) = _guess_current_dyndns_domain(dyn_host)
                 assert "+157" in private_key_path
-            except (MoulinetteError, AssertionError):
+            except (YunohostError, AssertionError):
                 logger.info(m18n.n("migrate_tsig_not_needed"))
                 return
 
@@ -52,7 +52,7 @@ class MyMigration(Migration):
                                'public_key_sha512': base64.b64encode(public_key_sha512),
                              }, timeout=30)
         except requests.ConnectionError:
-            raise MoulinetteError('no_internet_connection')
+            raise YunohostError('no_internet_connection')
 
         if r.status_code != 201:
             try:
@@ -70,7 +70,7 @@ class MyMigration(Migration):
             # Migration didn't succeed, so we rollback and raise an exception
             os.system("mv /etc/yunohost/dyndns/*+165* /tmp")
 
-            raise MoulinetteError('migrate_tsig_failed', domain=domain,
+            raise YunohostError('migrate_tsig_failed', domain=domain,
                                   error_code=str(r.status_code), error=error)
 
         # remove old certificates
diff --git a/src/yunohost/data_migrations/0003_migrate_to_stretch.py b/src/yunohost/data_migrations/0003_migrate_to_stretch.py
index 474a26db5..80d182fbe 100644
--- a/src/yunohost/data_migrations/0003_migrate_to_stretch.py
+++ b/src/yunohost/data_migrations/0003_migrate_to_stretch.py
@@ -3,7 +3,7 @@ import os
 from shutil import copy2
 
 from moulinette import m18n, msettings
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.process import check_output, call_async_output
 from moulinette.utils.filesystem import read_file
@@ -30,7 +30,7 @@ class MyMigration(Migration):
 
     def backward(self):
 
-        raise MoulinetteError("migration_0003_backward_impossible")
+        raise YunohostError("migration_0003_backward_impossible")
 
     def migrate(self):
 
@@ -57,7 +57,7 @@ class MyMigration(Migration):
         self.apt_dist_upgrade(conf_flags=["old", "miss", "def"])
         _run_service_command("start", "mysql")
         if self.debian_major_version() == 8:
-            raise MoulinetteError("migration_0003_still_on_jessie_after_main_upgrade", log=self.logfile)
+            raise YunohostError("migration_0003_still_on_jessie_after_main_upgrade", log=self.logfile)
 
         # Specific upgrade for fail2ban...
         logger.info(m18n.n("migration_0003_fail2ban_upgrade"))
@@ -107,11 +107,11 @@ class MyMigration(Migration):
         # would still be in 2.x...
         if not self.debian_major_version() == 8 \
            and not self.yunohost_major_version() == 2:
-            raise MoulinetteError("migration_0003_not_jessie")
+            raise YunohostError("migration_0003_not_jessie")
 
         # Have > 1 Go free space on /var/ ?
         if free_space_in_directory("/var/") / (1024**3) < 1.0:
-            raise MoulinetteError("migration_0003_not_enough_free_space")
+            raise YunohostError("migration_0003_not_enough_free_space")
 
         # Check system is up to date
         # (but we don't if 'stretch' is already in the sources.list ...
@@ -120,7 +120,7 @@ class MyMigration(Migration):
             self.apt_update()
             apt_list_upgradable = check_output("apt list --upgradable -a")
             if "upgradable" in apt_list_upgradable:
-                raise MoulinetteError("migration_0003_system_not_fully_up_to_date")
+                raise YunohostError("migration_0003_system_not_fully_up_to_date")
 
     @property
     def disclaimer(self):
diff --git a/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py b/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py
index f03a93ef9..0208b717e 100644
--- a/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py
+++ b/src/yunohost/data_migrations/0005_postgresql_9p4_to_9p6.py
@@ -1,7 +1,7 @@
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.tools import Migration
@@ -20,10 +20,10 @@ class MyMigration(Migration):
             return
 
         if not self.package_is_installed("postgresql-9.6"):
-            raise MoulinetteError("migration_0005_postgresql_96_not_installed")
+            raise YunohostError("migration_0005_postgresql_96_not_installed")
 
         if not space_used_by_directory("/var/lib/postgresql/9.4") > free_space_in_directory("/var/lib/postgresql"):
-            raise MoulinetteError("migration_0005_not_enough_space", path="/var/lib/postgresql/")
+            raise YunohostError("migration_0005_not_enough_space", path="/var/lib/postgresql/")
 
         subprocess.check_call("service postgresql stop", shell=True)
         subprocess.check_call("pg_dropcluster --stop 9.6 main", shell=True)
diff --git a/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py b/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py
index ee3aeefcb..1149f28d5 100644
--- a/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py
+++ b/src/yunohost/data_migrations/0006_sync_admin_and_root_passwords.py
@@ -5,7 +5,7 @@ import string
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.process import run_commands, check_output
 from moulinette.utils.filesystem import append_to_file
diff --git a/src/yunohost/domain.py b/src/yunohost/domain.py
index 7be214914..e28a24afe 100644
--- a/src/yunohost/domain.py
+++ b/src/yunohost/domain.py
@@ -30,7 +30,7 @@ import yaml
 import errno
 
 from moulinette import m18n, msettings
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 import yunohost.certificate
@@ -77,8 +77,8 @@ def domain_add(operation_logger, auth, domain, dyndns=False):
 
     try:
         auth.validate_uniqueness({'virtualdomain': domain})
-    except MoulinetteError:
-        raise MoulinetteError('domain_exists')
+    except YunohostError:
+        raise YunohostError('domain_exists')
 
     operation_logger.start()
 
@@ -87,14 +87,14 @@ def domain_add(operation_logger, auth, domain, dyndns=False):
 
         # Do not allow to subscribe to multiple dyndns domains...
         if os.path.exists('/etc/cron.d/yunohost-dyndns'):
-            raise MoulinetteError('domain_dyndns_already_subscribed')
+            raise YunohostError('domain_dyndns_already_subscribed')
 
         from yunohost.dyndns import dyndns_subscribe, _dyndns_provides
 
         # 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 MoulinetteError('domain_dyndns_root_unknown')
+            raise YunohostError('domain_dyndns_root_unknown')
 
         # Actually subscribe
         dyndns_subscribe(domain=domain)
@@ -108,7 +108,7 @@ def domain_add(operation_logger, auth, domain, dyndns=False):
         }
 
         if not auth.add('virtualdomain=%s,ou=domains' % domain, attr_dict):
-            raise MoulinetteError('domain_creation_failed')
+            raise YunohostError('domain_creation_failed')
 
         # Don't regen these conf if we're still in postinstall
         if os.path.exists('/etc/yunohost/installed'):
@@ -145,11 +145,11 @@ def domain_remove(operation_logger, auth, domain, force=False):
     from yunohost.app import app_ssowatconf
 
     if not force and domain not in domain_list(auth)['domains']:
-        raise MoulinetteError('domain_unknown')
+        raise YunohostError('domain_unknown')
 
     # Check domain is not the main domain
     if domain == _get_maindomain():
-        raise MoulinetteError('domain_cannot_remove_main')
+        raise YunohostError('domain_cannot_remove_main')
 
     # Check if apps are installed on the domain
     for app in os.listdir('/etc/yunohost/apps/'):
@@ -160,13 +160,13 @@ def domain_remove(operation_logger, auth, domain, force=False):
                 continue
             else:
                 if app_domain == domain:
-                    raise MoulinetteError('domain_uninstall_app_first')
+                    raise YunohostError('domain_uninstall_app_first')
 
     operation_logger.start()
     if auth.remove('virtualdomain=' + domain + ',ou=domains') or force:
         os.system('rm -rf /etc/yunohost/certs/%s' % domain)
     else:
-        raise MoulinetteError('domain_deletion_failed')
+        raise YunohostError('domain_deletion_failed')
 
     service_regen_conf(names=['nginx', 'metronome', 'dnsmasq', 'postfix'])
     app_ssowatconf(auth)
@@ -243,7 +243,7 @@ def _get_conflicting_apps(auth, domain, path):
 
     # Abort if domain is unknown
     if domain not in domain_list(auth)['domains']:
-        raise MoulinetteError('domain_unknown')
+        raise YunohostError('domain_unknown')
 
     # This import cannot be put on top of file because it would create a
     # recursive import...
diff --git a/src/yunohost/dyndns.py b/src/yunohost/dyndns.py
index 93f3a7a38..13dd4b43d 100644
--- a/src/yunohost/dyndns.py
+++ b/src/yunohost/dyndns.py
@@ -33,7 +33,7 @@ import errno
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import read_file, write_to_file, rm
 from moulinette.utils.network import download_json
@@ -75,9 +75,9 @@ def _dyndns_provides(provider, domain):
         # Dyndomains will be a list of domains supported by the provider
         # e.g. [ "nohost.me", "noho.st" ]
         dyndomains = download_json('https://%s/domains' % provider, timeout=30)
-    except MoulinetteError as e:
+    except YunohostError as e:
         logger.error(str(e))
-        raise MoulinetteError('dyndns_could_not_check_provide', domain=domain, provider=provider)
+        raise YunohostError('dyndns_could_not_check_provide', domain=domain, provider=provider)
 
     # Extract 'dyndomain' from 'domain', e.g. 'nohost.me' from 'foo.nohost.me'
     dyndomain = '.'.join(domain.split('.')[1:])
@@ -102,9 +102,9 @@ def _dyndns_available(provider, domain):
     try:
         r = download_json('https://%s/test/%s' % (provider, domain),
                           expected_status_code=None)
-    except MoulinetteError as e:
+    except YunohostError as e:
         logger.error(str(e))
-        raise MoulinetteError('dyndns_could_not_check_available',
+        raise YunohostError('dyndns_could_not_check_available',
                                      domain=domain, provider=provider)
 
     return r == u"Domain %s is available" % domain
@@ -127,11 +127,11 @@ def dyndns_subscribe(operation_logger, subscribe_host="dyndns.yunohost.org", dom
 
     # Verify if domain is provided by subscribe_host
     if not _dyndns_provides(subscribe_host, domain):
-        raise MoulinetteError('dyndns_domain_not_provided', domain=domain, provider=subscribe_host)
+        raise YunohostError('dyndns_domain_not_provided', domain=domain, provider=subscribe_host)
 
     # Verify if domain is available
     if not _dyndns_available(subscribe_host, domain):
-        raise MoulinetteError('dyndns_unavailable', domain=domain)
+        raise YunohostError('dyndns_unavailable', domain=domain)
 
     operation_logger.start()
 
@@ -155,13 +155,13 @@ def dyndns_subscribe(operation_logger, subscribe_host="dyndns.yunohost.org", dom
     try:
         r = requests.post('https://%s/key/%s?key_algo=hmac-sha512' % (subscribe_host, base64.b64encode(key)), data={'subdomain': domain}, timeout=30)
     except requests.ConnectionError:
-        raise MoulinetteError('no_internet_connection')
+        raise YunohostError('no_internet_connection')
     if r.status_code != 201:
         try:
             error = json.loads(r.text)['error']
         except:
             error = "Server error, code: %s. (Message: \"%s\")" % (r.status_code, r.text)
-        raise MoulinetteError('dyndns_registration_failed', error=error)
+        raise YunohostError('dyndns_registration_failed', error=error)
 
     logger.success(m18n.n('dyndns_registered'))
 
@@ -195,7 +195,7 @@ def dyndns_update(operation_logger, dyn_host="dyndns.yunohost.org", domain=None,
             keys = glob.glob('/etc/yunohost/dyndns/K{0}.+*.private'.format(domain))
 
             if not keys:
-                raise MoulinetteError('dyndns_key_not_found')
+                raise YunohostError('dyndns_key_not_found')
 
             key = keys[0]
 
@@ -295,7 +295,7 @@ def dyndns_update(operation_logger, dyn_host="dyndns.yunohost.org", domain=None,
         command = ["/usr/bin/nsupdate", "-k", key, DYNDNS_ZONE]
         subprocess.check_call(command)
     except subprocess.CalledProcessError:
-        raise MoulinetteError('dyndns_ip_update_failed')
+        raise YunohostError('dyndns_ip_update_failed')
 
     logger.success(m18n.n('dyndns_ip_updated'))
 
@@ -321,7 +321,7 @@ def dyndns_removecron():
     try:
         os.remove("/etc/cron.d/yunohost-dyndns")
     except:
-        raise MoulinetteError('dyndns_cron_remove_failed')
+        raise YunohostError('dyndns_cron_remove_failed')
 
     logger.success(m18n.n('dyndns_cron_removed'))
 
@@ -351,4 +351,4 @@ def _guess_current_dyndns_domain(dyn_host):
         else:
             return (_domain, path)
 
-    raise MoulinetteError('dyndns_no_domain_registered')
+    raise YunohostError('dyndns_no_domain_registered')
diff --git a/src/yunohost/firewall.py b/src/yunohost/firewall.py
index 878083bc7..fb1804659 100644
--- a/src/yunohost/firewall.py
+++ b/src/yunohost/firewall.py
@@ -34,7 +34,7 @@ except ImportError:
     sys.exit(1)
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import process
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.text import prependlines
@@ -268,7 +268,7 @@ def firewall_reload(skip_upnp=False):
         reloaded = True
 
     if not reloaded:
-        raise MoulinetteError('firewall_reload_failed')
+        raise YunohostError('firewall_reload_failed')
 
     hook_callback('post_iptable_rules',
                   args=[upnp, os.path.exists("/proc/net/if_inet6")])
@@ -338,7 +338,7 @@ def firewall_upnp(action='status', no_refresh=False):
         if action == 'status':
             no_refresh = True
     else:
-        raise MoulinetteError('action_invalid', action=action)
+        raise YunohostError('action_invalid', action=action)
 
     # Refresh port mapping using UPnP
     if not no_refresh:
@@ -407,7 +407,7 @@ def firewall_upnp(action='status', no_refresh=False):
             firewall_reload(skip_upnp=True)
 
     if action == 'enable' and not enabled:
-        raise MoulinetteError('upnp_port_open_failed')
+        raise YunohostError('upnp_port_open_failed')
     return {'enabled': enabled}
 
 
@@ -419,7 +419,7 @@ def firewall_stop():
     """
 
     if os.system("iptables -w -P INPUT ACCEPT") != 0:
-        raise MoulinetteError('iptables_unavailable')
+        raise YunohostError('iptables_unavailable')
 
     os.system("iptables -w -F")
     os.system("iptables -w -X")
diff --git a/src/yunohost/hook.py b/src/yunohost/hook.py
index 665d2fe40..901321926 100644
--- a/src/yunohost/hook.py
+++ b/src/yunohost/hook.py
@@ -30,7 +30,7 @@ import tempfile
 from glob import iglob
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import log
 
 HOOK_FOLDER = '/usr/share/yunohost/hooks/'
@@ -112,7 +112,7 @@ def hook_info(action, name):
             })
 
     if not hooks:
-        raise MoulinetteError('hook_name_unknown', name=name)
+        raise YunohostError('hook_name_unknown', name=name)
     return {
         'action': action,
         'name': name,
@@ -174,7 +174,7 @@ def hook_list(action, list_by='name', show_info=False):
                 # Add only the name
                 d.add(name)
     else:
-        raise MoulinetteError('hook_list_by_invalid')
+        raise YunohostError('hook_list_by_invalid')
 
     def _append_folder(d, folder):
         # Iterate over and add hook from a folder
@@ -255,7 +255,7 @@ def hook_callback(action, hooks=[], args=None, no_trace=False, chdir=None,
             try:
                 hl = hooks_names[n]
             except KeyError:
-                raise MoulinetteError('hook_name_unknown', n)
+                raise YunohostError('hook_name_unknown', n)
             # Iterate over hooks with this name
             for h in hl:
                 # Update hooks dict
@@ -281,7 +281,7 @@ def hook_callback(action, hooks=[], args=None, no_trace=False, chdir=None,
                                          path=path, args=args)
                 hook_exec(path, args=hook_args, chdir=chdir, env=env,
                           no_trace=no_trace, raise_on_error=True)
-            except MoulinetteError as e:
+            except YunohostError as e:
                 state = 'failed'
                 logger.error(e.strerror, exc_info=1)
                 post_callback(name=name, priority=priority, path=path,
@@ -318,7 +318,7 @@ def hook_exec(path, args=None, raise_on_error=False, no_trace=False,
     if path[0] != '/':
         path = os.path.realpath(path)
     if not os.path.isfile(path):
-        raise MoulinetteError('file_not_exist', path=path)
+        raise YunohostError('file_not_exist', path=path)
 
     # Construct command variables
     cmd_args = ''
@@ -383,12 +383,12 @@ def hook_exec(path, args=None, raise_on_error=False, no_trace=False,
     # Check and return process' return code
     if returncode is None:
         if raise_on_error:
-            raise MoulinetteError('hook_exec_not_terminated', path=path)
+            raise YunohostError('hook_exec_not_terminated', path=path)
         else:
             logger.error(m18n.n('hook_exec_not_terminated', path=path))
             return 1
     elif raise_on_error and returncode != 0:
-        raise MoulinetteError('hook_exec_failed', path=path)
+        raise YunohostError('hook_exec_failed', path=path)
     return returncode
 
 
diff --git a/src/yunohost/log.py b/src/yunohost/log.py
index 3df630b14..3c7ff02f3 100644
--- a/src/yunohost/log.py
+++ b/src/yunohost/log.py
@@ -34,7 +34,7 @@ from logging import FileHandler, getLogger, Formatter
 from sys import exc_info
 
 from moulinette import m18n, msettings
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.filesystem import read_file
 
@@ -148,7 +148,7 @@ def log_display(path, number=50, share=False):
         log_path = base_path + LOG_FILE_EXT
 
     if not os.path.exists(md_path) and not os.path.exists(log_path):
-        raise MoulinetteError('log_does_exists', log=path)
+        raise YunohostError('log_does_exists', log=path)
 
     infos = {}
 
@@ -188,7 +188,7 @@ def log_display(path, number=50, share=False):
                 if os.path.exists(log_path):
                     logger.warning(error)
                 else:
-                    raise MoulinetteError(error)
+                    raise YunohostError(error)
 
     # Display logs if exist
     if os.path.exists(log_path):
diff --git a/src/yunohost/monitor.py b/src/yunohost/monitor.py
index 0839c6ae7..4fef2ca61 100644
--- a/src/yunohost/monitor.py
+++ b/src/yunohost/monitor.py
@@ -38,7 +38,7 @@ import cPickle as pickle
 from datetime import datetime
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 from yunohost.utils.network import get_public_ip
@@ -83,7 +83,7 @@ def monitor_disk(units=None, mountpoint=None, human_readable=False):
             result_dname = dn
     if len(devices) == 0:
         if mountpoint is not None:
-            raise MoulinetteError('mountpoint_unknown')
+            raise YunohostError('mountpoint_unknown')
         return result
 
     # Retrieve monitoring for unit(s)
@@ -141,7 +141,7 @@ def monitor_disk(units=None, mountpoint=None, human_readable=False):
             for dname in devices_names:
                 _set(dname, 'not-available')
         else:
-            raise MoulinetteError('unit_unknown', unit=u)
+            raise YunohostError('unit_unknown', unit=u)
 
     if result_dname is not None:
         return result[result_dname]
@@ -237,7 +237,7 @@ def monitor_network(units=None, human_readable=False):
                 'gateway': gateway,
             }
         else:
-            raise MoulinetteError('unit_unknown', unit=u)
+            raise YunohostError('unit_unknown', unit=u)
 
     if len(units) == 1:
         return result[units[0]]
@@ -287,7 +287,7 @@ def monitor_system(units=None, human_readable=False):
         elif u == 'infos':
             result[u] = json.loads(glances.getSystem())
         else:
-            raise MoulinetteError('unit_unknown', unit=u)
+            raise YunohostError('unit_unknown', unit=u)
 
     if len(units) == 1 and type(result[units[0]]) is not str:
         return result[units[0]]
@@ -303,7 +303,7 @@ def monitor_update_stats(period):
 
     """
     if period not in ['day', 'week', 'month']:
-        raise MoulinetteError('monitor_period_invalid')
+        raise YunohostError('monitor_period_invalid')
 
     stats = _retrieve_stats(period)
     if not stats:
@@ -321,7 +321,7 @@ def monitor_update_stats(period):
         else:
             monitor = _monitor_all(p, 0)
     if not monitor:
-        raise MoulinetteError('monitor_stats_no_update')
+        raise YunohostError('monitor_stats_no_update')
 
     stats['timestamp'].append(time.time())
 
@@ -386,13 +386,13 @@ def monitor_show_stats(period, date=None):
 
     """
     if period not in ['day', 'week', 'month']:
-        raise MoulinetteError('monitor_period_invalid')
+        raise YunohostError('monitor_period_invalid')
 
     result = _retrieve_stats(period, date)
     if result is False:
-        raise MoulinetteError('monitor_stats_file_not_found')
+        raise YunohostError('monitor_stats_file_not_found')
     elif result is None:
-        raise MoulinetteError('monitor_stats_period_unavailable')
+        raise YunohostError('monitor_stats_period_unavailable')
     return result
 
 
@@ -440,7 +440,7 @@ def monitor_disable():
     if glances['loaded'] != 'disabled':
         try:
             service_disable('glances')
-        except MoulinetteError as e:
+        except YunohostError as e:
             logger.warning(e.strerror)
 
     # Remove crontab
@@ -468,8 +468,8 @@ def _get_glances_api():
     from yunohost.service import service_status
 
     if service_status('glances')['status'] != 'running':
-        raise MoulinetteError('monitor_not_enabled')
-    raise MoulinetteError('monitor_glances_con_failed')
+        raise YunohostError('monitor_not_enabled')
+    raise YunohostError('monitor_glances_con_failed')
 
 
 def _extract_inet(string, skip_netmask=False, skip_loopback=True):
diff --git a/src/yunohost/service.py b/src/yunohost/service.py
index 140c107be..082b32eab 100644
--- a/src/yunohost/service.py
+++ b/src/yunohost/service.py
@@ -36,7 +36,7 @@ from difflib import unified_diff
 from datetime import datetime
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils import log, filesystem
 
 from yunohost.log import is_unit_operation
@@ -85,7 +85,7 @@ def service_add(name, status=None, log=None, runlevel=None, need_lock=False, des
         _save_services(services)
     except:
         # we'll get a logger.warning with more details in _save_services
-        raise MoulinetteError('service_add_failed', service=name)
+        raise YunohostError('service_add_failed', service=name)
 
     logger.success(m18n.n('service_added', service=name))
 
@@ -103,13 +103,13 @@ def service_remove(name):
     try:
         del services[name]
     except KeyError:
-        raise MoulinetteError('service_unknown', service=name)
+        raise YunohostError('service_unknown', service=name)
 
     try:
         _save_services(services)
     except:
         # we'll get a logger.warning with more details in _save_services
-        raise MoulinetteError('service_remove_failed', service=name)
+        raise YunohostError('service_remove_failed', service=name)
 
     logger.success(m18n.n('service_removed', service=name))
 
@@ -130,7 +130,7 @@ def service_start(names):
             logger.success(m18n.n('service_started', service=name))
         else:
             if service_status(name)['status'] != 'running':
-                raise MoulinetteError('service_start_failed', service=name, logs=_get_journalctl_logs(name))
+                raise YunohostError('service_start_failed', service=name, logs=_get_journalctl_logs(name))
             logger.debug(m18n.n('service_already_started', service=name))
 
 
@@ -149,7 +149,7 @@ def service_stop(names):
             logger.success(m18n.n('service_stopped', service=name))
         else:
             if service_status(name)['status'] != 'inactive':
-                raise MoulinetteError('service_stop_failed', service=name, logs=_get_journalctl_logs(name))
+                raise YunohostError('service_stop_failed', service=name, logs=_get_journalctl_logs(name))
             logger.debug(m18n.n('service_already_stopped', service=name))
 
 @is_unit_operation()
@@ -168,7 +168,7 @@ def service_enable(operation_logger, names):
         if _run_service_command('enable', name):
             logger.success(m18n.n('service_enabled', service=name))
         else:
-            raise MoulinetteError('service_enable_failed', service=name, logs=_get_journalctl_logs(name))
+            raise YunohostError('service_enable_failed', service=name, logs=_get_journalctl_logs(name))
 
 
 def service_disable(names):
@@ -185,7 +185,7 @@ def service_disable(names):
         if _run_service_command('disable', name):
             logger.success(m18n.n('service_disabled', service=name))
         else:
-            raise MoulinetteError('service_disable_failed', service=name, logs=_get_journalctl_logs(name))
+            raise YunohostError('service_disable_failed', service=name, logs=_get_journalctl_logs(name))
 
 
 def service_status(names=[]):
@@ -208,7 +208,7 @@ def service_status(names=[]):
 
     for name in names:
         if check_names and name not in services.keys():
-            raise MoulinetteError('service_unknown', service=name)
+            raise YunohostError('service_unknown', service=name)
 
         # this "service" isn't a service actually so we skip it
         #
@@ -307,10 +307,10 @@ def service_log(name, number=50):
     services = _get_services()
 
     if name not in services.keys():
-        raise MoulinetteError('service_unknown', service=name)
+        raise YunohostError('service_unknown', service=name)
 
     if 'log' not in services[name]:
-        raise MoulinetteError('service_no_log', service=name)
+        raise YunohostError('service_no_log', service=name)
 
     log_list = services[name]['log']
 
@@ -418,7 +418,7 @@ def service_regen_conf(operation_logger, names=[], with_diff=False, force=False,
     names = pre_result['succeed'].keys()
 
     if not names:
-        raise MoulinetteError('service_regenconf_failed',
+        raise YunohostError('service_regenconf_failed',
                                      services=', '.join(pre_result['failed']))
 
     # Set the processing method
@@ -595,7 +595,7 @@ def _run_service_command(action, service):
     """
     services = _get_services()
     if service not in services.keys():
-        raise MoulinetteError('service_unknown', service=service)
+        raise YunohostError('service_unknown', service=service)
 
     possible_actions = ['start', 'stop', 'restart', 'reload', 'enable', 'disable']
     if action not in possible_actions:
diff --git a/src/yunohost/settings.py b/src/yunohost/settings.py
index 5d875afb9..8783188a1 100644
--- a/src/yunohost/settings.py
+++ b/src/yunohost/settings.py
@@ -6,7 +6,7 @@ from datetime import datetime
 from collections import OrderedDict
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 
 logger = getActionLogger('yunohost.settings')
@@ -54,7 +54,7 @@ def settings_get(key, full=False):
     settings = _get_settings()
 
     if key not in settings:
-        raise MoulinetteError('global_settings_key_doesnt_exists', settings_key=key)
+        raise YunohostError('global_settings_key_doesnt_exists', settings_key=key)
 
     if full:
         return settings[key]
@@ -82,13 +82,13 @@ def settings_set(key, value):
     settings = _get_settings()
 
     if key not in settings:
-        raise MoulinetteError('global_settings_key_doesnt_exists', settings_key=key)
+        raise YunohostError('global_settings_key_doesnt_exists', settings_key=key)
 
     key_type = settings[key]["type"]
 
     if key_type == "bool":
         if not isinstance(value, bool):
-            raise MoulinetteError('global_settings_bad_type_for_setting', setting=key,
+            raise YunohostError('global_settings_bad_type_for_setting', setting=key,
                 received_type=type(value).__name__, expected_type=key_type)
     elif key_type == "int":
         if not isinstance(value, int) or isinstance(value, bool):
@@ -100,19 +100,19 @@ def settings_set(key, value):
                         'global_settings_bad_type_for_setting', setting=key,
                         received_type=type(value).__name__, expected_type=key_type))
             else:
-                raise MoulinetteError('global_settings_bad_type_for_setting', setting=key,
+                raise YunohostError('global_settings_bad_type_for_setting', setting=key,
                     received_type=type(value).__name__, expected_type=key_type)
     elif key_type == "string":
         if not isinstance(value, basestring):
-            raise MoulinetteError('global_settings_bad_type_for_setting', setting=key,
+            raise YunohostError('global_settings_bad_type_for_setting', setting=key,
                 received_type=type(value).__name__, expected_type=key_type)
     elif key_type == "enum":
         if value not in settings[key]["choices"]:
-            raise MoulinetteError('global_settings_bad_choice_for_enum', setting=key,
+            raise YunohostError('global_settings_bad_choice_for_enum', setting=key,
                 received_type=type(value).__name__,
                 expected_type=", ".join(settings[key]["choices"]))
     else:
-        raise MoulinetteError('global_settings_unknown_type', setting=key,
+        raise YunohostError('global_settings_unknown_type', setting=key,
             unknown_type=key_type)
 
     settings[key]["value"] = value
@@ -131,7 +131,7 @@ def settings_reset(key):
     settings = _get_settings()
 
     if key not in settings:
-        raise MoulinetteError('global_settings_key_doesnt_exists', settings_key=key)
+        raise YunohostError('global_settings_key_doesnt_exists', settings_key=key)
 
     settings[key]["value"] = settings[key]["default"]
     _save_settings(settings)
@@ -207,7 +207,7 @@ def _get_settings():
                                           setting_key=key))
                     unknown_settings[key] = value
     except Exception as e:
-        raise MoulinetteError('global_settings_cant_open_settings', reason=e, exc_info=1)
+        raise YunohostError('global_settings_cant_open_settings', reason=e, exc_info=1)
 
     if unknown_settings:
         try:
@@ -228,10 +228,10 @@ def _save_settings(settings, location=SETTINGS_PATH):
     try:
         result = json.dumps(settings_without_description, indent=4)
     except Exception as e:
-        raise MoulinetteError('global_settings_cant_serialize_settings', reason=e, exc_info=1)
+        raise YunohostError('global_settings_cant_serialize_settings', reason=e, exc_info=1)
 
     try:
         with open(location, "w") as settings_fd:
             settings_fd.write(result)
     except Exception as e:
-        raise MoulinetteError('global_settings_cant_write_settings', reason=e, exc_info=1)
+        raise YunohostError('global_settings_cant_write_settings', reason=e, exc_info=1)
diff --git a/src/yunohost/ssh.py b/src/yunohost/ssh.py
index 41ac64293..e284736c4 100644
--- a/src/yunohost/ssh.py
+++ b/src/yunohost/ssh.py
@@ -7,7 +7,7 @@ import pwd
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.filesystem import read_file, write_to_file, chown, chmod, mkdir
 
 SSHD_CONFIG_PATH = "/etc/ssh/sshd_config"
@@ -23,7 +23,7 @@ def user_ssh_allow(auth, username):
     # TODO it would be good to support different kind of shells
 
     if not _get_user_for_ssh(auth, username):
-        raise MoulinetteError('user_unknown', user=username)
+        raise YunohostError('user_unknown', user=username)
 
     auth.update('uid=%s,ou=users' % username, {'loginShell': '/bin/bash'})
 
@@ -42,7 +42,7 @@ def user_ssh_disallow(auth, username):
     # TODO it would be good to support different kind of shells
 
     if not _get_user_for_ssh(auth, username):
-        raise MoulinetteError('user_unknown', user=username)
+        raise YunohostError('user_unknown', user=username)
 
     auth.update('uid=%s,ou=users' % username, {'loginShell': '/bin/false'})
 
diff --git a/src/yunohost/tests/test_appslist.py b/src/yunohost/tests/test_appslist.py
index 6b7141f4a..7a6f27d6c 100644
--- a/src/yunohost/tests/test_appslist.py
+++ b/src/yunohost/tests/test_appslist.py
@@ -5,7 +5,7 @@ import requests_mock
 import glob
 import time
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 from yunohost.app import app_fetchlist, app_removelist, app_listlists, _using_legacy_appslist_system, _migrate_appslist_system, _register_new_appslist
 
@@ -79,7 +79,7 @@ def test_appslist_list_register_conflict_name():
     """
 
     _register_new_appslist("https://lol.com/appslist.json", "dummy")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         _register_new_appslist("https://lol.com/appslist2.json", "dummy")
 
     appslist_dict = app_listlists()
@@ -94,7 +94,7 @@ def test_appslist_list_register_conflict_url():
     """
 
     _register_new_appslist("https://lol.com/appslist.json", "dummy")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         _register_new_appslist("https://lol.com/appslist.json", "plopette")
 
     appslist_dict = app_listlists()
@@ -161,7 +161,7 @@ def test_appslist_fetch_unknownlist():
 
     assert app_listlists() == {}
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_fetchlist(name="swag")
 
 
@@ -170,7 +170,7 @@ def test_appslist_fetch_url_but_no_name():
     Do a fetchlist with url given, but no name given
     """
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_fetchlist(url=URL_OFFICIAL_APP_LIST)
 
 
@@ -270,7 +270,7 @@ def test_appslist_remove_unknown():
     Attempt to remove an unknown list
     """
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_removelist("dummy")
 
 
diff --git a/src/yunohost/tests/test_appurl.py b/src/yunohost/tests/test_appurl.py
index dc1dbc29b..58c345dea 100644
--- a/src/yunohost/tests/test_appurl.py
+++ b/src/yunohost/tests/test_appurl.py
@@ -1,6 +1,6 @@
 import pytest
 
-from moulinette.core import MoulinetteError, init_authenticator
+from yunohost.utils.error import YunohostError, init_authenticator
 
 from yunohost.app import app_install, app_remove
 from yunohost.domain import _get_maindomain, domain_url_available, _normalize_domain_path
@@ -43,7 +43,7 @@ def test_urlavailable():
     assert domain_url_available(auth, maindomain, "/macnuggets")
 
     # We don't know the domain yolo.swag
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         assert domain_url_available(auth, "yolo.swag", "/macnuggets")
 
 
@@ -55,13 +55,13 @@ def test_registerurl():
     assert not domain_url_available(auth, maindomain, "/urlregisterapp")
 
     # Try installing at same location
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_install(auth, "./tests/apps/register_url_app_ynh",
                 args="domain=%s&path=%s" % (maindomain, "/urlregisterapp"))
 
 
 def test_registerurl_baddomain():
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_install(auth, "./tests/apps/register_url_app_ynh",
                 args="domain=%s&path=%s" % ("yolo.swag", "/urlregisterapp"))
diff --git a/src/yunohost/tests/test_backuprestore.py b/src/yunohost/tests/test_backuprestore.py
index c9d4c6b15..abe5bb1c8 100644
--- a/src/yunohost/tests/test_backuprestore.py
+++ b/src/yunohost/tests/test_backuprestore.py
@@ -12,7 +12,7 @@ from yunohost.app import app_install, app_remove, app_ssowatconf
 from yunohost.app import _is_installed
 from yunohost.backup import backup_create, backup_restore, backup_list, backup_info, backup_delete
 from yunohost.domain import _get_maindomain
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 # Get main domain
 maindomain = ""
@@ -214,7 +214,7 @@ def test_backup_system_part_that_does_not_exists(mocker):
     mocker.spy(m18n, "n")
 
     # Create the backup
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=["yolol"], apps=None)
 
     m18n.n.assert_any_call('backup_hook_unknown', hook="yolol")
@@ -295,7 +295,7 @@ def test_backup_script_failure_handling(monkeypatch, mocker):
     monkeypatch.setattr("yunohost.backup.hook_exec", custom_hook_exec)
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["backup_recommended_app"])
 
     m18n.n.assert_any_call('backup_app_failed', app='backup_recommended_app')
@@ -315,7 +315,7 @@ def test_backup_not_enough_free_space(monkeypatch, mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["backup_recommended_app"])
 
     m18n.n.assert_any_call('not_enough_disk_space', path=ANY)
@@ -327,7 +327,7 @@ def test_backup_app_not_installed(mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["wordpress"])
 
     m18n.n.assert_any_call("unbackup_app", app="wordpress")
@@ -343,8 +343,9 @@ def test_backup_app_with_no_backup_script(mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_create(system=None, apps=["backup_recommended_app"])
+>>>>>>> modif YunohostError to YunohostError
 
     m18n.n.assert_any_call("backup_with_no_backup_script_for_app", app="backup_recommended_app")
     m18n.n.assert_any_call('backup_nothings_done')
@@ -420,7 +421,7 @@ def test_restore_app_script_failure_handling(monkeypatch, mocker):
 
     assert not _is_installed("wordpress")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["wordpress"])
 
@@ -441,7 +442,7 @@ def test_restore_app_not_enough_free_space(monkeypatch, mocker):
 
     assert not _is_installed("wordpress")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["wordpress"])
 
@@ -460,7 +461,7 @@ def test_restore_app_not_in_backup(mocker):
 
     mocker.spy(m18n, "n")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["yoloswag"])
 
@@ -480,7 +481,7 @@ def test_restore_app_already_installed(mocker):
     assert _is_installed("wordpress")
 
     mocker.spy(m18n, "n")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, system=None, name=backup_list()["archives"][0],
                              apps=["wordpress"])
 
@@ -544,7 +545,7 @@ def test_restore_archive_with_no_json(mocker):
     assert "badbackup" in backup_list()["archives"]
 
     mocker.spy(m18n, "n")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         backup_restore(auth, name="badbackup", force=True)
     m18n.n.assert_any_call('backup_invalid_archive')
 
diff --git a/src/yunohost/tests/test_changeurl.py b/src/yunohost/tests/test_changeurl.py
index eb10cd604..826ec659b 100644
--- a/src/yunohost/tests/test_changeurl.py
+++ b/src/yunohost/tests/test_changeurl.py
@@ -6,7 +6,7 @@ from moulinette.core import init_authenticator
 from yunohost.app import app_install, app_change_url, app_remove, app_map
 from yunohost.domain import _get_maindomain
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 # Instantiate LDAP Authenticator
 AUTH_IDENTIFIER = ('ldap', 'ldap-anonymous')
@@ -57,5 +57,5 @@ def test_appchangeurl_sameurl():
     install_changeurl_app("/changeurl")
     check_changeurl_app("/changeurl")
 
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         app_change_url(auth, "change_url_app", maindomain, "changeurl")
diff --git a/src/yunohost/tests/test_settings.py b/src/yunohost/tests/test_settings.py
index 746f5a9d4..afb9faee9 100644
--- a/src/yunohost/tests/test_settings.py
+++ b/src/yunohost/tests/test_settings.py
@@ -2,7 +2,7 @@ import os
 import json
 import pytest
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 from yunohost.settings import settings_get, settings_list, _get_settings, \
     settings_set, settings_reset, settings_reset_all, \
@@ -46,7 +46,7 @@ def test_settings_get_full_enum():
 
 
 def test_settings_get_doesnt_exists():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_get("doesnt.exists")
 
 
@@ -70,39 +70,39 @@ def test_settings_set_enum():
 
 
 def test_settings_set_doesexit():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("doesnt.exist", True)
 
 
 def test_settings_set_bad_type_bool():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.bool", 42)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.bool", "pouet")
 
 
 def test_settings_set_bad_type_int():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.int", True)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.int", "pouet")
 
 
 def test_settings_set_bad_type_string():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.string", True)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.string", 42)
 
 
 def test_settings_set_bad_value_enum():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", True)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", "e")
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", 42)
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_set("example.enum", "pouet")
 
 
@@ -119,7 +119,7 @@ def test_reset():
 
 
 def test_settings_reset_doesexit():
-    with pytest.raises(MoulinetteError):
+    with pytest.raises(YunohostError):
         settings_reset("doesnt.exist")
 
 
diff --git a/src/yunohost/tools.py b/src/yunohost/tools.py
index 8e7da9939..51c19ff34 100644
--- a/src/yunohost/tools.py
+++ b/src/yunohost/tools.py
@@ -40,7 +40,7 @@ import apt
 import apt.progress
 
 from moulinette import msettings, msignals, m18n
-from moulinette.core import MoulinetteError, init_authenticator
+from yunohost.utils.error import YunohostError, init_authenticator
 from moulinette.utils.log import getActionLogger
 from moulinette.utils.process import check_output
 from moulinette.utils.filesystem import read_json, write_to_json
@@ -112,7 +112,7 @@ def tools_ldapinit():
         pwd.getpwnam("admin")
     except KeyError:
         logger.error(m18n.n('ldap_init_failed_to_create_admin'))
-        raise MoulinetteError('installation_failed')
+        raise YunohostError('installation_failed')
 
     logger.success(m18n.n('ldap_initialized'))
     return auth
@@ -139,7 +139,7 @@ def tools_adminpw(auth, new_password, check_strength=True):
         auth.update("cn=admin", { "userPassword": new_hash, })
     except:
         logger.exception('unable to change admin password')
-        raise MoulinetteError('admin_password_change_failed')
+        raise YunohostError('admin_password_change_failed')
     else:
         # Write as root password
         try:
@@ -175,7 +175,7 @@ def tools_maindomain(operation_logger, auth, new_domain=None):
 
     # Check domain exists
     if new_domain not in domain_list(auth)['domains']:
-        raise MoulinetteError('domain_unknown')
+        raise YunohostError('domain_unknown')
 
     operation_logger.related_to.append(('domain', new_domain))
     operation_logger.start()
@@ -198,7 +198,7 @@ def tools_maindomain(operation_logger, auth, new_domain=None):
         _set_maindomain(new_domain)
     except Exception as e:
         logger.warning("%s" % e, exc_info=1)
-        raise MoulinetteError('maindomain_change_failed')
+        raise YunohostError('maindomain_change_failed')
 
     _set_hostname(new_domain)
 
@@ -247,7 +247,7 @@ def _set_hostname(hostname, pretty_hostname=None):
         if p.returncode != 0:
             logger.warning(command)
             logger.warning(out)
-            raise MoulinetteError('domain_hostname_failed')
+            raise YunohostError('domain_hostname_failed')
         else:
             logger.debug(out)
 
@@ -288,7 +288,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
 
     # Do some checks at first
     if os.path.isfile('/etc/yunohost/installed'):
-        raise MoulinetteError('yunohost_already_installed')
+        raise YunohostError('yunohost_already_installed')
 
     # Check password
     if not force_password:
@@ -317,7 +317,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
                 dyndns = True
             # If not, abort the postinstall
             else:
-                raise MoulinetteError('dyndns_unavailable', domain=domain)
+                raise YunohostError('dyndns_unavailable', domain=domain)
         else:
             dyndns = False
     else:
@@ -360,7 +360,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
         with open('/etc/ssowat/conf.json.persistent') as json_conf:
             ssowat_conf = json.loads(str(json_conf.read()))
     except ValueError as e:
-        raise MoulinetteError('ssowat_persistent_conf_read_error', error=str(e))
+        raise YunohostError('ssowat_persistent_conf_read_error', error=str(e))
     except IOError:
         ssowat_conf = {}
 
@@ -373,7 +373,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
         with open('/etc/ssowat/conf.json.persistent', 'w+') as f:
             json.dump(ssowat_conf, f, sort_keys=True, indent=4)
     except IOError as e:
-        raise MoulinetteError('ssowat_persistent_conf_write_error', error=str(e))
+        raise YunohostError('ssowat_persistent_conf_write_error', error=str(e))
 
     os.system('chmod 644 /etc/ssowat/conf.json.persistent')
 
@@ -400,7 +400,7 @@ def tools_postinstall(operation_logger, domain, password, ignore_dyndns=False,
 
         if p.returncode != 0:
             logger.warning(out)
-            raise MoulinetteError('yunohost_ca_creation_failed')
+            raise YunohostError('yunohost_ca_creation_failed')
         else:
             logger.debug(out)
 
@@ -476,7 +476,7 @@ def tools_update(ignore_apps=False, ignore_packages=False):
         # Update APT cache
         logger.debug(m18n.n('updating_apt_cache'))
         if not cache.update():
-            raise MoulinetteError('update_cache_failed')
+            raise YunohostError('update_cache_failed')
 
         cache.open(None)
         cache.upgrade(True)
@@ -495,7 +495,7 @@ def tools_update(ignore_apps=False, ignore_packages=False):
     if not ignore_apps:
         try:
             app_fetchlist()
-        except MoulinetteError:
+        except YunohostError:
             # FIXME : silent exception !?
             pass
 
@@ -626,7 +626,7 @@ def tools_diagnosis(auth, private=False):
     diagnosis['system'] = OrderedDict()
     try:
         disks = monitor_disk(units=['filesystem'], human_readable=True)
-    except (MoulinetteError, Fault) as e:
+    except (YunohostError, Fault) as e:
         logger.warning(m18n.n('diagnosis_monitor_disk_error', error=format(e)), exc_info=1)
     else:
         diagnosis['system']['disks'] = {}
@@ -642,7 +642,7 @@ def tools_diagnosis(auth, private=False):
 
     try:
         system = monitor_system(units=['cpu', 'memory'], human_readable=True)
-    except MoulinetteError as e:
+    except YunohostError as e:
         logger.warning(m18n.n('diagnosis_monitor_system_error', error=format(e)), exc_info=1)
     else:
         diagnosis['system']['memory'] = {
@@ -668,7 +668,7 @@ def tools_diagnosis(auth, private=False):
     # YNH Applications
     try:
         applications = app_list()['apps']
-    except MoulinetteError as e:
+    except YunohostError as e:
         diagnosis['applications'] = m18n.n('diagnosis_no_apps')
     else:
         diagnosis['applications'] = {}
@@ -800,7 +800,7 @@ def tools_migrations_list(pending=False, done=False):
 
     # Check for option conflict
     if pending and done:
-        raise MoulinetteError("migrations_list_conflict_pending_done")
+        raise YunohostError("migrations_list_conflict_pending_done")
 
     # Get all migrations
     migrations = _get_migrations_list()
@@ -857,7 +857,7 @@ def tools_migrations_migrate(target=None, skip=False, auto=False, accept_disclai
 
     # validate input, target must be "0" or a valid number
     elif target != 0 and target not in all_migration_numbers:
-        raise MoulinetteError('migrations_bad_value_for_target', ", ".join(map(str, all_migration_numbers)))
+        raise YunohostError('migrations_bad_value_for_target', ", ".join(map(str, all_migration_numbers)))
 
     logger.debug(m18n.n('migrations_current_target', target))
 
@@ -1063,7 +1063,7 @@ def _load_migration(migration_file):
         import traceback
         traceback.print_exc()
 
-        raise MoulinetteError('migrations_error_failed_to_load_migration',
+        raise YunohostError('migrations_error_failed_to_load_migration',
             number=number, name=name)
 
 def _skip_all_migrations():
diff --git a/src/yunohost/user.py b/src/yunohost/user.py
index 67cfe6cf1..313835fe0 100644
--- a/src/yunohost/user.py
+++ b/src/yunohost/user.py
@@ -34,7 +34,7 @@ import string
 import subprocess
 
 from moulinette import m18n
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 from moulinette.utils.log import getActionLogger
 from yunohost.service import service_status
 from yunohost.log import is_unit_operation
@@ -71,7 +71,7 @@ def user_list(auth, fields=None):
             if attr in keys:
                 attrs.append(attr)
             else:
-                raise MoulinetteError('field_invalid', attr)
+                raise YunohostError('field_invalid', attr)
     else:
         attrs = ['uid', 'cn', 'mail', 'mailuserquota', 'loginShell']
 
@@ -129,7 +129,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
     # 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 MoulinetteError('system_username_exists')
+        raise YunohostError('system_username_exists')
 
     main_domain = _get_maindomain()
     aliases = [
@@ -140,11 +140,11 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
     ]
 
     if mail in aliases:
-        raise MoulinetteError('mail_unavailable')
+        raise YunohostError('mail_unavailable')
 
     # Check that the mail domain exists
     if mail.split("@")[1] not in domain_list(auth)['domains']:
-        raise MoulinetteError(m18n.n('mail_domain_unknown',
+        raise YunohostError(m18n.n('mail_domain_unknown',
                                      domain=mail.split("@")[1]))
 
     operation_logger.start()
@@ -186,7 +186,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
             with open('/etc/ssowat/conf.json.persistent') as json_conf:
                 ssowat_conf = json.loads(str(json_conf.read()))
         except ValueError as e:
-            raise MoulinetteError('ssowat_persistent_conf_read_error', error=e.strerror)
+            raise YunohostError('ssowat_persistent_conf_read_error', error=e.strerror)
         except IOError:
             ssowat_conf = {}
 
@@ -196,7 +196,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
                 with open('/etc/ssowat/conf.json.persistent', 'w+') as f:
                     json.dump(ssowat_conf, f, sort_keys=True, indent=4)
             except IOError as e:
-                raise MoulinetteError('ssowat_persistent_conf_write_error', error=e.strerror)
+                raise YunohostError('ssowat_persistent_conf_write_error', error=e.strerror)
 
     if auth.add('uid=%s,ou=users' % username, attr_dict):
         # Invalidate passwd to take user creation into account
@@ -222,7 +222,7 @@ def user_create(operation_logger, auth, username, firstname, lastname, mail, pas
 
             return {'fullname': fullname, 'username': username, 'mail': mail}
 
-    raise MoulinetteError('user_creation_failed')
+    raise YunohostError('user_creation_failed')
 
 
 @is_unit_operation([('username', 'user')])
@@ -253,7 +253,7 @@ def user_delete(operation_logger, auth, username, purge=False):
             if purge:
                 subprocess.call(['rm', '-rf', '/home/{0}'.format(username)])
     else:
-        raise MoulinetteError('user_deletion_failed')
+        raise YunohostError('user_deletion_failed')
 
     app_ssowatconf(auth)
 
@@ -292,7 +292,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
     # Populate user informations
     result = auth.search(base='ou=users,dc=yunohost,dc=org', filter='uid=' + username, attrs=attrs_to_fetch)
     if not result:
-        raise MoulinetteError('user_unknown', user=username)
+        raise YunohostError('user_unknown', user=username)
     user = result[0]
 
     # Get modifications from arguments
@@ -323,10 +323,10 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
         ]
         auth.validate_uniqueness({'mail': mail})
         if mail[mail.find('@') + 1:] not in domains:
-            raise MoulinetteError(m18n.n('mail_domain_unknown',
+            raise YunohostError(m18n.n('mail_domain_unknown',
                                          domain=mail[mail.find('@') + 1:]))
         if mail in aliases:
-            raise MoulinetteError('mail_unavailable')
+            raise YunohostError('mail_unavailable')
 
         del user['mail'][0]
         new_attr_dict['mail'] = [mail] + user['mail']
@@ -337,7 +337,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
         for mail in add_mailalias:
             auth.validate_uniqueness({'mail': mail})
             if mail[mail.find('@') + 1:] not in domains:
-                raise MoulinetteError('mail_domain_unknown', domain=mail[mail.find('@') + 1:])
+                raise YunohostError('mail_domain_unknown', domain=mail[mail.find('@') + 1:])
             user['mail'].append(mail)
         new_attr_dict['mail'] = user['mail']
 
@@ -348,7 +348,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
             if len(user['mail']) > 1 and mail in user['mail'][1:]:
                 user['mail'].remove(mail)
             else:
-                raise MoulinetteError('mail_alias_remove_failed', mail=mail)
+                raise YunohostError('mail_alias_remove_failed', mail=mail)
         new_attr_dict['mail'] = user['mail']
 
     if add_mailforward:
@@ -367,7 +367,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
             if len(user['maildrop']) > 1 and mail in user['maildrop'][1:]:
                 user['maildrop'].remove(mail)
             else:
-                raise MoulinetteError('mail_forward_remove_failed', mail=mail)
+                raise YunohostError('mail_forward_remove_failed', mail=mail)
         new_attr_dict['maildrop'] = user['maildrop']
 
     if mailbox_quota is not None:
@@ -380,7 +380,7 @@ def user_update(operation_logger, auth, username, firstname=None, lastname=None,
         app_ssowatconf(auth)
         return user_info(auth, username)
     else:
-        raise MoulinetteError('user_update_failed')
+        raise YunohostError('user_update_failed')
 
 
 def user_info(auth, username):
@@ -405,7 +405,7 @@ def user_info(auth, username):
     if result:
         user = result[0]
     else:
-        raise MoulinetteError('user_unknown', user=username)
+        raise YunohostError('user_unknown', user=username)
 
     result_dict = {
         'username': user['uid'][0],
@@ -461,7 +461,7 @@ def user_info(auth, username):
     if result:
         return result_dict
     else:
-        raise MoulinetteError('user_info_failed')
+        raise YunohostError('user_info_failed')
 
 #
 # SSH subcategory
diff --git a/src/yunohost/utils/error.py b/src/yunohost/utils/error.py
index a2b6f5055..479176ee3 100644
--- a/src/yunohost/utils/error.py
+++ b/src/yunohost/utils/error.py
@@ -20,6 +20,7 @@
 """
 
 from moulinette.core import MoulinetteError
+from moulinette.__init__ import m18n
 
 class YunohostError(MoulinetteError):
     """Yunohost base exception"""
diff --git a/src/yunohost/utils/password.py b/src/yunohost/utils/password.py
index 6e8f5ba0a..b86fa23b1 100644
--- a/src/yunohost/utils/password.py
+++ b/src/yunohost/utils/password.py
@@ -84,14 +84,14 @@ class PasswordValidator(object):
         import errno
         import logging
         from moulinette import m18n
-        from moulinette.core import MoulinetteError
+        from yunohost.utils.error import YunohostError
         from moulinette.utils.log import getActionLogger
 
         logger = logging.getLogger('yunohost.utils.password')
 
         status, msg = self.validation_summary(password)
         if status == "error":
-            raise MoulinetteError(1, m18n.n(msg))
+            raise YunohostError(1, m18n.n(msg))
 
     def validation_summary(self, password):
         """
diff --git a/src/yunohost/utils/yunopaste.py b/src/yunohost/utils/yunopaste.py
index 475f29f79..7a3847873 100644
--- a/src/yunohost/utils/yunopaste.py
+++ b/src/yunohost/utils/yunopaste.py
@@ -4,7 +4,7 @@ import requests
 import json
 import errno
 
-from moulinette.core import MoulinetteError
+from yunohost.utils.error import YunohostError
 
 def yunopaste(data):
 
@@ -13,14 +13,14 @@ def yunopaste(data):
     try:
         r = requests.post("%s/documents" % paste_server, data=data, timeout=30)
     except Exception as e:
-        raise MoulinetteError("Something wrong happened while trying to paste data on paste.yunohost.org : %s" % str(e))
+        raise YunohostError("Something wrong happened while trying to paste data on paste.yunohost.org : %s" % str(e))
 
     if r.status_code != 200:
-        raise MoulinetteError("Something wrong happened while trying to paste data on paste.yunohost.org : %s, %s" % (r.status_code, r.text))
+        raise YunohostError("Something wrong happened while trying to paste data on paste.yunohost.org : %s, %s" % (r.status_code, r.text))
 
     try:
         url = json.loads(r.text)["key"]
     except:
-        raise MoulinetteError("Uhoh, couldn't parse the answer from paste.yunohost.org : %s" % r.text)
+        raise YunohostError("Uhoh, couldn't parse the answer from paste.yunohost.org : %s" % r.text)
 
     return "%s/raw/%s" % (paste_server, url)