Remove the specified policy from the cache
@param pid
@throws PolicyIndexException
766590
private void deletePolicy(String pid) throws GeneralException  {
        LOG.debug("Deleting policy " + pid);

        try {
            // in case the policy doesn't exist (corrupt policy index, failed to add because invalid, etc)
            m_policyIndex.deletePolicy(pid);
        } catch (PolicyIndexException e) {
            throw new GeneralException("Error deleting policy " + pid + " from policy index: " + e.getMessage(), e);
        }
    }
668018
public AlertPolicyChannelService delete(long policyId, long channelId)
    {
        QueryParameterList queryParams = new QueryParameterList();
        queryParams.add("policy_id", policyId);
        queryParams.add("channel_id", channelId);
        HTTP.DELETE("/v2/alerts_policy_channels.json", null, queryParams);       
        return this;
    }
504280
@Override
    public void deleted(String pid) {
        final ServiceRegistration<T> registration = registrations.get(pid);
        if (registration != null) {
            LOGGER.info("Unregistering OSGi service for pid \"{}\"...", pid);
            final T service = bundleContext.getService(registration.getReference());
            registration.unregister();
            LOGGER.info("Destroying service object for pid \"{}\"...", pid);
            destroy(pid, service);
        }
    }
229004
def delete_policy(self, policy_name, autoscale_group=None):
        
        params = {'PolicyName': policy_name}
        if autoscale_group:
            params['AutoScalingGroupName'] = autoscale_group
        return self.get_status('DeletePolicy', params)
34098
@Override
    public boolean deletePolicy(String name) throws PolicyIndexException {

        writeLock.lock();
        try {
            logger.debug("Deleting policy named: " + name);
            return doDelete(name);
        } finally {
            writeLock.unlock();
        }
    }
870052
public static prune_policy update(nitro_service client, prune_policy resource) throws Exception
	{
		resource.validate("modify");
		return ((prune_policy[]) resource.update_resource(client))[0];
	}
775310
public static void destory(Long pipelineId) {
        Map<Class, Object> resources = cache.remove(pipelineId);
        if (resources != null) {
            Collection collection = resources.values();
            for (Object obj : collection) {
                if (obj instanceof ArbitrateLifeCycle) {
                    ArbitrateLifeCycle lifeCycle = (ArbitrateLifeCycle) obj;
                    lifeCycle.destory();// 调用销毁方法
                }
            }
        }
    }
431678
@Override
	public void remove(String oid) throws IndexerException {
		log.debug("Deleting " + oid + " from index");
		try {
			solr.deleteByQuery("storage_id:\"" + oid + "\"");
			solr.commit();
		} catch (SolrServerException sse) {
			throw new IndexerException(sse);
		} catch (IOException ioe) {
			throw new IndexerException(ioe);
		}
	}
140748
protected static void destroyProcess(String pid, long sleeptimeBeforeSigkill,
                                    boolean inBackground) {
    terminateProcess(pid);
    sigKill(pid, false, sleeptimeBeforeSigkill, inBackground);
  }
278108
function remove(conf) {
  var file = conf.get(ConfigKey.PIDFILE);
  // can be the empty string
  if(file) {
    log.notice('removing pid file %s', file);
    try {
      fs.unlinkSync(file);
    }catch(e) {
      log.warning('failed to remove pid file (%s): %s', file, e.message);
    }
  }
}
1319556
public boolean removePolicy(String sec, String ptype, List<String> rule) {
        for (int i = 0; i < model.get(sec).get(ptype).policy.size(); i ++) {
            List<String> r = model.get(sec).get(ptype).policy.get(i);
            if (Util.arrayEquals(rule, r)) {
                model.get(sec).get(ptype).policy.remove(i);
                return true;
            }
        }

        return false;
    }
1344526
@Override
    public void removeFilteredPolicy(String sec, String ptype, int fieldIndex, String... fieldValues) {
        throw new Error("not implemented");
    }
1345560
def delete_policy(name, policy_name, region=None, key=None, keyid=None,
                  profile=None):
    '''
    
    '''
    conn = _get_conn(region=region, key=key, keyid=keyid, profile=profile)

    if not exists(name, region, key, keyid, profile):
        return True
    try:
        conn.delete_lb_policy(name, policy_name)
        log.info('Deleted policy %s on ELB %s', policy_name, name)
        return True
    except boto.exception.BotoServerError as e:
        log.error('Failed to delete policy %s on ELB %s: %s',
                  policy_name, name, e.message,
                  exc_info_on_loglevel=logging.DEBUG)
        return False
874821
public final void setUsagePolicy(Callback<Integer, Usage> policy) {
        Objects.requireNonNull(policy);
        this.usagePolicy.set(policy);
    }
503056
def fw_policy_delete(self, data, fw_name=None):
        
        LOG.debug("FW Policy Debug")
        self._fw_policy_delete(fw_name, data)
1280207
public void inactivateSubProcess(String spPid) {
		synchronized (fileList) {		// always lock fileList first to avoid deadlock
			synchronized(activeFilesMap) {		// Right into sync block because 99% case is that map contains pid
				activeFilesMap.remove(spPid) ;
			}
		}
		if (debugLogger.isLoggable(Level.FINE) && LogRepositoryBaseImpl.isDebugEnabled()) {
			debugLogger.logp(Level.FINE, thisClass, "inactivateSubProcess", "Inactivated pid: "+spPid) ;
		}
	}
6147
def remove_policy(self, index=None, params=None):
        
        return self.transport.perform_request(
            "POST", _make_path(index, "_ilm", "remove"), params=params
        )