Пример #1
0
        def _validate(context, body, gid):
            # validation checks
            if not self.is_valid_body(body, "network"):
                msg = _("Invalid request body")
                raise exception.InvalidInput(reason=msg)

            values = body.get("network")

            # Required item
            subnet = values.get("cidr")
            if subnet is None:
                msg = _("Ntwork cidr is required")
                raise exception.InvalidInput(reason=msg)
            if not utils.is_valid_cidr(subnet):
                msg = _("cidr must be a CIDR")
                raise exception.InvalidInput(reason=msg)

            # Non-essential items
            network_id = unicode(uuid.uuid4())
            name = values.get("name")
            if name is None or not name:
                name = "net-" + network_id
            else:
                name = name.strip()
                utils.check_string_length(
                    name, 'name', min_length=1, max_length=255)

            is_admin = values.get("is_admin")
            if is_admin:
                try:
                    is_admin = strutils.bool_from_string(
                        is_admin, strict=True)
                except ValueError:
                    msg = _("is_admin must be a boolean")
                    raise exception.InvalidInput(reason=msg)
            else:
                is_admin = False

            gateway = values.get("gateway")
            if gateway is not None and not utils.is_valid_ip_address(gateway):
                msg = _("Invalid gateway")
                raise exception.InvalidInput(reason=msg)

            dns_nameservers = values.get("dns_nameservers")
            if dns_nameservers is not None:
                if isinstance(dns_nameservers, list):
                    for dns in dns_nameservers:
                        if dns == "" or not utils.is_valid_ip_address(dns):
                            msg = _("Invalid dns_nameservers")
                            raise exception.InvalidInput(reason=msg)
                else:
                    msg = _("dns_nameservers must be list format")
                    raise exception.InvalidInput(reason=msg)

            ext_router = values.get("ext_router_id")
            if ext_router is not None and not uuidutils.is_uuid_like(
                    ext_router):
                msg = _("ext_router must be a uuid")
                raise exception.InvalidInput(reason=msg)

            valid_values1 = {}
            valid_values1["network_id"] = network_id
            valid_values1["gid"] = gid
            valid_values1["neutron_network_id"] = None
            valid_values1["is_admin"] = is_admin
            valid_values1["subnet"] = subnet
            valid_values1["ext_router"] = ext_router
            valid_values1["user_id"] = context.user_id
            valid_values1["project_id"] = context.project_id
            valid_values1["display_name"] = name
            valid_values1["status"] = "BUILDING"
            valid_values1["deleted"] = 0

            valid_values2 = {}
            valid_values2["gateway"] = gateway
            valid_values2["dns_nameservers"] = dns_nameservers

            valid_values = {}
            valid_values["db"] = valid_values1
            valid_values["opst"] = valid_values2

            return valid_values
Пример #2
0
        def _validate_securitygrouprules(securitygrouprules):

            valid_securitygrouprules = []
            for securitygroup in securitygrouprules:
                protocol = securitygroup.get("protocol")
                port_range_max = securitygroup.get("port_range_max")
                port_range_min = securitygroup.get("port_range_min")
                remote_securitygroup_id = securitygroup.get(
                    "remote_securitygroup_id")
                remote_ip_prefix = securitygroup.get("remote_ip_prefix")

                if not protocol:
                    msg = _("SecurityGroupRule protocol is required")
                    raise exception.InvalidInput(reason=msg)
                elif not utils.is_valid_protocol(protocol):
                    msg = _(
                        "SecurityGroupRule protocol should be tcp or udp or "
                        "icmp")
                    raise exception.InvalidInput(reason=msg)

                if not remote_securitygroup_id and not remote_ip_prefix:
                    msg = _(
                        "SecurityGroupRule either remote_securitygroup_id or "
                        "remote_ip_prefix is required")
                    raise exception.InvalidInput(reason=msg)
                elif remote_securitygroup_id and remote_ip_prefix:
                    msg = _(
                        "SecurityGroupRule either remote_securitygroup_id or "
                        "remote_ip_prefix is required")
                    raise exception.InvalidInput(reason=msg)
                elif remote_securitygroup_id is not None:
                    if not uuidutils.is_uuid_like(remote_securitygroup_id):
                        raise exception.SecuritygroupNotFound(
                            securitygroup_id=remote_securitygroup_id)
                elif remote_ip_prefix is not None:
                    if not utils.is_valid_cidr(remote_ip_prefix):
                        msg = _(
                            "SecurityGroupRule remote_ip_prefix should be "
                            "cidr format")
                        raise exception.InvalidInput(reason=msg)

                if protocol in ["tcp", "udp"]:
                    if port_range_max is None:
                        msg = _("SecurityGroupRule port_range_max is "
                                "required")
                        raise exception.InvalidInput(reason=msg)
                    utils.validate_integer(
                        port_range_max, 'port_range_max', min_value=1,
                        max_value=65535)
                    if port_range_min:
                        utils.validate_integer(
                            port_range_min, 'port_range_min', min_value=1,
                            max_value=65535)
                        if port_range_min > port_range_max:
                            msg = _(
                                "SecurityGroupRule port_range_min should be "
                                "lower than port_range_max")
                            raise exception.InvalidInput(reason=msg)
                elif protocol == "icmp":
                    port_range_max = None
                    port_range_min = None

                valid_securitygrouprules.append({
                    "protocol": protocol,
                    "port_range_max": port_range_max,
                    "port_range_min": port_range_min,
                    "remote_securitygroup_id": remote_securitygroup_id,
                    "remote_ip_prefix": unicode(netaddr
                                                .IPNetwork(remote_ip_prefix))
                    if remote_ip_prefix else remote_ip_prefix
                })
            return valid_securitygrouprules