Delete dump before expiration date

REST: DELETE /hosting/privateDatabase/{serviceName}/dump/{dumpId}
@param serviceName [required] The internal name of your private database
@param dumpId [required] Dump id
541997
public OvhTask serviceName_dump_dumpId_DELETE(String serviceName, Long dumpId) throws IOException {
		String qPath = "/hosting/privateDatabase/{serviceName}/dump/{dumpId}";
		StringBuilder sb = path(qPath, serviceName, dumpId);
		String resp = exec(qPath, "DELETE", sb.toString(), null);
		return convertTo(resp, OvhTask.class);
	}
985005
@Override
	public synchronized void delete(long historyId, String tag) throws DatabaseException {
    	try {
			psDeleteTag.setLong(1, historyId);
			psDeleteTag.setString(2, tag);
			psDeleteTag.executeUpdate();
		} catch (SQLException e) {
			throw new DatabaseException(e);
		}
    }
388770
public static void unregisterService(String serviceName, String clientId) {
        try {
            if (registry != null) {
                synchronized (lock) {
                    ServiceInstance<NodeStatus> instance = registry.serviceDiscovery.queryForInstance(serviceName, clientId);
                    if (instance != null) {
                        registry.serviceDiscovery.unregisterService(instance);
                    } else {
                        LOG.warn("你要注销的服务不存在或已经被注销了,服务id:" + clientId);
                    }
                }
            } else {
                LOG.error("服务注册机已经停止，说明本机所有服务已经全部注销，所以没必要再单独注销服务了。", new Throwable());
            }
        } catch (Throwable e) {
            LOG.error(e);
        }
    }
1188563
public void unregisterService(String serviceName, String providerId) {
        getServiceDirectoryClient().unregisterServiceInstance(serviceName, providerId);
        getCacheServiceInstances().remove(new ServiceInstanceToken(serviceName, providerId));
    }
1318810
public void deleteService(String id, boolean force) {
        try {
            if (id == null || id.isEmpty()) {
                id = selectRunningService();
            }
            final String idFinal = id;
            int input = 'Y';
            if (!force) {
                OutputStreamFormater.printValue(String.format(
                    "Do you really want to delete the connector: %s (Y/n): ", id));
                input = keyboard.read();
            }
            if ('n' != (char) input && 'N' != (char) input) {
                SecurityContext.executeWithSystemPermissions(new Callable<Object>() {
                    @Override
                    public Object call() throws Exception {
                        serviceManager.delete(idFinal);
                        return null;
                    }
                });
                OutputStreamFormater.printValue(String.format("Service: %s successfully deleted", id));
            }
        } catch (ExecutionException e) {
            e.printStackTrace();
            System.err.println("Could not delete service");
        } catch (IOException e) {
            e.printStackTrace();
            System.err.println("Unexpected Error");
        }
    }
72380
public void project_serviceName_sshkey_keyId_DELETE(String serviceName, String keyId) throws IOException {
		String qPath = "/cloud/project/{serviceName}/sshkey/{keyId}";
		StringBuilder sb = path(qPath, serviceName, keyId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
747349
public void serviceName_PUT(String serviceName, net.minidev.ovh.api.hosting.privatedatabase.OvhService body) throws IOException {
		String qPath = "/hosting/privateDatabase/{serviceName}";
		StringBuilder sb = path(qPath, serviceName);
		exec(qPath, "PUT", sb.toString(), body);
	}
839322
private void dumpCache(){
        if (CacheDumpLogger.isDebugEnabled()) {
            try {
                StringBuilder sb = new StringBuilder();
                sb.append("LookupManager dumped Service Cache at: ").append(System.currentTimeMillis()).append("\n");
                ModelService service = getData();
                sb.append(service==null ? "Cache is empty" : new String(serialize(service))).append("\n");
                CacheDumpLogger.debug(sb.toString());
            } catch (Exception e) {
                LOGGER.warn("Dump Service Cache failed. Set Logger {} to INFO to disable this message.",
                            CacheDumpLogger.getName());
                LOGGER.trace("Dump Service Cache failed. ", e);
            }
        }
    }
1329689
def delete_service_key(self, service_name, key_name):
        
        key = self.get_service_key(service_name, key_name)
        logging.info("Deleting service key %s for service %s" % (key, service_name))
        return self.api.delete(key['metadata']['url'])
566596
public void serviceName_users_userId_DELETE(String serviceName, String userId) throws IOException {
		String qPath = "/caas/registry/{serviceName}/users/{userId}";
		StringBuilder sb = path(qPath, serviceName, userId);
		exec(qPath, "DELETE", sb.toString(), null);
	}
259301
public void serviceName_users_login_DELETE(String serviceName, String login) throws IOException {
		String qPath = "/sms/{serviceName}/users/{login}";
		StringBuilder sb = path(qPath, serviceName, login);
		exec(qPath, "DELETE", sb.toString(), null);
	}
981622
def delete_service(self, service_name, params=None):
        
        if not self.space.has_service_with_name(service_name):
            logging.warning("Service not found so... succeeded?")
            return True

        guid = self.get_instance_guid(service_name)
        logging.info("Deleting service %s with guid %s" % (service_name, guid))

        # MAINT: this endpoint changes in newer version of api
        return self.api.delete("/v2/service_instances/%s?accepts_incomplete=true" %
            (guid), params=params)
1034195
public DeploymentService delete(long applicationId, long deploymentId)
    {
        HTTP.DELETE(String.format("/v2/applications/%d/deployments/%d.json", applicationId, deploymentId));       
        return this;
    }
1068619
public function delete_service($serviceid) {
        global $DB;
        $DB->delete_records('external_services_users', array('externalserviceid' => $serviceid));
        $DB->delete_records('external_services_functions', array('externalserviceid' => $serviceid));
        $DB->delete_records('external_tokens', array('externalserviceid' => $serviceid));
        $DB->delete_records('external_services', array('id' => $serviceid));
    }
904766
async def delete(self, service_id: str) -> bool:
        

        await self.docker._query(
            "services/{service_id}".format(service_id=service_id), method="DELETE"
        )
        return True
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;
        });
    }
767057
public void serviceName_runtime_id_PUT(String serviceName, Long id, OvhRuntime body) throws IOException {
		String qPath = "/hosting/web/{serviceName}/runtime/{id}";
		StringBuilder sb = path(qPath, serviceName, id);
		exec(qPath, "PUT", sb.toString(), body);
	}