Deletes resources for a hosting device in a plugin specific way.
163452
def delete_hosting_device_resources(self, context, tenant_id, mgmt_port,
                                        **kwargs):
        """"""

        if mgmt_port is not None:
            try:
                self._cleanup_hosting_port(context, mgmt_port['id'])
            except n_exc.NeutronException as e:
                LOG.error("Unable to delete port:%(port)s after %(tries)d"
                          " attempts due to exception %(exception)s. "
                          "Skipping it", {'port': mgmt_port['id'],
                                          'tries': DELETION_ATTEMPTS,
                                          'exception': str(e)})
183807
def clear(self, *resource_types):
        """"""
        resource_types = resource_types or tuple(self.__caches.keys())

        for cls in resource_types:
            # Clear and delete cache instances to guarantee no lingering references
            self.__caches[cls].clear()
            del self.__caches[cls]
1178379
def clear(self):
        """"""

        r = self._h._http_resource(
            method='DELETE',
            resource=('user', 'keys'),
        )

        return r.ok
423068
def delete(cls, resources, background=False, force=False):
        """"""
        if not isinstance(resources, (list, tuple)):
            resources = [resources]

        ifaces = []
        for item in resources:
            try:
                ip_ = cls.info(item)
            except UsageError:
                cls.error("Can't find this ip %s" % item)

            iface = Iface.info(ip_['iface_id'])
            ifaces.append(iface['id'])

        return Iface.delete(ifaces, background)
293241
protected void clear() {
        resource = null;
        resourceResolver = null;
        context = null;
        out = null;
        request = null;
        expressionUtil = null;
    }
413625
def deallocate(self):
        """"""
        if self._domain is not None:
            domain_delete(self._domain, self.logger)
        if self._network is not None:
            self._network_delete()
        if self._storage_pool is not None:
            self._storage_pool_delete()
        if self._hypervisor is not None:
            self._hypervisor_delete()
496075
def remove_resources(self, resources):
    

    resources_to_delete = self._build_resource_dictionary(resources)
    for email in resources_to_delete.keys():
      if email in self._resources:
        del self._resources[email]

    self._dirty_attributes.add(u'resources')
412592
def delete(args):
    
    m = TemplateManager(args.hosts)
    m.delete(args.name)
507042
function cleanup()
    {
        $this->HTTP->removeSessionVariable( $this->StorageName . $this->MetaDataName );
        $this->HTTP->removeSessionVariable( $this->StorageName . $this->VariableListName );
        $this->MetaData = array();
        $this->VariableList = array();
    }
1194047
public void purge() {

        synchronized(this){
            // Clear all references to VirtualHost objects
            for (DynamicVirtualHost host : hostMap.values()) {
                if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled()) {
                    Tr.debug(tc, "Purge host : " + host.hashCode() + ", this : " +this);
                }
                host.getHostConfiguration().setConfiguration(null);
            }

            hostMap.clear();
        }
        //do not clear the transport map. 
        //DS looks after the transport map via set/unset/updateVirtualHost
        //transportMap.clear();
    }
1336472
def remove(self, resource):
        """"""
        if isinstance(resource, Resource):
            self._resources.remove(resource)
1256672
def destroy_plugin(plugin_name, conn=None):
    
    results = {}
    if plugin_exists(plugin_name, conn=conn):
        results = RPX.table_drop(plugin_name).run(conn)
    return results
90587
def delete_service(self, name):
    
    return services.delete_service(self._get_resource_root(), name, self.name)
102247
function cleanup(e) {
    if (e.tile.proxyRefs) {
      for (var proxyKey in e.tile.proxyRefs) {
        var proxyTile = e.tile.proxyRefs[proxyKey];
        if ((--proxyTile.proxyCount <= 0) && cache.unload(proxyKey)) {
          proxyTile.element.parentNode.removeChild(proxyTile.element);
        }
      }
      delete e.tile.proxyRefs;
    }
  }
804914
def destroy(self):
        """"""
        r = api.Resources(self.provider_conf.to_dict())
        # insert force_deploy
        r.destroy()
213201
private function cleanupAppServers()
    {
        $allFoundServers = $this->loadAppServerList();
        /** @var \OxidEsales\Eshop\Core\DataObject\ApplicationServer $server */
        foreach ($allFoundServers as $server) {
            if ($server->needToDelete($this->currentTime)) {
                $this->deleteAppServerById($server->getId());
            }
        }
    }
641909
public function preRemove()
    {
        if ($this->lifecycleEventsActive && $this->deleted === false) {
            $this->resourceManager->deleteResource($this);
        }
    }