Python attributes.is_attr_set函数代码示例

    def create_port(self, context, port):
        if attr.is_attr_set(port['port'][psec.PORTSECURITY]):
            self._enforce_set_auth(context, port,
                                   self.port_security_enabled_create)
        p = port['port']
        with context.session.begin(subtransactions=True):
            p[ext_sg.SECURITYGROUPS] = self._get_security_groups_on_port(
                context, port)
            quantum_db = super(PortSecurityTestPlugin, self).create_port(
                context, port)
            p.update(quantum_db)

            (port_security, has_ip) = self._determine_port_security_and_has_ip(
                context, p)
            p[psec.PORTSECURITY] = port_security
            self._process_port_security_create(context, p)

            if (attr.is_attr_set(p.get(ext_sg.SECURITYGROUPS)) and
                not (port_security and has_ip)):
                raise psec.PortSecurityAndIPRequiredForSecurityGroups()

            # Port requires ip and port_security enabled for security group
            if has_ip and port_security:
                self._ensure_default_security_group_on_port(context, port)

            if (p.get(ext_sg.SECURITYGROUPS) and p[psec.PORTSECURITY]):
                self._process_port_create_security_group(
                    context, p['id'], p[ext_sg.SECURITYGROUPS])

            self._extend_port_dict_security_group(context, p)
            self._extend_port_port_security_dict(context, p)

        return port['port']

    def _process_provider_create(self, context, attrs):
        network_type = attrs.get(provider.NETWORK_TYPE)
        physical_network = attrs.get(provider.PHYSICAL_NETWORK)
        segmentation_id = attrs.get(provider.SEGMENTATION_ID)

        network_type_set = attributes.is_attr_set(network_type)
        physical_network_set = attributes.is_attr_set(physical_network)
        segmentation_id_set = attributes.is_attr_set(segmentation_id)

        if not (network_type_set or physical_network_set or
                segmentation_id_set):
            return (None, None, None)

        if not network_type_set:
            msg = _("provider:network_type required")
            raise q_exc.InvalidInput(error_message=msg)
        elif network_type == constants.TYPE_FLAT:
            if segmentation_id_set:
                msg = _("provider:segmentation_id specified for flat network")
                raise q_exc.InvalidInput(error_message=msg)
            else:
                segmentation_id = constants.FLAT_VLAN_ID
        elif network_type == constants.TYPE_VLAN:
            if not segmentation_id_set:
                msg = _("provider:segmentation_id required")
                raise q_exc.InvalidInput(error_message=msg)
            if segmentation_id < 1 or segmentation_id > 4094:
                msg = _("provider:segmentation_id out of range "
                        "(1 through 4094)")
                raise q_exc.InvalidInput(error_message=msg)
        elif network_type == constants.TYPE_LOCAL:
            if physical_network_set:
                msg = _("provider:physical_network specified for local "
                        "network")
                raise q_exc.InvalidInput(error_message=msg)
            else:
                physical_network = None
            if segmentation_id_set:
                msg = _("provider:segmentation_id specified for local "
                        "network")
                raise q_exc.InvalidInput(error_message=msg)
            else:
                segmentation_id = constants.LOCAL_VLAN_ID
        else:
            msg = _("provider:network_type %s not supported") % network_type
            raise q_exc.InvalidInput(error_message=msg)

        if network_type in [constants.TYPE_VLAN, constants.TYPE_FLAT]:
            if physical_network_set:
                if physical_network not in self.network_vlan_ranges:
                    msg = (_("Unknown provider:physical_network %s") %
                           physical_network)
                    raise q_exc.InvalidInput(error_message=msg)
            elif 'default' in self.network_vlan_ranges:
                physical_network = 'default'
            else:
                msg = _("provider:physical_network required")
                raise q_exc.InvalidInput(error_message=msg)

        return (network_type, physical_network, segmentation_id)

    def test_is_attr_set(self):
        data = attributes.ATTR_NOT_SPECIFIED
        self.assertIs(attributes.is_attr_set(data), False)

        data = None
        self.assertIs(attributes.is_attr_set(data), False)

        data = "I'm set"
        self.assertIs(attributes.is_attr_set(data), True)

 def create_network(self, session, attrs):
     segmentation_id = attrs.get(provider.SEGMENTATION_ID)
     if attributes.is_attr_set(segmentation_id):
         physical_network = attrs.get(provider.PHYSICAL_NETWORK)
         if not attributes.is_attr_set(physical_network):
             msg = _("physical_network not provided")
             raise q_exc.InvalidInput(error_message=msg)
         self._db.reserve_specific_vlan(session, physical_network, segmentation_id)
     else:
         (physical_network, segmentation_id) = self._db.reserve_vlan(session)
         attrs[provider.SEGMENTATION_ID] = segmentation_id
         attrs[provider.PHYSICAL_NETWORK] = physical_network

    def _check_provider_update(self, context, attrs):
        network_type = attrs.get(provider.NETWORK_TYPE)
        physical_network = attrs.get(provider.PHYSICAL_NETWORK)
        segmentation_id = attrs.get(provider.SEGMENTATION_ID)

        network_type_set = attributes.is_attr_set(network_type)
        physical_network_set = attributes.is_attr_set(physical_network)
        segmentation_id_set = attributes.is_attr_set(segmentation_id)

        if not (network_type_set or physical_network_set or segmentation_id_set):
            return

        msg = _("Plugin does not support updating provider attributes")
        raise q_exc.InvalidInput(error_message=msg)

    def _process_provider_create(self, context, attrs):
        network_type = attrs.get('provider:network_type')
        physical_network = attrs.get('provider:physical_network')
        vlan_id = attrs.get('provider:vlan_id')

        network_type_set = attributes.is_attr_set(network_type)
        physical_network_set = attributes.is_attr_set(physical_network)
        vlan_id_set = attributes.is_attr_set(vlan_id)

        if not (network_type_set or physical_network_set or vlan_id_set):
            return (None, None, None)

        # Authorize before exposing plugin details to client
        self._enforce_provider_set_auth(context, attrs)

        if not network_type_set:
            msg = _("provider:network_type required")
            raise q_exc.InvalidInput(error_message=msg)
        elif network_type == 'flat':
            msg = _("plugin does not support flat networks")
            raise q_exc.InvalidInput(error_message=msg)
        # REVISIT(rkukura) to be enabled in phase 3
        #    if vlan_id_set:
        #        msg = _("provider:vlan_id specified for flat network")
        #        raise q_exc.InvalidInput(error_message=msg)
        #    else:
        #        vlan_id = db.FLAT_VLAN_ID
        elif network_type == 'vlan':
            if not vlan_id_set:
                msg = _("provider:vlan_id required")
                raise q_exc.InvalidInput(error_message=msg)
        else:
            msg = _("invalid provider:network_type %s" % network_type)
            raise q_exc.InvalidInput(error_message=msg)

        if physical_network_set:
            msg = _("plugin does not support specifying physical_network")
            raise q_exc.InvalidInput(error_message=msg)
        # REVISIT(rkukura) to be enabled in phase 3
        #    if physical_network not in self.physical_networks:
        #        msg = _("unknown provider:physical_network %s" %
        #                physical_network)
        #        raise q_exc.InvalidInput(error_message=msg)
        #elif 'default' in self.physical_networks:
        #    physical_network = 'default'
        #else:
        #    msg = _("provider:physical_network required")
        #    raise q_exc.InvalidInput(error_message=msg)

        return (network_type, physical_network, vlan_id)

    def _process_provider_create(self, context, attrs):
        network_type = attrs.get(provider.NETWORK_TYPE)
        physical_network = attrs.get(provider.PHYSICAL_NETWORK)
        segmentation_id = attrs.get(provider.SEGMENTATION_ID)

        network_type_set = attributes.is_attr_set(network_type)
        physical_network_set = attributes.is_attr_set(physical_network)
        segmentation_id_set = attributes.is_attr_set(segmentation_id)

        if not (network_type_set or physical_network_set or
                segmentation_id_set):
            return (None, None, None)

        # Authorize before exposing plugin details to client
        self._enforce_provider_set_auth(context, attrs)

        if not network_type_set:
            msg = _("provider:network_type required")
            raise q_exc.InvalidInput(error_message=msg)
        elif network_type == constants.TYPE_FLAT:
            if segmentation_id_set:
                msg = _("provider:segmentation_id specified for flat network")
                raise q_exc.InvalidInput(error_message=msg)
            else:
                segmentation_id = constants.FLAT_VLAN_ID
        elif network_type == constants.TYPE_VLAN:
            if not segmentation_id_set:
                msg = _("provider:segmentation_id required")
                raise q_exc.InvalidInput(error_message=msg)
            if segmentation_id < 1 or segmentation_id > 4094:
                msg = _("provider:segmentation_id out of range "
                        "(1 through 4094)")
                raise q_exc.InvalidInput(error_message=msg)
        else:
            msg = _("invalid provider:network_type %s" % network_type)
            raise q_exc.InvalidInput(error_message=msg)

        if physical_network_set:
            if physical_network not in self.network_vlan_ranges:
                msg = _("unknown provider:physical_network %s" %
                        physical_network)
                raise q_exc.InvalidInput(error_message=msg)
        elif 'default' in self.network_vlan_ranges:
            physical_network = 'default'
        else:
            msg = _("provider:physical_network required")
            raise q_exc.InvalidInput(error_message=msg)

        return (network_type, physical_network, segmentation_id)

 def _process_port_create_security_group(self, context, port_id,
                                         security_group_id):
     if not attr.is_attr_set(security_group_id):
         return
     for security_group_id in security_group_id:
         self._create_port_security_group_binding(context, port_id,
                                                  security_group_id)

    def _process_l3_update(self, context, net_data, net_id):

        new_value = net_data.get(l3.EXTERNAL)
        if not attributes.is_attr_set(new_value):
            return

        self._enforce_l3_set_auth(context, net_data)
        existing_value = self._network_is_external(context, net_id)

        if existing_value == new_value:
            return

        if new_value:
            context.session.add(ExternalNetwork(network_id=net_id))
        else:
            # must make sure we do not have any external gateway ports
            # (and thus, possible floating IPs) on this network before
            # allow it to be update to external=False
            port = context.session.query(models_v2.Port).filter_by(
                device_owner=DEVICE_OWNER_ROUTER_GW,
                network_id=net_id).first()
            if port:
                raise l3.ExternalNetworkInUse(net_id=net_id)

            context.session.query(ExternalNetwork).filter_by(
                network_id=net_id).delete()

 def _check_update_deletes_security_groups(self, port):
     """Return True if port has as a security group and it's value
     is either [] or not is_attr_set, otherwise return False"""
     if (ext_sg.SECURITYGROUPS in port['port'] and
         not (attr.is_attr_set(port['port'][ext_sg.SECURITYGROUPS])
              and port['port'][ext_sg.SECURITYGROUPS] != [])):
         return True
     return False

    def _process_provider_create(self, context, attrs):
        network_type = self._get_attribute(attrs, provider.NETWORK_TYPE)
        physical_network = self._get_attribute(attrs,
                                               provider.PHYSICAL_NETWORK)
        segmentation_id = self._get_attribute(attrs, provider.SEGMENTATION_ID)

        if attributes.is_attr_set(network_type):
            segment = {api.NETWORK_TYPE: network_type,
                       api.PHYSICAL_NETWORK: physical_network,
                       api.SEGMENTATION_ID: segmentation_id}
            return self.type_manager.validate_provider_segment(segment)

        if (attributes.is_attr_set(attrs.get(provider.PHYSICAL_NETWORK)) or
            attributes.is_attr_set(attrs.get(provider.SEGMENTATION_ID))):
            msg = _("network_type required if other provider attributes "
                    "specified")
            raise exc.InvalidInput(error_message=msg)

 def _check_update_has_security_groups(self, port):
     """Return True if port has as a security group and False if the
     security_group field is is_attr_set or []."""
     if (ext_sg.SECURITYGROUPS in port['port'] and
         (attr.is_attr_set(port['port'][ext_sg.SECURITYGROUPS]) and
          port['port'][ext_sg.SECURITYGROUPS] != [])):
         return True
     return False

    def _check_provider_update(self, context, attrs):
        network_type = attrs.get('provider:network_type')
        physical_network = attrs.get('provider:physical_network')
        vlan_id = attrs.get('provider:vlan_id')

        network_type_set = attributes.is_attr_set(network_type)
        physical_network_set = attributes.is_attr_set(physical_network)
        vlan_id_set = attributes.is_attr_set(vlan_id)

        if not (network_type_set or physical_network_set or vlan_id_set):
            return

        # Authorize before exposing plugin details to client
        self._enforce_provider_set_auth(context, attrs)

        msg = _("plugin does not support updating provider attributes")
        raise q_exc.InvalidInput(error_message=msg)

    def _check_provider_update(self, context, attrs):
        network_type = attrs.get(provider.NETWORK_TYPE)
        physical_network = attrs.get(provider.PHYSICAL_NETWORK)
        segmentation_id = attrs.get(provider.SEGMENTATION_ID)

        network_type_set = attributes.is_attr_set(network_type)
        physical_network_set = attributes.is_attr_set(physical_network)
        segmentation_id_set = attributes.is_attr_set(segmentation_id)

        if not (network_type_set or physical_network_set or
                segmentation_id_set):
            return

        # Authorize before exposing plugin details to client
        self._enforce_set_auth(context, attrs, self.network_set)

        msg = _("plugin does not support updating provider attributes")
        raise q_exc.InvalidInput(error_message=msg)

    def _process_provider_create(self, context, attrs):
        network_type = attrs.get('provider:network_type')
        physical_network = attrs.get('provider:physical_network')
        vlan_id = attrs.get('provider:vlan_id')

        network_type_set = attributes.is_attr_set(network_type)
        physical_network_set = attributes.is_attr_set(physical_network)
        vlan_id_set = attributes.is_attr_set(vlan_id)

        if not (network_type_set or physical_network_set or vlan_id_set):
            return (None, None, None)

        # Authorize before exposing plugin details to client
        self._enforce_provider_set_auth(context, attrs)

        if not network_type_set:
            msg = _("provider:network_type required")
            raise q_exc.InvalidInput(error_message=msg)
        elif network_type == 'flat':
            if vlan_id_set:
                msg = _("provider:vlan_id specified for flat network")
                raise q_exc.InvalidInput(error_message=msg)
            else:
                vlan_id = lconst.FLAT_VLAN_ID
        elif network_type == 'vlan':
            if not vlan_id_set:
                msg = _("provider:vlan_id required")
                raise q_exc.InvalidInput(error_message=msg)
        else:
            msg = _("invalid provider:network_type %s" % network_type)
            raise q_exc.InvalidInput(error_message=msg)

        if physical_network_set:
            if physical_network not in self.network_vlan_ranges:
                msg = _("unknown provider:physical_network %s" %
                        physical_network)
                raise q_exc.InvalidInput(error_message=msg)
        elif 'default' in self.network_vlan_ranges:
            physical_network = 'default'
        else:
            msg = _("provider:physical_network required")
            raise q_exc.InvalidInput(error_message=msg)

        return (network_type, physical_network, vlan_id)