Example #1
0
    def update_security_group(self, context, id, security_group):
        s = security_group['security_group']

        kwargs = {
            'context': context,
            'security_group_id': id,
            'security_group': s,
        }
        self._registry_notify(resources.SECURITY_GROUP,
                              events.BEFORE_UPDATE,
                              exc_cls=ext_sg.SecurityGroupConflict,
                              **kwargs)

        with context.session.begin(subtransactions=True):
            sg = self._get_security_group(context, id)
            if sg['name'] == 'default' and 'name' in s:
                raise ext_sg.SecurityGroupCannotUpdateDefault()
            self._registry_notify(resources.SECURITY_GROUP,
                                  events.PRECOMMIT_UPDATE,
                                  exc_cls=ext_sg.SecurityGroupConflict,
                                  **kwargs)
            sg.update(s)
        sg_dict = self._make_security_group_dict(sg)

        kwargs['security_group'] = sg_dict
        registry.notify(resources.SECURITY_GROUP, events.AFTER_UPDATE, self,
                        **kwargs)
        return sg_dict
Example #2
0
    def update_security_group(self, context, id, security_group):
        s = security_group['security_group']

        kwargs = {
            'context': context,
            'security_group_id': id,
            'security_group': s,
        }
        # NOTE(armax): a callback exception here will prevent the request
        # from being processed. This is a hook point for backend's validation;
        # we raise to propagate the reason for the failure.
        try:
            registry.notify(resources.SECURITY_GROUP, events.BEFORE_UPDATE,
                            self, **kwargs)
        except exceptions.CallbackFailure as e:
            raise ext_sg.SecurityGroupConflict(reason=e)

        with context.session.begin(subtransactions=True):
            sg = self._get_security_group(context, id)
            if sg['name'] == 'default' and 'name' in s:
                raise ext_sg.SecurityGroupCannotUpdateDefault()
            sg.update(s)
        sg_dict = self._make_security_group_dict(sg)

        kwargs['security_group'] = sg_dict
        registry.notify(resources.SECURITY_GROUP, events.AFTER_UPDATE, self,
                        **kwargs)
        return sg_dict
Example #3
0
    def update_security_group(self, context, id, security_group):
        s = security_group['security_group']

        kwargs = {
            'context': context,
            'security_group_id': id,
            'security_group': s,
        }
        self._registry_notify(resources.SECURITY_GROUP, events.BEFORE_UPDATE,
                              exc_cls=ext_sg.SecurityGroupConflict, **kwargs)

        with db_api.CONTEXT_WRITER.using(context):
            sg = self._get_security_group(context, id)
            if sg.name == 'default' and 'name' in s:
                raise ext_sg.SecurityGroupCannotUpdateDefault()
            sg_dict = self._make_security_group_dict(sg)
            kwargs['original_security_group'] = sg_dict
            sg.update_fields(s)
            sg.update()
            sg_dict = self._make_security_group_dict(sg)
            kwargs['security_group'] = sg_dict
            self._registry_notify(
                    resources.SECURITY_GROUP,
                    events.PRECOMMIT_UPDATE,
                    exc_cls=ext_sg.SecurityGroupConflict,
                    payload=events.DBEventPayload(
                        context, request_body=s,
                        states=(kwargs['original_security_group'],),
                        resource_id=id, desired_state=sg_dict))
        registry.notify(resources.SECURITY_GROUP, events.AFTER_UPDATE, self,
                        **kwargs)
        return sg_dict
Example #4
0
    def update_security_group(self, context, id, security_group):
        s = security_group['security_group']

        kwargs = {
            'context': context,
            'security_group_id': id,
            'security_group': s,
        }
        self._registry_notify(resources.SECURITY_GROUP, events.BEFORE_UPDATE,
                              exc_cls=ext_sg.SecurityGroupConflict, **kwargs)

        with db_api.context_manager.writer.using(context):
            sg = self._get_security_group(context, id)
            if sg.name == 'default' and 'name' in s:
                raise ext_sg.SecurityGroupCannotUpdateDefault()
            sg_dict = self._make_security_group_dict(sg)
            kwargs['original_security_group'] = sg_dict
            sg.update_fields(s)
            sg.update()
            sg_dict = self._make_security_group_dict(sg)
            kwargs['security_group'] = sg_dict
            self._registry_notify(
                    resources.SECURITY_GROUP,
                    events.PRECOMMIT_UPDATE,
                    exc_cls=ext_sg.SecurityGroupConflict, **kwargs)

        registry.notify(resources.SECURITY_GROUP, events.AFTER_UPDATE, self,
                        **kwargs)
        return sg_dict
Example #5
0
def update_security_group(context, id, security_group):
    if id == DEFAULT_SG_UUID:
        raise sg_ext.SecurityGroupCannotUpdateDefault()
    new_group = security_group["security_group"]
    with context.session.begin():
        group = db_api.security_group_find(context, id=id, scope=db_api.ONE)
        db_group = db_api.security_group_update(context, group, **new_group)
    return v._make_security_group_dict(db_group)
Example #6
0
 def update_security_group(self, context, id, security_group):
     s = security_group['security_group']
     with context.session.begin(subtransactions=True):
         sg = self._get_security_group(context, id)
         if sg['name'] == 'default' and 'name' in s:
             raise ext_sg.SecurityGroupCannotUpdateDefault()
         sg.update(s)
     return self._make_security_group_dict(sg)
 def update_security_group(self, context, id, security_group):
     s = security_group['security_group']
     # NOTE(gongysh) for the purpose update the security_group with
     # data return security_group created just
     s.pop('created_at', None)
     with context.session.begin(subtransactions=True):
         sg = self._get_security_group(context, id)
         if sg['name'] == 'default' and 'name' in s:
             raise ext_sg.SecurityGroupCannotUpdateDefault()
         sg.update(s)
     return self._make_security_group_dict(sg)
Example #8
0
    def update_security_group(self, context, id, security_group):
        s = security_group['security_group']

        if 'stateful' in s:
            with db_api.CONTEXT_READER.using(context):
                sg = self._get_security_group(context, id)
                if s['stateful'] != sg['stateful']:
                    filters = {'security_group_id': [id]}
                    ports = self._get_port_security_group_bindings(
                        context, filters)
                    if ports:
                        raise ext_sg.SecurityGroupInUse(id=id)

        self._registry_notify(resources.SECURITY_GROUP,
                              events.BEFORE_UPDATE,
                              exc_cls=ext_sg.SecurityGroupConflict,
                              payload=events.DBEventPayload(context,
                                                            resource_id=id,
                                                            states=(s, )))

        with db_api.CONTEXT_WRITER.using(context):
            sg = self._get_security_group(context, id)
            if sg.name == 'default' and 'name' in s:
                raise ext_sg.SecurityGroupCannotUpdateDefault()
            sg_dict = self._make_security_group_dict(sg)
            original_security_group = sg_dict
            sg.update_fields(s)
            sg.update()
            sg_dict = self._make_security_group_dict(sg)
            self._registry_notify(resources.SECURITY_GROUP,
                                  events.PRECOMMIT_UPDATE,
                                  exc_cls=ext_sg.SecurityGroupConflict,
                                  payload=events.DBEventPayload(
                                      context,
                                      request_body=s,
                                      states=(original_security_group, ),
                                      resource_id=id,
                                      desired_state=sg_dict))
        registry.publish(resources.SECURITY_GROUP,
                         events.AFTER_UPDATE,
                         self,
                         payload=events.DBEventPayload(
                             context,
                             request_body=s,
                             states=(original_security_group, sg_dict),
                             resource_id=id))

        return sg_dict