Deletes the specified security group rule
485244
def delete_security_group_rule(self, sec_grp_rule_id):
        '''
        
        '''
        ret = self.network_conn.delete_security_group_rule(
            security_group_rule=sec_grp_rule_id)
        return ret if ret else True
1228893
def DeleteGroup(r, group, dry_run=False):
    

    query = {
        "dry-run": dry_run,
    }

    return r.request("delete", "/2/groups/%s" % group, query=query)
692446
def delete_cache_security_group(name, region=None, key=None, keyid=None,
                                profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    deleted = conn.delete_cache_security_group(name)
    if deleted:
        log.info('Deleted cache security group %s.', name)
        return True
    else:
        msg = 'Failed to delete cache security group {0}.'.format(name)
        log.error(msg)
        return False
1189442
def cli(env, securitygroup_id):
    """"""
    mgr = SoftLayer.NetworkManager(env.client)
    if not mgr.delete_securitygroup(securitygroup_id):
        raise exceptions.CLIAbort("Failed to delete security group")
105755
def revoke_group_permission(
        self, group_name, source_group_name, source_group_owner_id):
        
        d = self.revoke_security_group(
            group_name,
            source_group_name=source_group_name,
            source_group_owner_id=source_group_owner_id)
        return d
1295970
def delete_group(self, name):
        

        group = self.get_group(name)

        method, url = get_URL('group_delete')

        payload = {
            'apikey': self.config.get('apikey'),
            'logintoken': self.session.cookies.get('logintoken'),
            'contactgroupid': group['contactgroupid']
            }

        res = getattr(self.session, method)(url, params=payload)

        if res.status_code == 200:
            return True

        hellraiser(res)
765019
def delete(resource_group_name, image_name, custom_headers:nil)
      response = delete_async(resource_group_name, image_name, custom_headers:custom_headers).value!
      nil
    end
1078251
def deletegroupmember(self, group_id, user_id):
        
        request = requests.delete(
            '{0}/{1}/members/{2}'.format(self.groups_url, group_id, user_id),
            headers=self.headers, verify=self.verify_ssl, auth=self.auth, timeout=self.timeout)

        if request.status_code == 200:
            return True
998949
def delete(options = {})
      options = options.merge(
        auto_scaling_group_name: @group_name,
        topic_arn: @topic_arn
      )
      resp = @client.delete_notification_configuration(options)
      resp.data
    end
751048
def delete_cache_security_group(name, region=None, key=None, keyid=None, profile=None, **args):
    '''
    
    '''
    return _delete_resource(name, name_param='CacheSecurityGroupName',
                            desc='cache security group', res_type='cache_security_group',
                            region=region, key=key, keyid=keyid, profile=profile, **args)
88546
def revoke_ip_permission(
        self, group_name, ip_protocol, from_port, to_port, cidr_ip):
        
        d = self.revoke_security_group(
            group_name,
            ip_protocol=ip_protocol, from_port=from_port, to_port=to_port,
            cidr_ip=cidr_ip)
        return d
826579
def delete_group_dampening(self, group_id, dampening_id):
        
        self._delete(self._service_url(['triggers', 'groups', group_id, 'dampenings', dampening_id]))
231314
def delete_service_group(self, group_id):
        

        svc = self.client['Network_Application_Delivery_Controller_'
                          'LoadBalancer_VirtualServer']

        return svc.deleteObject(id=group_id)
357438
def del_permission(self, role, name):
        
        if not self.has_permission(role, name):
            return True
        targetGroup = AuthGroup.objects(role=role, creator=self.client).first()
        target = AuthPermission.objects(groups=targetGroup, name=name, creator=self.client).first()
        if not target:
            return True
        target.delete()
        return True
924771
def remove(env, securitygroup_id, rule_id):
    """"""
    mgr = SoftLayer.NetworkManager(env.client)

    ret = mgr.remove_securitygroup_rule(securitygroup_id, rule_id)

    if not ret:
        raise exceptions.CLIAbort("Failed to remove security group rule")

    table = formatting.Table(REQUEST_BOOL_COLUMNS)
    table.add_row([ret['requestId']])

    env.fout(table)
1124688
def show_security_group_rule(self, security_group_rule, **_params):
        """"""
        return self.get(self.security_group_rule_path % (security_group_rule),
                        params=_params)
615888
function(oDD, sGroup) {
            if (!this.ids[sGroup]) {
                this.ids[sGroup] = {};
            }

            var obj = this.ids[sGroup];
            if (obj && obj[oDD.id]) {
                delete obj[oDD.id];
            }
        }