Removes the given server from the cache.

@param serverId The id of the server to remove.
554820
public void removeServerFromCache(long serverId) {
        servers.computeIfPresent(serverId, (key, server) -> {
            ((Cleanupable) server).cleanup();
            return null;
        });
        nonReadyServers.computeIfPresent(serverId, (key, server) -> {
            ((Cleanupable) server).cleanup();
            return null;
        });
    }
335823
public static void delete(final BandwidthClient client, final String domainId, final String endpointId, final String token) throws AppPlatformException, ParseException, IOException {
        assert(client != null && domainId != null && endpointId != null && endpointId != null);
        deleteToken(client, domainId, endpointId, token);
    }
135011
public synchronized void removeId(@Nonnull String tokenUuid) {
        if(areStatsDisabled()){
            return;
        }
        
        boolean tokenRemoved = tokenStats.removeIf(s -> s.tokenUuid.equals(tokenUuid));
        if (tokenRemoved) {
            save();
        }
    }
1269060
public static Message buildRemove(String serverId) {
    Remove remove = Remove.newBuilder().setServerId(serverId).build();
    return Message.newBuilder().setType(MessageType.REMOVE)
                               .setRemove(remove)
                               .build();
  }
37924
protected Server getServer(final Settings settings, final String serverId) {
		if (settings == null)
			return null;
		List<Server> servers = settings.getServers();
		if (servers == null || servers.isEmpty())
			return null;

		for (Server server : servers)
			if (serverId.equals(server.getId()))
				return server;
		return null;
	}
1141932
public static void delete(final String id) throws AppPlatformException, IOException {
        assert(id != null);
        final BandwidthClient client = BandwidthClient.getInstance();
        client.delete(client.getUserResourceInstanceUri(BandwidthConstants.DOMAINS_URI_PATH, id));
    }
164667
function (id,server)
		{
			if (!_.isString(id) || !_.isObject(server))
				return false;

			if (this.hasModule('server-'+id) && server == null)
				delete this.getModule('server-'+id);
			else
				this.setModule('server-'+id,server);
		}
1014500
public boolean removeHadoopClusterServerInformation(final String serverName) {
        final Element serverInformationCatalogElement = getServerInformationCatalogElement();
        final Element hadoopClustersElement =
                getOrCreateChildElementByTagName(serverInformationCatalogElement, "hadoop-clusters");
        return removeChildElementByNameAttribute(serverName, hadoopClustersElement);
    }
1023313
public void removeFromCache(String id) throws DaoManagerException{
		if (map.containsKey(id)){
			map.remove(id);
		} 
	}
581665
public void deleteService(String serviceId) {

        DeleteServiceRequest deleteServiceRequest = new DeleteServiceRequest().withId(serviceId);
        getDiscoveryClient().deleteService(deleteServiceRequest);

    }
327574
@DeleteOperation
    public void invalidate(@Nullable final String serviceId) {
        if (StringUtils.isBlank(serviceId)) {
            cachingMetadataResolver.invalidate();
        } else {
            val registeredService = findRegisteredService(serviceId);
            val criteriaSet = new CriteriaSet();
            criteriaSet.add(new EntityIdCriterion(serviceId));
            criteriaSet.add(new EntityRoleCriterion(SPSSODescriptor.DEFAULT_ELEMENT_NAME));
            cachingMetadataResolver.invalidate(registeredService, criteriaSet);
        }
    }
1217624
private void remove(final ProviderIdent ident) {
        final cacheItem cacheItem = cache.get(ident);
        if (null != cacheItem) {
            filecache.remove(cacheItem.getFirst());
        }
        cache.remove(ident);
    }
1250480
public void deleteServerGroup(int id) {
        try {
            sqlService.executeUpdate("DELETE FROM " + Constants.DB_TABLE_SERVER_GROUPS +
                                         " WHERE " + Constants.GENERIC_ID + " = " + id + ";");

            sqlService.executeUpdate("DELETE FROM " + Constants.DB_TABLE_SERVERS +
                                         " WHERE " + Constants.SERVER_REDIRECT_GROUP_ID + " = " + id);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
739347
public OperationFuture<Server> removePublicIp(Server serverRef) {
        checkNotNull(serverRef, "Server reference must be not null");
        ServerMetadata serverMetadata = findByRef(serverRef);

        List<JobFuture> jobFutures = serverMetadata.getDetails().getIpAddresses()
            .stream()
            .map(IpAddress::getPublicIp)
            .filter(notNull())
            .map(address -> removePublicIp(serverRef, address).jobFuture())
            .collect(toList());

        return new OperationFuture<>(
            serverRef,
            new ParallelJobsFuture(jobFutures)
        );
    }
1062297
public void destroy()
    {
        if (_ajpIn!=null)
            _ajpIn.destroy();
        _ajpIn=null;
        if (_ajpOut!=null)
            _ajpOut.destroy();
        _ajpOut=null;
        _remoteHost=null;
        _remoteAddr=null;
        _serverName=null;
    }
1151041
public OperationFuture<List<Server>> delete(ServerFilter filter) {
        List<Server> serverRefs = find(filter)
            .stream()
            .map(ServerMetadata::asRefById)
            .collect(toList());

        return delete(serverRefs.toArray(new Server[serverRefs.size()]));
    }
1332629
public function destroySiteGitRepository($serverId, $siteId, $wait = true)
    {
        $this->delete("servers/$serverId/sites/$siteId/git");

        if ($wait) {
            $this->retry($this->getTimeout(), function () use ($serverId, $siteId) {
                return is_null($this->site($serverId, $siteId)->repositoryStatus);
            });
        }
    }