unrhodecode/rhodecode/model/validation_schema/validators.py

# Copyright (C) 2011-2024 RhodeCode GmbH
#
# This program is free software: you can redistribute it and/or modify
# it under the terms of the GNU Affero General Public License, version 3
# (only), as published by the Free Software Foundation.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU Affero General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#
# This program is dual-licensed. If you wish to learn more about the
# RhodeCode Enterprise Edition, including its added features, Support services,
# and proprietary license terms, please see https://rhodecode.com/licenses/

import re
import logging

import ipaddress
import colander

from rhodecode.translation import _
from rhodecode.lib.utils2 import glob2re
from rhodecode.lib.str_utils import safe_str
from rhodecode.lib.ext_json import json, sjson

log = logging.getLogger(__name__)


def ip_addr_validator(node, value):
    try:
        # this raises an ValueError if address is not IpV4 or IpV6
        ipaddress.ip_network(safe_str(value), strict=False)
    except ValueError:
        msg = _("Please enter a valid IPv4 or IpV6 address")
        raise colander.Invalid(node, msg)


class IpAddrValidator(object):
    def __init__(self, strict=True):
        self.strict = strict

    def __call__(self, node, value):
        try:
            # this raises an ValueError if address is not IpV4 or IpV6
            ipaddress.ip_network(safe_str(value), strict=self.strict)
        except ValueError:
            msg = _("Please enter a valid IPv4 or IpV6 address")
            raise colander.Invalid(node, msg)


def glob_validator(node, value):
    try:
        re.compile("^" + glob2re(value) + "$")
    except Exception:
        msg = _("Invalid glob pattern")
        raise colander.Invalid(node, msg)


def valid_name_validator(node, value):
    from rhodecode.model.validation_schema import types

    if value is types.RootLocation:
        return

    msg = _("Name must start with a letter or number. Got `{}`").format(value)
    if not re.match(r"^[a-zA-Z0-9]+", value):
        raise colander.Invalid(node, msg)


def no_git_suffix_validator(node, value):
    if value.endswith(".git"):
        msg = _("Repository name cannot end with .git")
        raise colander.Invalid(node, msg)


def forbidden_repo_name_validator(node, value):
    from rhodecode.apps._base import RESERVED_NAMES

    if value in RESERVED_NAMES:
        msg = _("Repository with name `{}` is forbidden").format(value)
        raise colander.Invalid(node, msg)


def forbidden_repo_group_name_validator(node, value):
    from rhodecode.apps._base import RESERVED_NAMES

    if value in RESERVED_NAMES:
        msg = _("Repository group with name `{}` is forbidden").format(value)
        raise colander.Invalid(node, msg)


class InvalidCloneUrl(Exception):
    allowed_prefixes = ()


def url_validator(url, repo_type, config):
    from rhodecode.lib.vcs.backends.hg import MercurialRepository
    from rhodecode.lib.vcs.backends.git import GitRepository
    from rhodecode.lib.vcs.backends.svn import SubversionRepository

    if repo_type == "hg":
        allowed_prefixes = ("http", "svn+http", "git+http")

        if "http" in url[:4]:
            # initially check if it's at least the proper URL
            # or does it pass basic auth

            return MercurialRepository.check_url(url, config)
        elif "svn+http" in url[:8]:  # svn->hg import
            SubversionRepository.check_url(url, config)
        elif "git+http" in url[:8]:  # git->hg import
            raise NotImplementedError()
        else:
            exc = InvalidCloneUrl(
                "Clone from URI %s not allowed. "
                "Allowed url must start with one of %s" % (url, ",".join(allowed_prefixes))
            )
            exc.allowed_prefixes = allowed_prefixes
            raise exc

    elif repo_type == "git":
        allowed_prefixes = ("http", "svn+http", "hg+http")
        if "http" in url[:4]:
            # initially check if it's at least the proper URL
            # or does it pass basic auth
            return GitRepository.check_url(url, config)
        elif "svn+http" in url[:8]:  # svn->git import
            raise NotImplementedError()
        elif "hg+http" in url[:8]:  # hg->git import
            raise NotImplementedError()
        else:
            exc = InvalidCloneUrl(
                "Clone from URI %s not allowed. "
                "Allowed url must start with one of %s" % (url, ",".join(allowed_prefixes))
            )
            exc.allowed_prefixes = allowed_prefixes
            raise exc
    elif repo_type == "svn":
        # no validation for SVN yet
        return

    raise InvalidCloneUrl(f"Invalid repo type specified: `{repo_type}`")


class CloneUriValidator(object):
    def __init__(self, repo_type):
        self.repo_type = repo_type

    def __call__(self, node, value):
        from rhodecode.lib.utils import make_db_config

        try:
            config = make_db_config(clear_session=False)
            url_validator(value, self.repo_type, config)
        except InvalidCloneUrl as e:
            log.warning(e)
            raise colander.Invalid(node, str(e))
        except Exception as e:
            log.exception("Url validation failed")
            reason = repr(e)
            reason = reason.replace("<", "&lt;").replace(">", "&gt;")
            msg = _("invalid clone url or credentials for {repo_type} repository. Reason: {reason}").format(
                reason=reason, repo_type=self.repo_type
            )
            raise colander.Invalid(node, msg)


def json_validator(node, value):
    try:
        json.loads(value)
    except (Exception,):
        msg = _("Please enter a valid json object")
        raise colander.Invalid(node, msg)


def json_validator_with_exc(node, value):
    try:
        json.loads(value)
    except (Exception,) as e:
        msg = _(f"Please enter a valid json object type={type(value)}: `{e}`")
        raise colander.Invalid(node, msg)