Exemple #1
0
    def validate(self):
        """Validate user parameters."""
        image = self.properties.get(self.IMAGE)

        # It's okay if there's no script, as long as user_data and
        # metadata are both empty
        if image and self.script is None and self.has_userdata:
            msg = _("user_data is not supported for image %s.") % image
            raise exception.StackValidationFailed(message=msg)

        # Validate that the personality does not contain a reserved
        # key and that the number of personalities does not exceed the
        # Rackspace limit.
        personality = self.properties.get(self.PERSONALITY)
        if personality:
            limits = nova_utils.absolute_limits(self.nova())

            # One personality will be used for an SSH key
            personality_limit = limits['maxPersonality'] - 1

            if "/root/.ssh/authorized_keys" in personality:
                msg = _('The personality property may not contain a key '
                        'of "/root/.ssh/authorized_keys"')
                raise exception.StackValidationFailed(message=msg)

            elif len(personality) > personality_limit:
                msg = _("The personality property may not contain greater "
                        "than %s entries.") % personality_limit
                raise exception.StackValidationFailed(message=msg)

        super(CloudServer, self).validate()

        # Validate that user_data is passed for servers with bootable
        # volumes AFTER validating that the server has either an image
        # or a bootable volume in Server.validate()
        if not image and self.has_userdata:
            msg = _("user_data scripts are not supported with bootable "
                    "volumes.")
            raise exception.StackValidationFailed(message=msg)
Exemple #2
0
    def validate(self):
        """Validate user parameters."""
        image = self.properties.get(self.IMAGE)

        # It's okay if there's no script, as long as user_data and
        # metadata are both empty
        if image and self.script is None and self.has_userdata:
            msg = _("user_data is not supported for image %s.") % image
            raise exception.StackValidationFailed(message=msg)

        # Validate that the personality does not contain a reserved
        # key and that the number of personalities does not exceed the
        # Rackspace limit.
        personality = self.properties.get(self.PERSONALITY)
        if personality:
            limits = nova_utils.absolute_limits(self.nova())

            # One personality will be used for an SSH key
            personality_limit = limits['maxPersonality'] - 1

            if "/root/.ssh/authorized_keys" in personality:
                msg = _('The personality property may not contain a key '
                        'of "/root/.ssh/authorized_keys"')
                raise exception.StackValidationFailed(message=msg)

            elif len(personality) > personality_limit:
                msg = _("The personality property may not contain greater "
                        "than %s entries.") % personality_limit
                raise exception.StackValidationFailed(message=msg)

        super(CloudServer, self).validate()

        # Validate that user_data is passed for servers with bootable
        # volumes AFTER validating that the server has either an image
        # or a bootable volume in Server.validate()
        if not image and self.has_userdata:
            msg = _("user_data scripts are not supported with bootable "
                    "volumes.")
            raise exception.StackValidationFailed(message=msg)
Exemple #3
0
    def validate(self):
        '''
        Validate any of the provided params
        '''
        super(Server, self).validate()

        # either volume_id or snapshot_id needs to be specified, but not both
        # for block device mapping.
        bdm = self.properties.get(self.BLOCK_DEVICE_MAPPING) or []
        bootable_vol = False
        for mapping in bdm:
            device_name = mapping[self.BLOCK_DEVICE_MAPPING_DEVICE_NAME]
            if device_name == 'vda':
                bootable_vol = True

            volume_id = mapping.get(self.BLOCK_DEVICE_MAPPING_VOLUME_ID)
            snapshot_id = mapping.get(self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if volume_id and snapshot_id:
                raise exception.ResourcePropertyConflict(
                    self.BLOCK_DEVICE_MAPPING_VOLUME_ID,
                    self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if not volume_id and not snapshot_id:
                msg = _('Either volume_id or snapshot_id must be specified for'
                        ' device mapping %s') % device_name
                raise exception.StackValidationFailed(message=msg)

        # make sure the image exists if specified.
        image = self.properties.get(self.IMAGE)
        if not image and not bootable_vol:
            msg = _('Neither image nor bootable volume is specified for'
                    ' instance %s') % self.name
            raise exception.StackValidationFailed(message=msg)

        # network properties 'uuid' and 'network' shouldn't be used
        # both at once for all networks
        networks = self.properties.get(self.NETWORKS) or []
        # record if any networks include explicit ports
        networks_with_port = False
        for network in networks:
            networks_with_port = networks_with_port or \
                network.get(self.NETWORK_PORT)
            if network.get(self.NETWORK_UUID) and network.get(self.NETWORK_ID):
                msg = _('Properties "%(uuid)s" and "%(id)s" are both set '
                        'to the network "%(network)s" for the server '
                        '"%(server)s". The "%(uuid)s" property is deprecated. '
                        'Use only "%(id)s" property.'
                        '') % dict(uuid=self.NETWORK_UUID,
                                   id=self.NETWORK_ID,
                                   network=network[self.NETWORK_ID],
                                   server=self.name)
                raise exception.StackValidationFailed(message=msg)
            elif network.get(self.NETWORK_UUID):
                LOG.info(_('For the server "%(server)s" the "%(uuid)s" '
                           'property is set to network "%(network)s". '
                           '"%(uuid)s" property is deprecated. Use '
                           '"%(id)s"  property instead.')
                         % dict(uuid=self.NETWORK_UUID,
                                id=self.NETWORK_ID,
                                network=network[self.NETWORK_ID],
                                server=self.name))

        # retrieve provider's absolute limits if it will be needed
        metadata = self.properties.get(self.METADATA)
        personality = self.properties.get(self.PERSONALITY)
        if metadata is not None or personality:
            limits = nova_utils.absolute_limits(self.nova())

        # if 'security_groups' present for the server and explict 'port'
        # in one or more entries in 'networks', raise validation error
        if networks_with_port and self.properties.get(self.SECURITY_GROUPS):
            raise exception.ResourcePropertyConflict(
                self.SECURITY_GROUPS,
                "/".join([self.NETWORKS, self.NETWORK_PORT]))

        # verify that the number of metadata entries is not greater
        # than the maximum number allowed in the provider's absolute
        # limits
        if metadata is not None:
            msg = _('Instance metadata must not contain greater than %s '
                    'entries.  This is the maximum number allowed by your '
                    'service provider') % limits['maxServerMeta']
            self._check_maximum(len(metadata),
                                limits['maxServerMeta'], msg)

        # verify the number of personality files and the size of each
        # personality file against the provider's absolute limits
        if personality:
            msg = _("The personality property may not contain "
                    "greater than %s entries.") % limits['maxPersonality']
            self._check_maximum(len(personality),
                                limits['maxPersonality'], msg)

            for path, contents in personality.items():
                msg = (_("The contents of personality file \"%(path)s\" "
                         "is larger than the maximum allowed personality "
                         "file size (%(max_size)s bytes).") %
                       {'path': path,
                        'max_size': limits['maxPersonalitySize']})
                self._check_maximum(len(bytes(contents)),
                                    limits['maxPersonalitySize'], msg)
Exemple #4
0
    def validate(self):
        '''
        Validate any of the provided params
        '''
        super(Server, self).validate()

        # either volume_id or snapshot_id needs to be specified, but not both
        # for block device mapping.
        bdm = self.properties.get(self.BLOCK_DEVICE_MAPPING) or []
        bootable_vol = False
        for mapping in bdm:
            device_name = mapping[self.BLOCK_DEVICE_MAPPING_DEVICE_NAME]
            if device_name == 'vda':
                bootable_vol = True

            volume_id = mapping.get(self.BLOCK_DEVICE_MAPPING_VOLUME_ID)
            snapshot_id = mapping.get(self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if volume_id and snapshot_id:
                raise exception.ResourcePropertyConflict(
                    self.BLOCK_DEVICE_MAPPING_VOLUME_ID,
                    self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if not volume_id and not snapshot_id:
                msg = _('Either volume_id or snapshot_id must be specified for'
                        ' device mapping %s') % device_name
                raise exception.StackValidationFailed(message=msg)

        # make sure the image exists if specified.
        image = self.properties.get(self.IMAGE)
        if image:
            nova_utils.get_image_id(self.nova(), image)
        elif not image and not bootable_vol:
            msg = _('Neither image nor bootable volume is specified for'
                    ' instance %s') % self.name
            raise exception.StackValidationFailed(message=msg)
        # network properties 'uuid' and 'network' shouldn't be used
        # both at once for all networks
        networks = self.properties.get(self.NETWORKS) or []
        for network in networks:
            if network.get(self.NETWORK_UUID) and network.get(self.NETWORK_ID):
                msg = _('Properties "%(uuid)s" and "%(id)s" are both set '
                        'to the network "%(network)s" for the server '
                        '"%(server)s". The "%(uuid)s" property is deprecated. '
                        'Use only "%(id)s" property.'
                        '') % dict(uuid=self.NETWORK_UUID,
                                   id=self.NETWORK_ID,
                                   network=network[self.NETWORK_ID],
                                   server=self.name)
                raise exception.StackValidationFailed(message=msg)
            elif network.get(self.NETWORK_UUID):
                logger.info(
                    _('For the server "%(server)s" the "%(uuid)s" '
                      'property is set to network "%(network)s". '
                      '"%(uuid)s" property is deprecated. Use '
                      '"%(id)s"  property instead.'
                      '') % dict(uuid=self.NETWORK_UUID,
                                 id=self.NETWORK_ID,
                                 network=network[self.NETWORK_ID],
                                 server=self.name))

        # retrieve provider's absolute limits if it will be needed
        metadata = self.properties.get(self.METADATA)
        personality = self._personality()
        if metadata is not None or personality is not None:
            limits = nova_utils.absolute_limits(self.nova())

        # verify that the number of metadata entries is not greater
        # than the maximum number allowed in the provider's absolute
        # limits
        if metadata is not None:
            if len(metadata) > limits['maxServerMeta']:
                msg = _('Instance metadata must not contain greater than %s '
                        'entries.  This is the maximum number allowed by your '
                        'service provider') % limits['maxServerMeta']
                raise exception.StackValidationFailed(message=msg)

        # verify the number of personality files and the size of each
        # personality file against the provider's absolute limits
        if personality is not None:
            if len(personality) > limits['maxPersonality']:
                msg = _("The personality property may not contain "
                        "greater than %s entries.") % limits['maxPersonality']
                raise exception.StackValidationFailed(message=msg)

            for path, contents in personality.items():
                if len(bytes(contents)) > limits['maxPersonalitySize']:
                    msg = (_("The contents of personality file \"%(path)s\" "
                             "is larger than the maximum allowed personality "
                             "file size (%(max_size)s bytes).") % {
                                 'path': path,
                                 'max_size': limits['maxPersonalitySize']
                             })
                    raise exception.StackValidationFailed(message=msg)
Exemple #5
0
    def validate(self):
        '''
        Validate any of the provided params
        '''
        super(Server, self).validate()

        # check validity of key
        key_name = self.properties.get(self.KEY_NAME)
        if key_name:
            nova_utils.get_keypair(self.nova(), key_name)

        # either volume_id or snapshot_id needs to be specified, but not both
        # for block device mapping.
        bdm = self.properties.get(self.BLOCK_DEVICE_MAPPING) or []
        bootable_vol = False
        for mapping in bdm:
            device_name = mapping[self.BLOCK_DEVICE_MAPPING_DEVICE_NAME]
            if device_name == 'vda':
                bootable_vol = True

            volume_id = mapping.get(self.BLOCK_DEVICE_MAPPING_VOLUME_ID)
            snapshot_id = mapping.get(self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if volume_id and snapshot_id:
                raise exception.ResourcePropertyConflict(
                    self.BLOCK_DEVICE_MAPPING_VOLUME_ID,
                    self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if not volume_id and not snapshot_id:
                msg = _('Either volume_id or snapshot_id must be specified for'
                        ' device mapping %s') % device_name
                raise exception.StackValidationFailed(message=msg)

        # make sure the image exists if specified.
        image = self.properties.get(self.IMAGE)
        if image:
            nova_utils.get_image_id(self.nova(), image)
        elif not image and not bootable_vol:
            msg = _('Neither image nor bootable volume is specified for'
                    ' instance %s') % self.name
            raise exception.StackValidationFailed(message=msg)
        # network properties 'uuid' and 'network' shouldn't be used
        # both at once for all networks
        networks = self.properties.get(self.NETWORKS) or []
        for network in networks:
            if network.get(self.NETWORK_UUID) and network.get(self.NETWORK_ID):
                msg = _('Properties "%(uuid)s" and "%(id)s" are both set '
                        'to the network "%(network)s" for the server '
                        '"%(server)s". The "%(uuid)s" property is deprecated. '
                        'Use only "%(id)s" property.'
                        '') % dict(uuid=self.NETWORK_UUID,
                                   id=self.NETWORK_ID,
                                   network=network[self.NETWORK_ID],
                                   server=self.name)
                raise exception.StackValidationFailed(message=msg)
            elif network.get(self.NETWORK_UUID):
                logger.info(
                    _('For the server "%(server)s" the "%(uuid)s" '
                      'property is set to network "%(network)s". '
                      '"%(uuid)s" property is deprecated. Use '
                      '"%(id)s"  property instead.'
                      '') % dict(uuid=self.NETWORK_UUID,
                                 id=self.NETWORK_ID,
                                 network=network[self.NETWORK_ID],
                                 server=self.name))

        # verify that the number of metadata entries is not greater
        # than the maximum number allowed in the provider's absolute
        # limits
        metadata = self.properties.get('metadata')
        if metadata is not None:
            limits = nova_utils.absolute_limits(self.nova())
            if len(metadata) > limits['maxServerMeta']:
                msg = _('Instance metadata must not contain greater than %s '
                        'entries.  This is the maximum number allowed by your '
                        'service provider') % limits['maxServerMeta']
                raise exception.StackValidationFailed(message=msg)
Exemple #6
0
    def validate(self):
        '''
        Validate any of the provided params
        '''
        super(Server, self).validate()

        # check validity of key
        key_name = self.properties.get(self.KEY_NAME)
        if key_name:
            nova_utils.get_keypair(self.nova(), key_name)

        # either volume_id or snapshot_id needs to be specified, but not both
        # for block device mapping.
        bdm = self.properties.get(self.BLOCK_DEVICE_MAPPING) or []
        bootable_vol = False
        for mapping in bdm:
            device_name = mapping[self.BLOCK_DEVICE_MAPPING_DEVICE_NAME]
            if device_name == 'vda':
                bootable_vol = True

            volume_id = mapping.get(self.BLOCK_DEVICE_MAPPING_VOLUME_ID)
            snapshot_id = mapping.get(self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if volume_id and snapshot_id:
                raise exception.ResourcePropertyConflict(
                    self.BLOCK_DEVICE_MAPPING_VOLUME_ID,
                    self.BLOCK_DEVICE_MAPPING_SNAPSHOT_ID)
            if not volume_id and not snapshot_id:
                msg = _('Either volume_id or snapshot_id must be specified for'
                        ' device mapping %s') % device_name
                raise exception.StackValidationFailed(message=msg)

        # make sure the image exists if specified.
        image = self.properties.get(self.IMAGE)
        if image:
            nova_utils.get_image_id(self.nova(), image)
        elif not image and not bootable_vol:
            msg = _('Neither image nor bootable volume is specified for'
                    ' instance %s') % self.name
            raise exception.StackValidationFailed(message=msg)
        # network properties 'uuid' and 'network' shouldn't be used
        # both at once for all networks
        networks = self.properties.get(self.NETWORKS) or []
        for network in networks:
            if network.get(self.NETWORK_UUID) and network.get(self.NETWORK_ID):
                msg = _('Properties "%(uuid)s" and "%(id)s" are both set '
                        'to the network "%(network)s" for the server '
                        '"%(server)s". The "%(uuid)s" property is deprecated. '
                        'Use only "%(id)s" property.'
                        '') % dict(uuid=self.NETWORK_UUID,
                                   id=self.NETWORK_ID,
                                   network=network[self.NETWORK_ID],
                                   server=self.name)
                raise exception.StackValidationFailed(message=msg)
            elif network.get(self.NETWORK_UUID):
                logger.info(_('For the server "%(server)s" the "%(uuid)s" '
                              'property is set to network "%(network)s". '
                              '"%(uuid)s" property is deprecated. Use '
                              '"%(id)s"  property instead.'
                              '') % dict(uuid=self.NETWORK_UUID,
                                         id=self.NETWORK_ID,
                                         network=network[self.NETWORK_ID],
                                         server=self.name))

        # verify that the number of metadata entries is not greater
        # than the maximum number allowed in the provider's absolute
        # limits
        metadata = self.properties.get('metadata')
        if metadata is not None:
            limits = nova_utils.absolute_limits(self.nova())
            if len(metadata) > limits['maxServerMeta']:
                msg = _('Instance metadata must not contain greater than %s '
                        'entries.  This is the maximum number allowed by your '
                        'service provider') % limits['maxServerMeta']
                raise exception.StackValidationFailed(message=msg)