com.oracle.bmc.database.DatabaseAsyncClient Maven / Gradle / Ivy
Go to download
Show more of this group Show more artifacts with this name
Show all versions of oci-java-sdk-database Show documentation
Show all versions of oci-java-sdk-database Show documentation
This project contains the SDK used for Oracle Cloud Infrastructure Database Service
The newest version!
/**
* Copyright (c) 2016, 2024, Oracle and/or its affiliates. All rights reserved.
* This software is dual-licensed to you under the Universal Permissive License (UPL) 1.0 as shown at https://oss.oracle.com/licenses/upl or Apache License 2.0 as shown at http://www.apache.org/licenses/LICENSE-2.0. You may choose either license.
*/
package com.oracle.bmc.database;
import com.oracle.bmc.util.internal.Validate;
import com.oracle.bmc.database.requests.*;
import com.oracle.bmc.database.responses.*;
import java.util.Objects;
/**
* Async client implementation for Database service.
* There are two ways to use async client: 1. Use AsyncHandler: using AsyncHandler, if the response
* to the call is an {@link java.io.InputStream}, like getObject Api in object storage service,
* developers need to process the stream in AsyncHandler, and not anywhere else, because the stream
* will be closed right after the AsyncHandler is invoked.
* 2. Use Java Future: using Java Future, developers need to close the stream after they are done
* with the Java Future.
* Accessing the result should be done in a mutually exclusive manner, either through the Future or
* the AsyncHandler, but not both. If the Future is used, the caller should pass in null as the
* AsyncHandler. If the AsyncHandler is used, it is still safe to use the Future to determine
* whether or not the request was completed via Future.isDone/isCancelled.
* Please refer to
* https://github.com/oracle/oci-java-sdk/blob/master/bmc-examples/src/main/java/ResteasyClientWithObjectStorageExample.java
*/
@jakarta.annotation.Generated(value = "OracleSDKGenerator", comments = "API Version: 20160918")
public class DatabaseAsyncClient extends com.oracle.bmc.http.internal.BaseAsyncClient
implements DatabaseAsync {
/** Service instance for Database. */
public static final com.oracle.bmc.Service SERVICE =
com.oracle.bmc.Services.serviceBuilder()
.serviceName("DATABASE")
.serviceEndpointPrefix("database")
.serviceEndpointTemplate("https://database.{region}.{secondLevelDomain}")
.build();
private static final org.slf4j.Logger LOG =
org.slf4j.LoggerFactory.getLogger(DatabaseAsyncClient.class);
DatabaseAsyncClient(
com.oracle.bmc.common.ClientBuilderBase builder,
com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider
authenticationDetailsProvider) {
this(builder, authenticationDetailsProvider, true);
}
DatabaseAsyncClient(
com.oracle.bmc.common.ClientBuilderBase builder,
com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider authenticationDetailsProvider,
boolean isStreamWarningEnabled) {
super(builder, authenticationDetailsProvider);
if (isStreamWarningEnabled && com.oracle.bmc.util.StreamUtils.isExtraStreamLogsEnabled()) {
LOG.warn(
com.oracle.bmc.util.StreamUtils.getStreamWarningMessage(
"DatabaseAsyncClient",
"downloadExadataInfrastructureConfigFile,downloadValidationReport,downloadVmClusterNetworkConfigFile,generateAutonomousDatabaseWallet,getConsoleHistoryContent"));
}
}
/**
* Create a builder for this client.
*
* @return builder
*/
public static Builder builder() {
return new Builder(SERVICE);
}
/**
* Builder class for this client. The "authenticationDetailsProvider" is required and must be
* passed to the {@link #build(AbstractAuthenticationDetailsProvider)} method.
*/
public static class Builder
extends com.oracle.bmc.common.RegionalClientBuilder {
private boolean isStreamWarningEnabled = true;
private Builder(com.oracle.bmc.Service service) {
super(service);
final String packageName = "database";
com.oracle.bmc.internal.Alloy.throwDisabledServiceExceptionIfAppropriate(packageName);
requestSignerFactory =
new com.oracle.bmc.http.signing.internal.DefaultRequestSignerFactory(
com.oracle.bmc.http.signing.SigningStrategy.STANDARD);
}
/**
* Enable/disable the stream warnings for the client
*
* @param isStreamWarningEnabled executorService
* @return this builder
*/
public Builder isStreamWarningEnabled(boolean isStreamWarningEnabled) {
this.isStreamWarningEnabled = isStreamWarningEnabled;
return this;
}
/**
* Build the client.
*
* @param authenticationDetailsProvider authentication details provider
* @return the client
*/
public DatabaseAsyncClient build(
@jakarta.annotation.Nonnull
com.oracle.bmc.auth.AbstractAuthenticationDetailsProvider
authenticationDetailsProvider) {
return new DatabaseAsyncClient(
this, authenticationDetailsProvider, isStreamWarningEnabled);
}
}
@Override
public void setRegion(com.oracle.bmc.Region region) {
super.setRegion(region);
}
@Override
public void setRegion(String regionId) {
super.setRegion(regionId);
}
@Override
public java.util.concurrent.Future
activateExadataInfrastructure(
ActivateExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ActivateExadataInfrastructureRequest,
ActivateExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Objects.requireNonNull(
request.getActivateExadataInfrastructureDetails(),
"activateExadataInfrastructureDetails is required");
return clientCall(request, ActivateExadataInfrastructureResponse::builder)
.logger(LOG, "activateExadataInfrastructure")
.serviceDetails(
"Database",
"ActivateExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/ActivateExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ActivateExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("activate")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExadataInfrastructure.class,
ActivateExadataInfrastructureResponse.Builder::exadataInfrastructure)
.handleResponseHeaderString(
"opc-work-request-id",
ActivateExadataInfrastructureResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", ActivateExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
ActivateExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
addStorageCapacityCloudExadataInfrastructure(
AddStorageCapacityCloudExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
AddStorageCapacityCloudExadataInfrastructureRequest,
AddStorageCapacityCloudExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getCloudExadataInfrastructureId(),
"cloudExadataInfrastructureId must not be blank");
return clientCall(request, AddStorageCapacityCloudExadataInfrastructureResponse::builder)
.logger(LOG, "addStorageCapacityCloudExadataInfrastructure")
.serviceDetails(
"Database",
"AddStorageCapacityCloudExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudExadataInfrastructure/AddStorageCapacityCloudExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(AddStorageCapacityCloudExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudExadataInfrastructures")
.appendPathParam(request.getCloudExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("addStorageCapacity")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.handleBody(
com.oracle.bmc.database.model.CloudExadataInfrastructure.class,
AddStorageCapacityCloudExadataInfrastructureResponse.Builder
::cloudExadataInfrastructure)
.handleResponseHeaderString(
"opc-work-request-id",
AddStorageCapacityCloudExadataInfrastructureResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"etag", AddStorageCapacityCloudExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
AddStorageCapacityCloudExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
addStorageCapacityExadataInfrastructure(
AddStorageCapacityExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
AddStorageCapacityExadataInfrastructureRequest,
AddStorageCapacityExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
return clientCall(request, AddStorageCapacityExadataInfrastructureResponse::builder)
.logger(LOG, "addStorageCapacityExadataInfrastructure")
.serviceDetails(
"Database",
"AddStorageCapacityExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/AddStorageCapacityExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(AddStorageCapacityExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("addStorageCapacity")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.handleBody(
com.oracle.bmc.database.model.ExadataInfrastructure.class,
AddStorageCapacityExadataInfrastructureResponse.Builder
::exadataInfrastructure)
.handleResponseHeaderString(
"opc-work-request-id",
AddStorageCapacityExadataInfrastructureResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", AddStorageCapacityExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
AddStorageCapacityExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
addVirtualMachineToCloudVmCluster(
AddVirtualMachineToCloudVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
AddVirtualMachineToCloudVmClusterRequest,
AddVirtualMachineToCloudVmClusterResponse>
handler) {
Objects.requireNonNull(
request.getAddVirtualMachineToCloudVmClusterDetails(),
"addVirtualMachineToCloudVmClusterDetails is required");
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
return clientCall(request, AddVirtualMachineToCloudVmClusterResponse::builder)
.logger(LOG, "addVirtualMachineToCloudVmCluster")
.serviceDetails(
"Database",
"AddVirtualMachineToCloudVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudVmCluster/AddVirtualMachineToCloudVmCluster")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(AddVirtualMachineToCloudVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.appendPathParam("actions")
.appendPathParam("addVirtualMachine")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.CloudVmCluster.class,
AddVirtualMachineToCloudVmClusterResponse.Builder::cloudVmCluster)
.handleResponseHeaderString(
"opc-work-request-id",
AddVirtualMachineToCloudVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", AddVirtualMachineToCloudVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
AddVirtualMachineToCloudVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
addVirtualMachineToVmCluster(
AddVirtualMachineToVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
AddVirtualMachineToVmClusterRequest,
AddVirtualMachineToVmClusterResponse>
handler) {
Objects.requireNonNull(
request.getAddVirtualMachineToVmClusterDetails(),
"addVirtualMachineToVmClusterDetails is required");
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
return clientCall(request, AddVirtualMachineToVmClusterResponse::builder)
.logger(LOG, "addVirtualMachineToVmCluster")
.serviceDetails(
"Database",
"AddVirtualMachineToVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmCluster/AddVirtualMachineToVmCluster")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(AddVirtualMachineToVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.appendPathParam("actions")
.appendPathParam("addVirtualMachine")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.VmCluster.class,
AddVirtualMachineToVmClusterResponse.Builder::vmCluster)
.handleResponseHeaderString(
"opc-work-request-id",
AddVirtualMachineToVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", AddVirtualMachineToVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
AddVirtualMachineToVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
autonomousDatabaseManualRefresh(
AutonomousDatabaseManualRefreshRequest request,
final com.oracle.bmc.responses.AsyncHandler<
AutonomousDatabaseManualRefreshRequest,
AutonomousDatabaseManualRefreshResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
Objects.requireNonNull(
request.getAutonomousDatabaseManualRefreshDetails(),
"autonomousDatabaseManualRefreshDetails is required");
return clientCall(request, AutonomousDatabaseManualRefreshResponse::builder)
.logger(LOG, "autonomousDatabaseManualRefresh")
.serviceDetails(
"Database",
"AutonomousDatabaseManualRefresh",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/AutonomousDatabaseManualRefresh")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(AutonomousDatabaseManualRefreshRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("refresh")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabase.class,
AutonomousDatabaseManualRefreshResponse.Builder::autonomousDatabase)
.handleResponseHeaderString(
"etag", AutonomousDatabaseManualRefreshResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
AutonomousDatabaseManualRefreshResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
AutonomousDatabaseManualRefreshResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future cancelBackup(
CancelBackupRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getBackupId(), "backupId must not be blank");
return clientCall(request, CancelBackupResponse::builder)
.logger(LOG, "cancelBackup")
.serviceDetails(
"Database",
"CancelBackup",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Backup/CancelBackup")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CancelBackupRequest::builder)
.basePath("/20160918")
.appendPathParam("backups")
.appendPathParam(request.getBackupId())
.appendPathParam("actions")
.appendPathParam("cancel")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.handleResponseHeaderString(
"opc-work-request-id", CancelBackupResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", CancelBackupResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future cancelExecutionWindow(
CancelExecutionWindowRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CancelExecutionWindowRequest, CancelExecutionWindowResponse>
handler) {
Validate.notBlank(request.getExecutionWindowId(), "executionWindowId must not be blank");
Objects.requireNonNull(
request.getCancelExecutionWindowDetails(),
"cancelExecutionWindowDetails is required");
return clientCall(request, CancelExecutionWindowResponse::builder)
.logger(LOG, "cancelExecutionWindow")
.serviceDetails(
"Database",
"CancelExecutionWindow",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExecutionWindow/CancelExecutionWindow")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CancelExecutionWindowRequest::builder)
.basePath("/20160918")
.appendPathParam("executionWindows")
.appendPathParam(request.getExecutionWindowId())
.appendPathParam("actions")
.appendPathParam("cancel")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExecutionWindow.class,
CancelExecutionWindowResponse.Builder::executionWindow)
.handleResponseHeaderString(
"opc-work-request-id",
CancelExecutionWindowResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CancelExecutionWindowResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CancelExecutionWindowResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
cascadingDeleteSchedulingPlan(
CascadingDeleteSchedulingPlanRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CascadingDeleteSchedulingPlanRequest,
CascadingDeleteSchedulingPlanResponse>
handler) {
Validate.notBlank(request.getSchedulingPlanId(), "schedulingPlanId must not be blank");
return clientCall(request, CascadingDeleteSchedulingPlanResponse::builder)
.logger(LOG, "cascadingDeleteSchedulingPlan")
.serviceDetails(
"Database",
"CascadingDeleteSchedulingPlan",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPlan/CascadingDeleteSchedulingPlan")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CascadingDeleteSchedulingPlanRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPlans")
.appendPathParam(request.getSchedulingPlanId())
.appendPathParam("actions")
.appendPathParam("cascadingDeleteSchedulingPlan")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
CascadingDeleteSchedulingPlanResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
CascadingDeleteSchedulingPlanResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeAutonomousContainerDatabaseCompartment(
ChangeAutonomousContainerDatabaseCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeAutonomousContainerDatabaseCompartmentRequest,
ChangeAutonomousContainerDatabaseCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
return clientCall(request, ChangeAutonomousContainerDatabaseCompartmentResponse::builder)
.logger(LOG, "changeAutonomousContainerDatabaseCompartment")
.serviceDetails(
"Database",
"ChangeAutonomousContainerDatabaseCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabase/ChangeAutonomousContainerDatabaseCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeAutonomousContainerDatabaseCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag", ChangeAutonomousContainerDatabaseCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeAutonomousContainerDatabaseCompartmentResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeAutonomousContainerDatabaseCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeAutonomousDatabaseCompartment(
ChangeAutonomousDatabaseCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeAutonomousDatabaseCompartmentRequest,
ChangeAutonomousDatabaseCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, ChangeAutonomousDatabaseCompartmentResponse::builder)
.logger(LOG, "changeAutonomousDatabaseCompartment")
.serviceDetails(
"Database",
"ChangeAutonomousDatabaseCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ChangeAutonomousDatabaseCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeAutonomousDatabaseCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag", ChangeAutonomousDatabaseCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeAutonomousDatabaseCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeAutonomousDatabaseCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeAutonomousDatabaseSoftwareImageCompartment(
ChangeAutonomousDatabaseSoftwareImageCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeAutonomousDatabaseSoftwareImageCompartmentRequest,
ChangeAutonomousDatabaseSoftwareImageCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeAutonomousDatabaseSoftwareImageCompartmentDetails(),
"changeAutonomousDatabaseSoftwareImageCompartmentDetails is required");
Validate.notBlank(
request.getAutonomousDatabaseSoftwareImageId(),
"autonomousDatabaseSoftwareImageId must not be blank");
return clientCall(
request, ChangeAutonomousDatabaseSoftwareImageCompartmentResponse::builder)
.logger(LOG, "changeAutonomousDatabaseSoftwareImageCompartment")
.serviceDetails(
"Database",
"ChangeAutonomousDatabaseSoftwareImageCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseSoftwareImage/ChangeAutonomousDatabaseSoftwareImageCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeAutonomousDatabaseSoftwareImageCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseSoftwareImages")
.appendPathParam(request.getAutonomousDatabaseSoftwareImageId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag",
ChangeAutonomousDatabaseSoftwareImageCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeAutonomousDatabaseSoftwareImageCompartmentResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeAutonomousDatabaseSoftwareImageCompartmentResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeAutonomousDatabaseSubscription(
ChangeAutonomousDatabaseSubscriptionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeAutonomousDatabaseSubscriptionRequest,
ChangeAutonomousDatabaseSubscriptionResponse>
handler) {
Objects.requireNonNull(
request.getChangeAutonomousDatabaseSubscriptionDetails(),
"changeAutonomousDatabaseSubscriptionDetails is required");
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, ChangeAutonomousDatabaseSubscriptionResponse::builder)
.logger(LOG, "changeAutonomousDatabaseSubscription")
.serviceDetails(
"Database",
"ChangeAutonomousDatabaseSubscription",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ChangeAutonomousDatabaseSubscription")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeAutonomousDatabaseSubscriptionRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeSubscription")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeAutonomousDatabaseSubscriptionResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeAutonomousDatabaseSubscriptionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeAutonomousExadataInfrastructureCompartment(
ChangeAutonomousExadataInfrastructureCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeAutonomousExadataInfrastructureCompartmentRequest,
ChangeAutonomousExadataInfrastructureCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getAutonomousExadataInfrastructureId(),
"autonomousExadataInfrastructureId must not be blank");
return clientCall(
request, ChangeAutonomousExadataInfrastructureCompartmentResponse::builder)
.logger(LOG, "changeAutonomousExadataInfrastructureCompartment")
.serviceDetails(
"Database",
"ChangeAutonomousExadataInfrastructureCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousExadataInfrastructure/ChangeAutonomousExadataInfrastructureCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeAutonomousExadataInfrastructureCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousExadataInfrastructures")
.appendPathParam(request.getAutonomousExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag",
ChangeAutonomousExadataInfrastructureCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeAutonomousExadataInfrastructureCompartmentResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeAutonomousExadataInfrastructureCompartmentResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeAutonomousVmClusterCompartment(
ChangeAutonomousVmClusterCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeAutonomousVmClusterCompartmentRequest,
ChangeAutonomousVmClusterCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeAutonomousVmClusterCompartmentDetails(),
"changeAutonomousVmClusterCompartmentDetails is required");
Validate.notBlank(
request.getAutonomousVmClusterId(), "autonomousVmClusterId must not be blank");
return clientCall(request, ChangeAutonomousVmClusterCompartmentResponse::builder)
.logger(LOG, "changeAutonomousVmClusterCompartment")
.serviceDetails(
"Database",
"ChangeAutonomousVmClusterCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousVmCluster/ChangeAutonomousVmClusterCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeAutonomousVmClusterCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousVmClusters")
.appendPathParam(request.getAutonomousVmClusterId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeAutonomousVmClusterCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeAutonomousVmClusterCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeBackupDestinationCompartment(
ChangeBackupDestinationCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeBackupDestinationCompartmentRequest,
ChangeBackupDestinationCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getBackupDestinationId(), "backupDestinationId must not be blank");
return clientCall(request, ChangeBackupDestinationCompartmentResponse::builder)
.logger(LOG, "changeBackupDestinationCompartment")
.serviceDetails(
"Database",
"ChangeBackupDestinationCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/BackupDestination/ChangeBackupDestinationCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeBackupDestinationCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("backupDestinations")
.appendPathParam(request.getBackupDestinationId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag", ChangeBackupDestinationCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeBackupDestinationCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeBackupDestinationCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeCloudAutonomousVmClusterCompartment(
ChangeCloudAutonomousVmClusterCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeCloudAutonomousVmClusterCompartmentRequest,
ChangeCloudAutonomousVmClusterCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCloudAutonomousVmClusterCompartmentDetails(),
"changeCloudAutonomousVmClusterCompartmentDetails is required");
Validate.notBlank(
request.getCloudAutonomousVmClusterId(),
"cloudAutonomousVmClusterId must not be blank");
return clientCall(request, ChangeCloudAutonomousVmClusterCompartmentResponse::builder)
.logger(LOG, "changeCloudAutonomousVmClusterCompartment")
.serviceDetails(
"Database",
"ChangeCloudAutonomousVmClusterCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudAutonomousVmCluster/ChangeCloudAutonomousVmClusterCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeCloudAutonomousVmClusterCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudAutonomousVmClusters")
.appendPathParam(request.getCloudAutonomousVmClusterId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeCloudAutonomousVmClusterCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeCloudAutonomousVmClusterCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeCloudExadataInfrastructureCompartment(
ChangeCloudExadataInfrastructureCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeCloudExadataInfrastructureCompartmentRequest,
ChangeCloudExadataInfrastructureCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCloudExadataInfrastructureCompartmentDetails(),
"changeCloudExadataInfrastructureCompartmentDetails is required");
Validate.notBlank(
request.getCloudExadataInfrastructureId(),
"cloudExadataInfrastructureId must not be blank");
return clientCall(request, ChangeCloudExadataInfrastructureCompartmentResponse::builder)
.logger(LOG, "changeCloudExadataInfrastructureCompartment")
.serviceDetails(
"Database",
"ChangeCloudExadataInfrastructureCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudExadataInfrastructure/ChangeCloudExadataInfrastructureCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeCloudExadataInfrastructureCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudExadataInfrastructures")
.appendPathParam(request.getCloudExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeCloudExadataInfrastructureCompartmentResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeCloudExadataInfrastructureCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeCloudExadataInfrastructureSubscription(
ChangeCloudExadataInfrastructureSubscriptionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeCloudExadataInfrastructureSubscriptionRequest,
ChangeCloudExadataInfrastructureSubscriptionResponse>
handler) {
Objects.requireNonNull(
request.getChangeCloudExadataInfrastructureSubscriptionDetails(),
"changeCloudExadataInfrastructureSubscriptionDetails is required");
Validate.notBlank(
request.getCloudExadataInfrastructureId(),
"cloudExadataInfrastructureId must not be blank");
return clientCall(request, ChangeCloudExadataInfrastructureSubscriptionResponse::builder)
.logger(LOG, "changeCloudExadataInfrastructureSubscription")
.serviceDetails(
"Database",
"ChangeCloudExadataInfrastructureSubscription",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudExadataInfrastructure/ChangeCloudExadataInfrastructureSubscription")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeCloudExadataInfrastructureSubscriptionRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudExadataInfrastructures")
.appendPathParam(request.getCloudExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("changeSubscription")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeCloudExadataInfrastructureSubscriptionResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeCloudExadataInfrastructureSubscriptionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeCloudVmClusterCompartment(
ChangeCloudVmClusterCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeCloudVmClusterCompartmentRequest,
ChangeCloudVmClusterCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCloudVmClusterCompartmentDetails(),
"changeCloudVmClusterCompartmentDetails is required");
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
return clientCall(request, ChangeCloudVmClusterCompartmentResponse::builder)
.logger(LOG, "changeCloudVmClusterCompartment")
.serviceDetails(
"Database",
"ChangeCloudVmClusterCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudVmCluster/ChangeCloudVmClusterCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeCloudVmClusterCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeCloudVmClusterCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeCloudVmClusterCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeCloudVmClusterSubscription(
ChangeCloudVmClusterSubscriptionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeCloudVmClusterSubscriptionRequest,
ChangeCloudVmClusterSubscriptionResponse>
handler) {
Objects.requireNonNull(
request.getChangeCloudVmClusterSubscriptionDetails(),
"changeCloudVmClusterSubscriptionDetails is required");
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
return clientCall(request, ChangeCloudVmClusterSubscriptionResponse::builder)
.logger(LOG, "changeCloudVmClusterSubscription")
.serviceDetails(
"Database",
"ChangeCloudVmClusterSubscription",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudVmCluster/ChangeCloudVmClusterSubscription")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeCloudVmClusterSubscriptionRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.appendPathParam("actions")
.appendPathParam("changeSubscription")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeCloudVmClusterSubscriptionResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeCloudVmClusterSubscriptionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeDatabaseSoftwareImageCompartment(
ChangeDatabaseSoftwareImageCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeDatabaseSoftwareImageCompartmentRequest,
ChangeDatabaseSoftwareImageCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getDatabaseSoftwareImageId(), "databaseSoftwareImageId must not be blank");
return clientCall(request, ChangeDatabaseSoftwareImageCompartmentResponse::builder)
.logger(LOG, "changeDatabaseSoftwareImageCompartment")
.serviceDetails(
"Database",
"ChangeDatabaseSoftwareImageCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DatabaseSoftwareImage/ChangeDatabaseSoftwareImageCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeDatabaseSoftwareImageCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("databaseSoftwareImages")
.appendPathParam(request.getDatabaseSoftwareImageId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag", ChangeDatabaseSoftwareImageCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeDatabaseSoftwareImageCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeDatabaseSoftwareImageCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future changeDataguardRole(
ChangeDataguardRoleRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeDataguardRoleRequest, ChangeDataguardRoleResponse>
handler) {
Objects.requireNonNull(
request.getChangeDataguardRoleDetails(), "changeDataguardRoleDetails is required");
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
return clientCall(request, ChangeDataguardRoleResponse::builder)
.logger(LOG, "changeDataguardRole")
.serviceDetails(
"Database",
"ChangeDataguardRole",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabase/ChangeDataguardRole")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeDataguardRoleRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeDataguardRole")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousContainerDatabase.class,
ChangeDataguardRoleResponse.Builder::autonomousContainerDatabase)
.handleResponseHeaderString("etag", ChangeDataguardRoleResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeDataguardRoleResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", ChangeDataguardRoleResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future changeDbSystemCompartment(
ChangeDbSystemCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeDbSystemCompartmentRequest, ChangeDbSystemCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(request.getDbSystemId(), "dbSystemId must not be blank");
return clientCall(request, ChangeDbSystemCompartmentResponse::builder)
.logger(LOG, "changeDbSystemCompartment")
.serviceDetails(
"Database",
"ChangeDbSystemCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbSystem/ChangeDbSystemCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeDbSystemCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("dbSystems")
.appendPathParam(request.getDbSystemId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString("etag", ChangeDbSystemCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeDbSystemCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", ChangeDbSystemCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeDisasterRecoveryConfiguration(
ChangeDisasterRecoveryConfigurationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeDisasterRecoveryConfigurationRequest,
ChangeDisasterRecoveryConfigurationResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
Objects.requireNonNull(
request.getChangeDisasterRecoveryConfigurationDetails(),
"changeDisasterRecoveryConfigurationDetails is required");
return clientCall(request, ChangeDisasterRecoveryConfigurationResponse::builder)
.logger(LOG, "changeDisasterRecoveryConfiguration")
.serviceDetails(
"Database",
"ChangeDisasterRecoveryConfiguration",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ChangeDisasterRecoveryConfiguration")
.method(com.oracle.bmc.http.client.Method.PUT)
.requestBuilder(ChangeDisasterRecoveryConfigurationRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeDisasterRecoveryConfiguration")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabase.class,
ChangeDisasterRecoveryConfigurationResponse.Builder::autonomousDatabase)
.handleResponseHeaderString(
"etag", ChangeDisasterRecoveryConfigurationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
ChangeDisasterRecoveryConfigurationResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeDisasterRecoveryConfigurationResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeExadataInfrastructureCompartment(
ChangeExadataInfrastructureCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeExadataInfrastructureCompartmentRequest,
ChangeExadataInfrastructureCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeExadataInfrastructureCompartmentDetails(),
"changeExadataInfrastructureCompartmentDetails is required");
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
return clientCall(request, ChangeExadataInfrastructureCompartmentResponse::builder)
.logger(LOG, "changeExadataInfrastructureCompartment")
.serviceDetails(
"Database",
"ChangeExadataInfrastructureCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/ChangeExadataInfrastructureCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeExadataInfrastructureCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeExadataInfrastructureCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeExadataInfrastructureCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeExadbVmClusterCompartment(
ChangeExadbVmClusterCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeExadbVmClusterCompartmentRequest,
ChangeExadbVmClusterCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeExadbVmClusterCompartmentDetails(),
"changeExadbVmClusterCompartmentDetails is required");
Validate.notBlank(request.getExadbVmClusterId(), "exadbVmClusterId must not be blank");
return clientCall(request, ChangeExadbVmClusterCompartmentResponse::builder)
.logger(LOG, "changeExadbVmClusterCompartment")
.serviceDetails(
"Database",
"ChangeExadbVmClusterCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadbVmCluster/ChangeExadbVmClusterCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeExadbVmClusterCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("exadbVmClusters")
.appendPathParam(request.getExadbVmClusterId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeExadbVmClusterCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeExadbVmClusterCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeExascaleDbStorageVaultCompartment(
ChangeExascaleDbStorageVaultCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeExascaleDbStorageVaultCompartmentRequest,
ChangeExascaleDbStorageVaultCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeExascaleDbStorageVaultCompartmentDetails(),
"changeExascaleDbStorageVaultCompartmentDetails is required");
Validate.notBlank(
request.getExascaleDbStorageVaultId(),
"exascaleDbStorageVaultId must not be blank");
return clientCall(request, ChangeExascaleDbStorageVaultCompartmentResponse::builder)
.logger(LOG, "changeExascaleDbStorageVaultCompartment")
.serviceDetails(
"Database",
"ChangeExascaleDbStorageVaultCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExascaleDbStorageVault/ChangeExascaleDbStorageVaultCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeExascaleDbStorageVaultCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("exascaleDbStorageVaults")
.appendPathParam(request.getExascaleDbStorageVaultId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeExascaleDbStorageVaultCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeExascaleDbStorageVaultCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeExternalContainerDatabaseCompartment(
ChangeExternalContainerDatabaseCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeExternalContainerDatabaseCompartmentRequest,
ChangeExternalContainerDatabaseCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getExternalContainerDatabaseId(),
"externalContainerDatabaseId must not be blank");
return clientCall(request, ChangeExternalContainerDatabaseCompartmentResponse::builder)
.logger(LOG, "changeExternalContainerDatabaseCompartment")
.serviceDetails(
"Database",
"ChangeExternalContainerDatabaseCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/ChangeExternalContainerDatabaseCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeExternalContainerDatabaseCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.appendPathParam(request.getExternalContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag", ChangeExternalContainerDatabaseCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeExternalContainerDatabaseCompartmentResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeExternalContainerDatabaseCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeExternalNonContainerDatabaseCompartment(
ChangeExternalNonContainerDatabaseCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeExternalNonContainerDatabaseCompartmentRequest,
ChangeExternalNonContainerDatabaseCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
return clientCall(request, ChangeExternalNonContainerDatabaseCompartmentResponse::builder)
.logger(LOG, "changeExternalNonContainerDatabaseCompartment")
.serviceDetails(
"Database",
"ChangeExternalNonContainerDatabaseCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/ChangeExternalNonContainerDatabaseCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeExternalNonContainerDatabaseCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag", ChangeExternalNonContainerDatabaseCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeExternalNonContainerDatabaseCompartmentResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeExternalNonContainerDatabaseCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeExternalPluggableDatabaseCompartment(
ChangeExternalPluggableDatabaseCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeExternalPluggableDatabaseCompartmentRequest,
ChangeExternalPluggableDatabaseCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
return clientCall(request, ChangeExternalPluggableDatabaseCompartmentResponse::builder)
.logger(LOG, "changeExternalPluggableDatabaseCompartment")
.serviceDetails(
"Database",
"ChangeExternalPluggableDatabaseCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/ChangeExternalPluggableDatabaseCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeExternalPluggableDatabaseCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag", ChangeExternalPluggableDatabaseCompartmentResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
ChangeExternalPluggableDatabaseCompartmentResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeExternalPluggableDatabaseCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future changeKeyStoreCompartment(
ChangeKeyStoreCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeKeyStoreCompartmentRequest, ChangeKeyStoreCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeKeyStoreCompartmentDetails(),
"changeKeyStoreCompartmentDetails is required");
Validate.notBlank(request.getKeyStoreId(), "keyStoreId must not be blank");
return clientCall(request, ChangeKeyStoreCompartmentResponse::builder)
.logger(LOG, "changeKeyStoreCompartment")
.serviceDetails(
"Database",
"ChangeKeyStoreCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/KeyStore/ChangeKeyStoreCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeKeyStoreCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("keyStores")
.appendPathParam(request.getKeyStoreId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeKeyStoreCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", ChangeKeyStoreCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future changeKeyStoreType(
ChangeKeyStoreTypeRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeKeyStoreTypeRequest, ChangeKeyStoreTypeResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Objects.requireNonNull(
request.getChangeKeyStoreTypeDetails(), "changeKeyStoreTypeDetails is required");
return clientCall(request, ChangeKeyStoreTypeResponse::builder)
.logger(LOG, "changeKeyStoreType")
.serviceDetails(
"Database",
"ChangeKeyStoreType",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Database/ChangeKeyStoreType")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeKeyStoreTypeRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("actions")
.appendPathParam("changeKeyStoreType")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id", ChangeKeyStoreTypeResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", ChangeKeyStoreTypeResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeOneoffPatchCompartment(
ChangeOneoffPatchCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeOneoffPatchCompartmentRequest,
ChangeOneoffPatchCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeCompartmentDetails(), "changeCompartmentDetails is required");
Validate.notBlank(request.getOneoffPatchId(), "oneoffPatchId must not be blank");
return clientCall(request, ChangeOneoffPatchCompartmentResponse::builder)
.logger(LOG, "changeOneoffPatchCompartment")
.serviceDetails(
"Database",
"ChangeOneoffPatchCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/OneoffPatch/ChangeOneoffPatchCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeOneoffPatchCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("oneoffPatches")
.appendPathParam(request.getOneoffPatchId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeOneoffPatchCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeOneoffPatchCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeSchedulingPlanCompartment(
ChangeSchedulingPlanCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeSchedulingPlanCompartmentRequest,
ChangeSchedulingPlanCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeSchedulingPlanCompartmentDetails(),
"changeSchedulingPlanCompartmentDetails is required");
Validate.notBlank(request.getSchedulingPlanId(), "schedulingPlanId must not be blank");
return clientCall(request, ChangeSchedulingPlanCompartmentResponse::builder)
.logger(LOG, "changeSchedulingPlanCompartment")
.serviceDetails(
"Database",
"ChangeSchedulingPlanCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPlan/ChangeSchedulingPlanCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeSchedulingPlanCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPlans")
.appendPathParam(request.getSchedulingPlanId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeSchedulingPlanCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeSchedulingPlanCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeSchedulingPolicyCompartment(
ChangeSchedulingPolicyCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeSchedulingPolicyCompartmentRequest,
ChangeSchedulingPolicyCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeSchedulingPolicyCompartmentDetails(),
"changeSchedulingPolicyCompartmentDetails is required");
Validate.notBlank(request.getSchedulingPolicyId(), "schedulingPolicyId must not be blank");
return clientCall(request, ChangeSchedulingPolicyCompartmentResponse::builder)
.logger(LOG, "changeSchedulingPolicyCompartment")
.serviceDetails(
"Database",
"ChangeSchedulingPolicyCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPolicy/ChangeSchedulingPolicyCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeSchedulingPolicyCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPolicies")
.appendPathParam(request.getSchedulingPolicyId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeSchedulingPolicyCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ChangeSchedulingPolicyCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
changeVmClusterCompartment(
ChangeVmClusterCompartmentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ChangeVmClusterCompartmentRequest,
ChangeVmClusterCompartmentResponse>
handler) {
Objects.requireNonNull(
request.getChangeVmClusterCompartmentDetails(),
"changeVmClusterCompartmentDetails is required");
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
return clientCall(request, ChangeVmClusterCompartmentResponse::builder)
.logger(LOG, "changeVmClusterCompartment")
.serviceDetails(
"Database",
"ChangeVmClusterCompartment",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmCluster/ChangeVmClusterCompartment")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ChangeVmClusterCompartmentRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.appendPathParam("actions")
.appendPathParam("changeCompartment")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ChangeVmClusterCompartmentResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", ChangeVmClusterCompartmentResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
checkExternalDatabaseConnectorConnectionStatus(
CheckExternalDatabaseConnectorConnectionStatusRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CheckExternalDatabaseConnectorConnectionStatusRequest,
CheckExternalDatabaseConnectorConnectionStatusResponse>
handler) {
Validate.notBlank(
request.getExternalDatabaseConnectorId(),
"externalDatabaseConnectorId must not be blank");
return clientCall(request, CheckExternalDatabaseConnectorConnectionStatusResponse::builder)
.logger(LOG, "checkExternalDatabaseConnectorConnectionStatus")
.serviceDetails(
"Database",
"CheckExternalDatabaseConnectorConnectionStatus",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalDatabaseConnector/CheckExternalDatabaseConnectorConnectionStatus")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CheckExternalDatabaseConnectorConnectionStatusRequest::builder)
.basePath("/20160918")
.appendPathParam("externaldatabaseconnectors")
.appendPathParam(request.getExternalDatabaseConnectorId())
.appendPathParam("actions")
.appendPathParam("checkConnectionStatus")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
CheckExternalDatabaseConnectorConnectionStatusResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
CheckExternalDatabaseConnectorConnectionStatusResponse.Builder
::opcRequestId)
.handleResponseHeaderString(
"etag",
CheckExternalDatabaseConnectorConnectionStatusResponse.Builder::etag)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future completeExternalBackupJob(
CompleteExternalBackupJobRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CompleteExternalBackupJobRequest, CompleteExternalBackupJobResponse>
handler) {
Validate.notBlank(request.getBackupId(), "backupId must not be blank");
Objects.requireNonNull(
request.getCompleteExternalBackupJobDetails(),
"completeExternalBackupJobDetails is required");
return clientCall(request, CompleteExternalBackupJobResponse::builder)
.logger(LOG, "completeExternalBackupJob")
.serviceDetails(
"Database",
"CompleteExternalBackupJob",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalBackupJob/CompleteExternalBackupJob")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CompleteExternalBackupJobRequest::builder)
.basePath("/20160918")
.appendPathParam("externalBackupJobs")
.appendPathParam(request.getBackupId())
.appendPathParam("actions")
.appendPathParam("complete")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExternalBackupJob.class,
CompleteExternalBackupJobResponse.Builder::externalBackupJob)
.handleResponseHeaderString(
"opc-work-request-id",
CompleteExternalBackupJobResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CompleteExternalBackupJobResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CompleteExternalBackupJobResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
configureAutonomousDatabaseVaultKey(
ConfigureAutonomousDatabaseVaultKeyRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ConfigureAutonomousDatabaseVaultKeyRequest,
ConfigureAutonomousDatabaseVaultKeyResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
Objects.requireNonNull(
request.getConfigureAutonomousDatabaseVaultKeyDetails(),
"configureAutonomousDatabaseVaultKeyDetails is required");
return clientCall(request, ConfigureAutonomousDatabaseVaultKeyResponse::builder)
.logger(LOG, "configureAutonomousDatabaseVaultKey")
.serviceDetails(
"Database",
"ConfigureAutonomousDatabaseVaultKey",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ConfigureAutonomousDatabaseVaultKey")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ConfigureAutonomousDatabaseVaultKeyRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("configureAutonomousDatabaseVaultKey")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
ConfigureAutonomousDatabaseVaultKeyResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ConfigureAutonomousDatabaseVaultKeyResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
configureExascaleExadataInfrastructure(
ConfigureExascaleExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ConfigureExascaleExadataInfrastructureRequest,
ConfigureExascaleExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Objects.requireNonNull(
request.getConfigureExascaleExadataInfrastructureDetails(),
"configureExascaleExadataInfrastructureDetails is required");
return clientCall(request, ConfigureExascaleExadataInfrastructureResponse::builder)
.logger(LOG, "configureExascaleExadataInfrastructure")
.serviceDetails(
"Database",
"ConfigureExascaleExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/ConfigureExascaleExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ConfigureExascaleExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("configureExascale")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExadataInfrastructure.class,
ConfigureExascaleExadataInfrastructureResponse.Builder
::exadataInfrastructure)
.handleResponseHeaderString(
"opc-work-request-id",
ConfigureExascaleExadataInfrastructureResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", ConfigureExascaleExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
ConfigureExascaleExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future configureSaasAdminUser(
ConfigureSaasAdminUserRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ConfigureSaasAdminUserRequest, ConfigureSaasAdminUserResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
Objects.requireNonNull(
request.getConfigureSaasAdminUserDetails(),
"configureSaasAdminUserDetails is required");
return clientCall(request, ConfigureSaasAdminUserResponse::builder)
.logger(LOG, "configureSaasAdminUser")
.serviceDetails(
"Database",
"ConfigureSaasAdminUser",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ConfigureSaasAdminUser")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ConfigureSaasAdminUserRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("configureSaasAdminUser")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabase.class,
ConfigureSaasAdminUserResponse.Builder::autonomousDatabase)
.handleResponseHeaderString("etag", ConfigureSaasAdminUserResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", ConfigureSaasAdminUserResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
ConfigureSaasAdminUserResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
confirmKeyStoreDetailsAreCorrect(
ConfirmKeyStoreDetailsAreCorrectRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ConfirmKeyStoreDetailsAreCorrectRequest,
ConfirmKeyStoreDetailsAreCorrectResponse>
handler) {
Validate.notBlank(request.getKeyStoreId(), "keyStoreId must not be blank");
return clientCall(request, ConfirmKeyStoreDetailsAreCorrectResponse::builder)
.logger(LOG, "confirmKeyStoreDetailsAreCorrect")
.serviceDetails(
"Database",
"ConfirmKeyStoreDetailsAreCorrect",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/KeyStore/ConfirmKeyStoreDetailsAreCorrect")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ConfirmKeyStoreDetailsAreCorrectRequest::builder)
.basePath("/20160918")
.appendPathParam("keyStores")
.appendPathParam(request.getKeyStoreId())
.appendPathParam("actions")
.appendPathParam("confirmDetailsAreCorrect")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
ConfirmKeyStoreDetailsAreCorrectResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
ConfirmKeyStoreDetailsAreCorrectResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future convertToPdb(
ConvertToPdbRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Objects.requireNonNull(request.getConvertToPdbDetails(), "convertToPdbDetails is required");
return clientCall(request, ConvertToPdbResponse::builder)
.logger(LOG, "convertToPdb")
.serviceDetails(
"Database",
"ConvertToPdb",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Database/ConvertToPdb")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ConvertToPdbRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("actions")
.appendPathParam("convertToPdb")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.Database.class,
ConvertToPdbResponse.Builder::database)
.handleResponseHeaderString(
"opc-work-request-id", ConvertToPdbResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", ConvertToPdbResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", ConvertToPdbResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
convertToRegularPluggableDatabase(
ConvertToRegularPluggableDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ConvertToRegularPluggableDatabaseRequest,
ConvertToRegularPluggableDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getConvertToRegularPluggableDatabaseDetails(),
"convertToRegularPluggableDatabaseDetails is required");
Validate.notBlank(
request.getPluggableDatabaseId(), "pluggableDatabaseId must not be blank");
return clientCall(request, ConvertToRegularPluggableDatabaseResponse::builder)
.logger(LOG, "convertToRegularPluggableDatabase")
.serviceDetails(
"Database",
"ConvertToRegularPluggableDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PluggableDatabase/ConvertToRegularPluggableDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(ConvertToRegularPluggableDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("pluggableDatabases")
.appendPathParam(request.getPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("convertToRegular")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.PluggableDatabase.class,
ConvertToRegularPluggableDatabaseResponse.Builder::pluggableDatabase)
.handleResponseHeaderString(
"opc-work-request-id",
ConvertToRegularPluggableDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", ConvertToRegularPluggableDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
ConvertToRegularPluggableDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createApplicationVip(
CreateApplicationVipRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateApplicationVipRequest, CreateApplicationVipResponse>
handler) {
Objects.requireNonNull(
request.getCreateApplicationVipDetails(),
"createApplicationVipDetails is required");
return clientCall(request, CreateApplicationVipResponse::builder)
.logger(LOG, "createApplicationVip")
.serviceDetails(
"Database",
"CreateApplicationVip",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ApplicationVip/CreateApplicationVip")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateApplicationVipRequest::builder)
.basePath("/20160918")
.appendPathParam("applicationVip")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ApplicationVip.class,
CreateApplicationVipResponse.Builder::applicationVip)
.handleResponseHeaderString(
"opc-work-request-id",
CreateApplicationVipResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateApplicationVipResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateApplicationVipResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createAutonomousContainerDatabase(
CreateAutonomousContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateAutonomousContainerDatabaseRequest,
CreateAutonomousContainerDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getCreateAutonomousContainerDatabaseDetails(),
"createAutonomousContainerDatabaseDetails is required");
return clientCall(request, CreateAutonomousContainerDatabaseResponse::builder)
.logger(LOG, "createAutonomousContainerDatabase")
.serviceDetails(
"Database",
"CreateAutonomousContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabase/CreateAutonomousContainerDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateAutonomousContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousContainerDatabase.class,
CreateAutonomousContainerDatabaseResponse.Builder
::autonomousContainerDatabase)
.handleResponseHeaderString(
"etag", CreateAutonomousContainerDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateAutonomousContainerDatabaseResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
CreateAutonomousContainerDatabaseResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future<
CreateAutonomousContainerDatabaseDataguardAssociationResponse>
createAutonomousContainerDatabaseDataguardAssociation(
CreateAutonomousContainerDatabaseDataguardAssociationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateAutonomousContainerDatabaseDataguardAssociationRequest,
CreateAutonomousContainerDatabaseDataguardAssociationResponse>
handler) {
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
Objects.requireNonNull(
request.getCreateAutonomousContainerDatabaseDataguardAssociationDetails(),
"createAutonomousContainerDatabaseDataguardAssociationDetails is required");
return clientCall(
request,
CreateAutonomousContainerDatabaseDataguardAssociationResponse::builder)
.logger(LOG, "createAutonomousContainerDatabaseDataguardAssociation")
.serviceDetails(
"Database",
"CreateAutonomousContainerDatabaseDataguardAssociation",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabaseDataguardAssociation/CreateAutonomousContainerDatabaseDataguardAssociation")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(
CreateAutonomousContainerDatabaseDataguardAssociationRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.appendPathParam("autonomousContainerDatabaseDataguardAssociations")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model
.AutonomousContainerDatabaseDataguardAssociation.class,
CreateAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::autonomousContainerDatabaseDataguardAssociation)
.handleResponseHeaderString(
"opc-work-request-id",
CreateAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"etag",
CreateAutonomousContainerDatabaseDataguardAssociationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createAutonomousDatabase(
CreateAutonomousDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateAutonomousDatabaseRequest, CreateAutonomousDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getCreateAutonomousDatabaseDetails(),
"createAutonomousDatabaseDetails is required");
return clientCall(request, CreateAutonomousDatabaseResponse::builder)
.logger(LOG, "createAutonomousDatabase")
.serviceDetails(
"Database",
"CreateAutonomousDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/CreateAutonomousDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateAutonomousDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabase.class,
CreateAutonomousDatabaseResponse.Builder::autonomousDatabase)
.handleResponseHeaderString("etag", CreateAutonomousDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateAutonomousDatabaseResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
CreateAutonomousDatabaseResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createAutonomousDatabaseBackup(
CreateAutonomousDatabaseBackupRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateAutonomousDatabaseBackupRequest,
CreateAutonomousDatabaseBackupResponse>
handler) {
Objects.requireNonNull(
request.getCreateAutonomousDatabaseBackupDetails(),
"createAutonomousDatabaseBackupDetails is required");
return clientCall(request, CreateAutonomousDatabaseBackupResponse::builder)
.logger(LOG, "createAutonomousDatabaseBackup")
.serviceDetails(
"Database",
"CreateAutonomousDatabaseBackup",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseBackup/CreateAutonomousDatabaseBackup")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateAutonomousDatabaseBackupRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseBackups")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseBackup.class,
CreateAutonomousDatabaseBackupResponse.Builder::autonomousDatabaseBackup)
.handleResponseHeaderString(
"etag", CreateAutonomousDatabaseBackupResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateAutonomousDatabaseBackupResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
CreateAutonomousDatabaseBackupResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createAutonomousDatabaseSoftwareImage(
CreateAutonomousDatabaseSoftwareImageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateAutonomousDatabaseSoftwareImageRequest,
CreateAutonomousDatabaseSoftwareImageResponse>
handler) {
Objects.requireNonNull(
request.getCreateAutonomousDatabaseSoftwareImageDetails(),
"createAutonomousDatabaseSoftwareImageDetails is required");
return clientCall(request, CreateAutonomousDatabaseSoftwareImageResponse::builder)
.logger(LOG, "createAutonomousDatabaseSoftwareImage")
.serviceDetails(
"Database",
"CreateAutonomousDatabaseSoftwareImage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseSoftwareImage/CreateAutonomousDatabaseSoftwareImage")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateAutonomousDatabaseSoftwareImageRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseSoftwareImages")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseSoftwareImage.class,
CreateAutonomousDatabaseSoftwareImageResponse.Builder
::autonomousDatabaseSoftwareImage)
.handleResponseHeaderString(
"opc-work-request-id",
CreateAutonomousDatabaseSoftwareImageResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateAutonomousDatabaseSoftwareImageResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateAutonomousDatabaseSoftwareImageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createAutonomousVmCluster(
CreateAutonomousVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateAutonomousVmClusterRequest, CreateAutonomousVmClusterResponse>
handler) {
Objects.requireNonNull(
request.getCreateAutonomousVmClusterDetails(),
"createAutonomousVmClusterDetails is required");
return clientCall(request, CreateAutonomousVmClusterResponse::builder)
.logger(LOG, "createAutonomousVmCluster")
.serviceDetails(
"Database",
"CreateAutonomousVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousVmCluster/CreateAutonomousVmCluster")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateAutonomousVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousVmClusters")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousVmCluster.class,
CreateAutonomousVmClusterResponse.Builder::autonomousVmCluster)
.handleResponseHeaderString(
"opc-work-request-id",
CreateAutonomousVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateAutonomousVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateAutonomousVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createBackup(
CreateBackupRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Objects.requireNonNull(request.getCreateBackupDetails(), "createBackupDetails is required");
return clientCall(request, CreateBackupResponse::builder)
.logger(LOG, "createBackup")
.serviceDetails(
"Database",
"CreateBackup",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Backup/CreateBackup")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateBackupRequest::builder)
.basePath("/20160918")
.appendPathParam("backups")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.Backup.class,
CreateBackupResponse.Builder::backup)
.handleResponseHeaderString(
"opc-work-request-id", CreateBackupResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateBackupResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateBackupResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createBackupDestination(
CreateBackupDestinationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateBackupDestinationRequest, CreateBackupDestinationResponse>
handler) {
Objects.requireNonNull(
request.getCreateBackupDestinationDetails(),
"createBackupDestinationDetails is required");
return clientCall(request, CreateBackupDestinationResponse::builder)
.logger(LOG, "createBackupDestination")
.serviceDetails(
"Database",
"CreateBackupDestination",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/BackupDestination/CreateBackupDestination")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateBackupDestinationRequest::builder)
.basePath("/20160918")
.appendPathParam("backupDestinations")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.BackupDestination.class,
CreateBackupDestinationResponse.Builder::backupDestination)
.handleResponseHeaderString("etag", CreateBackupDestinationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateBackupDestinationResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createCloudAutonomousVmCluster(
CreateCloudAutonomousVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateCloudAutonomousVmClusterRequest,
CreateCloudAutonomousVmClusterResponse>
handler) {
Objects.requireNonNull(
request.getCreateCloudAutonomousVmClusterDetails(),
"createCloudAutonomousVmClusterDetails is required");
return clientCall(request, CreateCloudAutonomousVmClusterResponse::builder)
.logger(LOG, "createCloudAutonomousVmCluster")
.serviceDetails(
"Database",
"CreateCloudAutonomousVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudAutonomousVmCluster/CreateCloudAutonomousVmCluster")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateCloudAutonomousVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudAutonomousVmClusters")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.CloudAutonomousVmCluster.class,
CreateCloudAutonomousVmClusterResponse.Builder::cloudAutonomousVmCluster)
.handleResponseHeaderString(
"opc-work-request-id",
CreateCloudAutonomousVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateCloudAutonomousVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateCloudAutonomousVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createCloudExadataInfrastructure(
CreateCloudExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateCloudExadataInfrastructureRequest,
CreateCloudExadataInfrastructureResponse>
handler) {
Objects.requireNonNull(
request.getCreateCloudExadataInfrastructureDetails(),
"createCloudExadataInfrastructureDetails is required");
return clientCall(request, CreateCloudExadataInfrastructureResponse::builder)
.logger(LOG, "createCloudExadataInfrastructure")
.serviceDetails(
"Database",
"CreateCloudExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudExadataInfrastructure/CreateCloudExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateCloudExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudExadataInfrastructures")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.CloudExadataInfrastructure.class,
CreateCloudExadataInfrastructureResponse.Builder
::cloudExadataInfrastructure)
.handleResponseHeaderString(
"opc-work-request-id",
CreateCloudExadataInfrastructureResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateCloudExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateCloudExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createCloudVmCluster(
CreateCloudVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateCloudVmClusterRequest, CreateCloudVmClusterResponse>
handler) {
Objects.requireNonNull(
request.getCreateCloudVmClusterDetails(),
"createCloudVmClusterDetails is required");
return clientCall(request, CreateCloudVmClusterResponse::builder)
.logger(LOG, "createCloudVmCluster")
.serviceDetails(
"Database",
"CreateCloudVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudVmCluster/CreateCloudVmCluster")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateCloudVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.CloudVmCluster.class,
CreateCloudVmClusterResponse.Builder::cloudVmCluster)
.handleResponseHeaderString(
"opc-work-request-id",
CreateCloudVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateCloudVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateCloudVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createConsoleConnection(
CreateConsoleConnectionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateConsoleConnectionRequest, CreateConsoleConnectionResponse>
handler) {
Objects.requireNonNull(
request.getCreateConsoleConnectionDetails(),
"createConsoleConnectionDetails is required");
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
return clientCall(request, CreateConsoleConnectionResponse::builder)
.logger(LOG, "createConsoleConnection")
.serviceDetails(
"Database",
"CreateConsoleConnection",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ConsoleConnection/CreateConsoleConnection")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateConsoleConnectionRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendPathParam("consoleConnections")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ConsoleConnection.class,
CreateConsoleConnectionResponse.Builder::consoleConnection)
.handleResponseHeaderString("etag", CreateConsoleConnectionResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateConsoleConnectionResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
CreateConsoleConnectionResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createConsoleHistory(
CreateConsoleHistoryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateConsoleHistoryRequest, CreateConsoleHistoryResponse>
handler) {
Objects.requireNonNull(
request.getCreateConsoleHistoryDetails(),
"createConsoleHistoryDetails is required");
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
return clientCall(request, CreateConsoleHistoryResponse::builder)
.logger(LOG, "createConsoleHistory")
.serviceDetails(
"Database",
"CreateConsoleHistory",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ConsoleHistory/CreateConsoleHistory")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateConsoleHistoryRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendPathParam("consoleHistories")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ConsoleHistory.class,
CreateConsoleHistoryResponse.Builder::consoleHistory)
.handleResponseHeaderString("etag", CreateConsoleHistoryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateConsoleHistoryResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
CreateConsoleHistoryResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createDataGuardAssociation(
CreateDataGuardAssociationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateDataGuardAssociationRequest,
CreateDataGuardAssociationResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Objects.requireNonNull(
request.getCreateDataGuardAssociationDetails(),
"createDataGuardAssociationDetails is required");
return clientCall(request, CreateDataGuardAssociationResponse::builder)
.logger(LOG, "createDataGuardAssociation")
.serviceDetails(
"Database",
"CreateDataGuardAssociation",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DataGuardAssociation/CreateDataGuardAssociation")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateDataGuardAssociationRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("dataGuardAssociations")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.DataGuardAssociation.class,
CreateDataGuardAssociationResponse.Builder::dataGuardAssociation)
.handleResponseHeaderString(
"opc-work-request-id",
CreateDataGuardAssociationResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateDataGuardAssociationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateDataGuardAssociationResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createDatabase(
CreateDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateDatabaseRequest, CreateDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getCreateNewDatabaseDetails(), "createNewDatabaseDetails is required");
return clientCall(request, CreateDatabaseResponse::builder)
.logger(LOG, "createDatabase")
.serviceDetails(
"Database",
"CreateDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Database/CreateDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.Database.class,
CreateDatabaseResponse.Builder::database)
.handleResponseHeaderString(
"opc-work-request-id", CreateDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createDatabaseSoftwareImage(
CreateDatabaseSoftwareImageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateDatabaseSoftwareImageRequest,
CreateDatabaseSoftwareImageResponse>
handler) {
Objects.requireNonNull(
request.getCreateDatabaseSoftwareImageDetails(),
"createDatabaseSoftwareImageDetails is required");
return clientCall(request, CreateDatabaseSoftwareImageResponse::builder)
.logger(LOG, "createDatabaseSoftwareImage")
.serviceDetails(
"Database",
"CreateDatabaseSoftwareImage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DatabaseSoftwareImage/CreateDatabaseSoftwareImage")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateDatabaseSoftwareImageRequest::builder)
.basePath("/20160918")
.appendPathParam("databaseSoftwareImages")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.DatabaseSoftwareImage.class,
CreateDatabaseSoftwareImageResponse.Builder::databaseSoftwareImage)
.handleResponseHeaderString(
"opc-work-request-id",
CreateDatabaseSoftwareImageResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateDatabaseSoftwareImageResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateDatabaseSoftwareImageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createDbHome(
CreateDbHomeRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Objects.requireNonNull(
request.getCreateDbHomeWithDbSystemIdDetails(),
"createDbHomeWithDbSystemIdDetails is required");
return clientCall(request, CreateDbHomeResponse::builder)
.logger(LOG, "createDbHome")
.serviceDetails(
"Database",
"CreateDbHome",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbHome/CreateDbHome")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateDbHomeRequest::builder)
.basePath("/20160918")
.appendPathParam("dbHomes")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.DbHome.class,
CreateDbHomeResponse.Builder::dbHome)
.handleResponseHeaderString(
"opc-work-request-id", CreateDbHomeResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateDbHomeResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateDbHomeResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createExadataInfrastructure(
CreateExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExadataInfrastructureRequest,
CreateExadataInfrastructureResponse>
handler) {
Objects.requireNonNull(
request.getCreateExadataInfrastructureDetails(),
"createExadataInfrastructureDetails is required");
return clientCall(request, CreateExadataInfrastructureResponse::builder)
.logger(LOG, "createExadataInfrastructure")
.serviceDetails(
"Database",
"CreateExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/CreateExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExadataInfrastructure.class,
CreateExadataInfrastructureResponse.Builder::exadataInfrastructure)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExadataInfrastructureResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createExadbVmCluster(
CreateExadbVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExadbVmClusterRequest, CreateExadbVmClusterResponse>
handler) {
Objects.requireNonNull(
request.getCreateExadbVmClusterDetails(),
"createExadbVmClusterDetails is required");
return clientCall(request, CreateExadbVmClusterResponse::builder)
.logger(LOG, "createExadbVmCluster")
.serviceDetails(
"Database",
"CreateExadbVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadbVmCluster/CreateExadbVmCluster")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExadbVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("exadbVmClusters")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExadbVmCluster.class,
CreateExadbVmClusterResponse.Builder::exadbVmCluster)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExadbVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateExadbVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateExadbVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createExascaleDbStorageVault(
CreateExascaleDbStorageVaultRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExascaleDbStorageVaultRequest,
CreateExascaleDbStorageVaultResponse>
handler) {
Objects.requireNonNull(
request.getCreateExascaleDbStorageVaultDetails(),
"createExascaleDbStorageVaultDetails is required");
return clientCall(request, CreateExascaleDbStorageVaultResponse::builder)
.logger(LOG, "createExascaleDbStorageVault")
.serviceDetails(
"Database",
"CreateExascaleDbStorageVault",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExascaleDbStorageVault/CreateExascaleDbStorageVault")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExascaleDbStorageVaultRequest::builder)
.basePath("/20160918")
.appendPathParam("exascaleDbStorageVaults")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExascaleDbStorageVault.class,
CreateExascaleDbStorageVaultResponse.Builder::exascaleDbStorageVault)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExascaleDbStorageVaultResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateExascaleDbStorageVaultResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateExascaleDbStorageVaultResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createExecutionAction(
CreateExecutionActionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExecutionActionRequest, CreateExecutionActionResponse>
handler) {
Objects.requireNonNull(
request.getCreateExecutionActionDetails(),
"createExecutionActionDetails is required");
return clientCall(request, CreateExecutionActionResponse::builder)
.logger(LOG, "createExecutionAction")
.serviceDetails(
"Database",
"CreateExecutionAction",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExecutionAction/CreateExecutionAction")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExecutionActionRequest::builder)
.basePath("/20160918")
.appendPathParam("executionActions")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExecutionAction.class,
CreateExecutionActionResponse.Builder::executionAction)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExecutionActionResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateExecutionActionResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateExecutionActionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createExecutionWindow(
CreateExecutionWindowRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExecutionWindowRequest, CreateExecutionWindowResponse>
handler) {
Objects.requireNonNull(
request.getCreateExecutionWindowDetails(),
"createExecutionWindowDetails is required");
return clientCall(request, CreateExecutionWindowResponse::builder)
.logger(LOG, "createExecutionWindow")
.serviceDetails(
"Database",
"CreateExecutionWindow",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExecutionWindow/CreateExecutionWindow")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExecutionWindowRequest::builder)
.basePath("/20160918")
.appendPathParam("executionWindows")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExecutionWindow.class,
CreateExecutionWindowResponse.Builder::executionWindow)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExecutionWindowResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateExecutionWindowResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateExecutionWindowResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createExternalBackupJob(
CreateExternalBackupJobRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExternalBackupJobRequest, CreateExternalBackupJobResponse>
handler) {
Objects.requireNonNull(
request.getCreateExternalBackupJobDetails(),
"createExternalBackupJobDetails is required");
return clientCall(request, CreateExternalBackupJobResponse::builder)
.logger(LOG, "createExternalBackupJob")
.serviceDetails(
"Database",
"CreateExternalBackupJob",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalBackupJob/CreateExternalBackupJob")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExternalBackupJobRequest::builder)
.basePath("/20160918")
.appendPathParam("externalBackupJobs")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExternalBackupJob.class,
CreateExternalBackupJobResponse.Builder::externalBackupJob)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExternalBackupJobResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateExternalBackupJobResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateExternalBackupJobResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createExternalContainerDatabase(
CreateExternalContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExternalContainerDatabaseRequest,
CreateExternalContainerDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getCreateExternalContainerDatabaseDetails(),
"createExternalContainerDatabaseDetails is required");
return clientCall(request, CreateExternalContainerDatabaseResponse::builder)
.logger(LOG, "createExternalContainerDatabase")
.serviceDetails(
"Database",
"CreateExternalContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/CreateExternalContainerDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExternalContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExternalContainerDatabase.class,
CreateExternalContainerDatabaseResponse.Builder::externalContainerDatabase)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExternalContainerDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateExternalContainerDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateExternalContainerDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createExternalDatabaseConnector(
CreateExternalDatabaseConnectorRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExternalDatabaseConnectorRequest,
CreateExternalDatabaseConnectorResponse>
handler) {
Objects.requireNonNull(
request.getCreateExternalDatabaseConnectorDetails(),
"createExternalDatabaseConnectorDetails is required");
return clientCall(request, CreateExternalDatabaseConnectorResponse::builder)
.logger(LOG, "createExternalDatabaseConnector")
.serviceDetails(
"Database",
"CreateExternalDatabaseConnector",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalDatabaseConnector/CreateExternalDatabaseConnector")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExternalDatabaseConnectorRequest::builder)
.basePath("/20160918")
.appendPathParam("externaldatabaseconnectors")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExternalDatabaseConnector.class,
CreateExternalDatabaseConnectorResponse.Builder::externalDatabaseConnector)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExternalDatabaseConnectorResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateExternalDatabaseConnectorResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateExternalDatabaseConnectorResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createExternalNonContainerDatabase(
CreateExternalNonContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExternalNonContainerDatabaseRequest,
CreateExternalNonContainerDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getCreateExternalNonContainerDatabaseDetails(),
"createExternalNonContainerDatabaseDetails is required");
return clientCall(request, CreateExternalNonContainerDatabaseResponse::builder)
.logger(LOG, "createExternalNonContainerDatabase")
.serviceDetails(
"Database",
"CreateExternalNonContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/CreateExternalNonContainerDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExternalNonContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExternalNonContainerDatabase.class,
CreateExternalNonContainerDatabaseResponse.Builder
::externalNonContainerDatabase)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExternalNonContainerDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateExternalNonContainerDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateExternalNonContainerDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
createExternalPluggableDatabase(
CreateExternalPluggableDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateExternalPluggableDatabaseRequest,
CreateExternalPluggableDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getCreateExternalPluggableDatabaseDetails(),
"createExternalPluggableDatabaseDetails is required");
return clientCall(request, CreateExternalPluggableDatabaseResponse::builder)
.logger(LOG, "createExternalPluggableDatabase")
.serviceDetails(
"Database",
"CreateExternalPluggableDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/CreateExternalPluggableDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateExternalPluggableDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ExternalPluggableDatabase.class,
CreateExternalPluggableDatabaseResponse.Builder::externalPluggableDatabase)
.handleResponseHeaderString(
"opc-work-request-id",
CreateExternalPluggableDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", CreateExternalPluggableDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
CreateExternalPluggableDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createKeyStore(
CreateKeyStoreRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateKeyStoreRequest, CreateKeyStoreResponse>
handler) {
Objects.requireNonNull(
request.getCreateKeyStoreDetails(), "createKeyStoreDetails is required");
return clientCall(request, CreateKeyStoreResponse::builder)
.logger(LOG, "createKeyStore")
.serviceDetails(
"Database",
"CreateKeyStore",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/KeyStore/CreateKeyStore")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateKeyStoreRequest::builder)
.basePath("/20160918")
.appendPathParam("keyStores")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.KeyStore.class,
CreateKeyStoreResponse.Builder::keyStore)
.handleResponseHeaderString("etag", CreateKeyStoreResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateKeyStoreResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createMaintenanceRun(
CreateMaintenanceRunRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateMaintenanceRunRequest, CreateMaintenanceRunResponse>
handler) {
Objects.requireNonNull(
request.getCreateMaintenanceRunDetails(),
"createMaintenanceRunDetails is required");
return clientCall(request, CreateMaintenanceRunResponse::builder)
.logger(LOG, "createMaintenanceRun")
.serviceDetails(
"Database",
"CreateMaintenanceRun",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/MaintenanceRun/CreateMaintenanceRun")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateMaintenanceRunRequest::builder)
.basePath("/20160918")
.appendPathParam("maintenanceRuns")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.MaintenanceRun.class,
CreateMaintenanceRunResponse.Builder::maintenanceRun)
.handleResponseHeaderString("etag", CreateMaintenanceRunResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateMaintenanceRunResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createOneoffPatch(
CreateOneoffPatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateOneoffPatchRequest, CreateOneoffPatchResponse>
handler) {
Objects.requireNonNull(
request.getCreateOneoffPatchDetails(), "createOneoffPatchDetails is required");
return clientCall(request, CreateOneoffPatchResponse::builder)
.logger(LOG, "createOneoffPatch")
.serviceDetails(
"Database",
"CreateOneoffPatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/OneoffPatch/CreateOneoffPatch")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateOneoffPatchRequest::builder)
.basePath("/20160918")
.appendPathParam("oneoffPatches")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.OneoffPatch.class,
CreateOneoffPatchResponse.Builder::oneoffPatch)
.handleResponseHeaderString(
"opc-work-request-id", CreateOneoffPatchResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateOneoffPatchResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateOneoffPatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createPluggableDatabase(
CreatePluggableDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreatePluggableDatabaseRequest, CreatePluggableDatabaseResponse>
handler) {
Objects.requireNonNull(
request.getCreatePluggableDatabaseDetails(),
"createPluggableDatabaseDetails is required");
return clientCall(request, CreatePluggableDatabaseResponse::builder)
.logger(LOG, "createPluggableDatabase")
.serviceDetails(
"Database",
"CreatePluggableDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PluggableDatabase/CreatePluggableDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreatePluggableDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("pluggableDatabases")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.PluggableDatabase.class,
CreatePluggableDatabaseResponse.Builder::pluggableDatabase)
.handleResponseHeaderString(
"opc-work-request-id",
CreatePluggableDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreatePluggableDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreatePluggableDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createScheduledAction(
CreateScheduledActionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateScheduledActionRequest, CreateScheduledActionResponse>
handler) {
Objects.requireNonNull(
request.getCreateScheduledActionDetails(),
"createScheduledActionDetails is required");
return clientCall(request, CreateScheduledActionResponse::builder)
.logger(LOG, "createScheduledAction")
.serviceDetails("Database", "CreateScheduledAction", "")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateScheduledActionRequest::builder)
.basePath("/20160918")
.appendPathParam("scheduledActions")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.ScheduledAction.class,
CreateScheduledActionResponse.Builder::scheduledAction)
.handleResponseHeaderString(
"opc-work-request-id",
CreateScheduledActionResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateScheduledActionResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateScheduledActionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createSchedulingPlan(
CreateSchedulingPlanRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateSchedulingPlanRequest, CreateSchedulingPlanResponse>
handler) {
Objects.requireNonNull(
request.getCreateSchedulingPlanDetails(),
"createSchedulingPlanDetails is required");
return clientCall(request, CreateSchedulingPlanResponse::builder)
.logger(LOG, "createSchedulingPlan")
.serviceDetails("Database", "CreateSchedulingPlan", "")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateSchedulingPlanRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPlans")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.SchedulingPlan.class,
CreateSchedulingPlanResponse.Builder::schedulingPlan)
.handleResponseHeaderString(
"opc-work-request-id",
CreateSchedulingPlanResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateSchedulingPlanResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateSchedulingPlanResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createSchedulingPolicy(
CreateSchedulingPolicyRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateSchedulingPolicyRequest, CreateSchedulingPolicyResponse>
handler) {
Objects.requireNonNull(
request.getCreateSchedulingPolicyDetails(),
"createSchedulingPolicyDetails is required");
return clientCall(request, CreateSchedulingPolicyResponse::builder)
.logger(LOG, "createSchedulingPolicy")
.serviceDetails(
"Database",
"CreateSchedulingPolicy",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPolicy/CreateSchedulingPolicy")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateSchedulingPolicyRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPolicies")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.SchedulingPolicy.class,
CreateSchedulingPolicyResponse.Builder::schedulingPolicy)
.handleResponseHeaderString(
"opc-work-request-id",
CreateSchedulingPolicyResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateSchedulingPolicyResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateSchedulingPolicyResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createSchedulingWindow(
CreateSchedulingWindowRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateSchedulingWindowRequest, CreateSchedulingWindowResponse>
handler) {
Validate.notBlank(request.getSchedulingPolicyId(), "schedulingPolicyId must not be blank");
Objects.requireNonNull(
request.getCreateSchedulingWindowDetails(),
"createSchedulingWindowDetails is required");
return clientCall(request, CreateSchedulingWindowResponse::builder)
.logger(LOG, "createSchedulingWindow")
.serviceDetails(
"Database",
"CreateSchedulingWindow",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingWindow/CreateSchedulingWindow")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateSchedulingWindowRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPolicies")
.appendPathParam(request.getSchedulingPolicyId())
.appendPathParam("schedulingWindows")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.SchedulingWindow.class,
CreateSchedulingWindowResponse.Builder::schedulingWindow)
.handleResponseHeaderString(
"opc-work-request-id",
CreateSchedulingWindowResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateSchedulingWindowResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateSchedulingWindowResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createVmCluster(
CreateVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateVmClusterRequest, CreateVmClusterResponse>
handler) {
Objects.requireNonNull(
request.getCreateVmClusterDetails(), "createVmClusterDetails is required");
return clientCall(request, CreateVmClusterResponse::builder)
.logger(LOG, "createVmCluster")
.serviceDetails(
"Database",
"CreateVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmCluster/CreateVmCluster")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.VmCluster.class,
CreateVmClusterResponse.Builder::vmCluster)
.handleResponseHeaderString(
"opc-work-request-id", CreateVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future createVmClusterNetwork(
CreateVmClusterNetworkRequest request,
final com.oracle.bmc.responses.AsyncHandler<
CreateVmClusterNetworkRequest, CreateVmClusterNetworkResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Objects.requireNonNull(
request.getVmClusterNetworkDetails(), "vmClusterNetworkDetails is required");
return clientCall(request, CreateVmClusterNetworkResponse::builder)
.logger(LOG, "createVmClusterNetwork")
.serviceDetails(
"Database",
"CreateVmClusterNetwork",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmClusterNetwork/CreateVmClusterNetwork")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(CreateVmClusterNetworkRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("vmClusterNetworks")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.VmClusterNetwork.class,
CreateVmClusterNetworkResponse.Builder::vmClusterNetwork)
.handleResponseHeaderString(
"opc-work-request-id",
CreateVmClusterNetworkResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", CreateVmClusterNetworkResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", CreateVmClusterNetworkResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future dbNodeAction(
DbNodeActionRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
Objects.requireNonNull(request.getAction(), "action is required");
return clientCall(request, DbNodeActionResponse::builder)
.logger(LOG, "dbNodeAction")
.serviceDetails(
"Database",
"DbNodeAction",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbNode/DbNodeAction")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DbNodeActionRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendQueryParam("action", request.getAction())
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("if-match", request.getIfMatch())
.handleBody(
com.oracle.bmc.database.model.DbNode.class,
DbNodeActionResponse.Builder::dbNode)
.handleResponseHeaderString(
"opc-work-request-id", DbNodeActionResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", DbNodeActionResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", DbNodeActionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteApplicationVip(
DeleteApplicationVipRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteApplicationVipRequest, DeleteApplicationVipResponse>
handler) {
Validate.notBlank(request.getApplicationVipId(), "applicationVipId must not be blank");
return clientCall(request, DeleteApplicationVipResponse::builder)
.logger(LOG, "deleteApplicationVip")
.serviceDetails(
"Database",
"DeleteApplicationVip",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ApplicationVip/DeleteApplicationVip")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteApplicationVipRequest::builder)
.basePath("/20160918")
.appendPathParam("applicationVip")
.appendPathParam(request.getApplicationVipId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteApplicationVipResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteApplicationVipResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteAutonomousDatabase(
DeleteAutonomousDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteAutonomousDatabaseRequest, DeleteAutonomousDatabaseResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, DeleteAutonomousDatabaseResponse::builder)
.logger(LOG, "deleteAutonomousDatabase")
.serviceDetails(
"Database",
"DeleteAutonomousDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/DeleteAutonomousDatabase")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteAutonomousDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-request-id", DeleteAutonomousDatabaseResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
DeleteAutonomousDatabaseResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteAutonomousDatabaseBackup(
DeleteAutonomousDatabaseBackupRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteAutonomousDatabaseBackupRequest,
DeleteAutonomousDatabaseBackupResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseBackupId(),
"autonomousDatabaseBackupId must not be blank");
return clientCall(request, DeleteAutonomousDatabaseBackupResponse::builder)
.logger(LOG, "deleteAutonomousDatabaseBackup")
.serviceDetails(
"Database",
"DeleteAutonomousDatabaseBackup",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseBackup/DeleteAutonomousDatabaseBackup")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteAutonomousDatabaseBackupRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseBackups")
.appendPathParam(request.getAutonomousDatabaseBackupId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-request-id",
DeleteAutonomousDatabaseBackupResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
DeleteAutonomousDatabaseBackupResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteAutonomousDatabaseSoftwareImage(
DeleteAutonomousDatabaseSoftwareImageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteAutonomousDatabaseSoftwareImageRequest,
DeleteAutonomousDatabaseSoftwareImageResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseSoftwareImageId(),
"autonomousDatabaseSoftwareImageId must not be blank");
return clientCall(request, DeleteAutonomousDatabaseSoftwareImageResponse::builder)
.logger(LOG, "deleteAutonomousDatabaseSoftwareImage")
.serviceDetails(
"Database",
"DeleteAutonomousDatabaseSoftwareImage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseSoftwareImage/DeleteAutonomousDatabaseSoftwareImage")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteAutonomousDatabaseSoftwareImageRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseSoftwareImages")
.appendPathParam(request.getAutonomousDatabaseSoftwareImageId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteAutonomousDatabaseSoftwareImageResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteAutonomousDatabaseSoftwareImageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteAutonomousVmCluster(
DeleteAutonomousVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteAutonomousVmClusterRequest, DeleteAutonomousVmClusterResponse>
handler) {
Validate.notBlank(
request.getAutonomousVmClusterId(), "autonomousVmClusterId must not be blank");
return clientCall(request, DeleteAutonomousVmClusterResponse::builder)
.logger(LOG, "deleteAutonomousVmCluster")
.serviceDetails(
"Database",
"DeleteAutonomousVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousVmCluster/DeleteAutonomousVmCluster")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteAutonomousVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousVmClusters")
.appendPathParam(request.getAutonomousVmClusterId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteAutonomousVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteAutonomousVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteBackup(
DeleteBackupRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getBackupId(), "backupId must not be blank");
return clientCall(request, DeleteBackupResponse::builder)
.logger(LOG, "deleteBackup")
.serviceDetails(
"Database",
"DeleteBackup",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Backup/DeleteBackup")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteBackupRequest::builder)
.basePath("/20160918")
.appendPathParam("backups")
.appendPathParam(request.getBackupId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id", DeleteBackupResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteBackupResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteBackupDestination(
DeleteBackupDestinationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteBackupDestinationRequest, DeleteBackupDestinationResponse>
handler) {
Validate.notBlank(
request.getBackupDestinationId(), "backupDestinationId must not be blank");
return clientCall(request, DeleteBackupDestinationResponse::builder)
.logger(LOG, "deleteBackupDestination")
.serviceDetails(
"Database",
"DeleteBackupDestination",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/BackupDestination/DeleteBackupDestination")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteBackupDestinationRequest::builder)
.basePath("/20160918")
.appendPathParam("backupDestinations")
.appendPathParam(request.getBackupDestinationId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-request-id", DeleteBackupDestinationResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteCloudAutonomousVmCluster(
DeleteCloudAutonomousVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteCloudAutonomousVmClusterRequest,
DeleteCloudAutonomousVmClusterResponse>
handler) {
Validate.notBlank(
request.getCloudAutonomousVmClusterId(),
"cloudAutonomousVmClusterId must not be blank");
return clientCall(request, DeleteCloudAutonomousVmClusterResponse::builder)
.logger(LOG, "deleteCloudAutonomousVmCluster")
.serviceDetails(
"Database",
"DeleteCloudAutonomousVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudAutonomousVmCluster/DeleteCloudAutonomousVmCluster")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteCloudAutonomousVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudAutonomousVmClusters")
.appendPathParam(request.getCloudAutonomousVmClusterId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteCloudAutonomousVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteCloudAutonomousVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteCloudExadataInfrastructure(
DeleteCloudExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteCloudExadataInfrastructureRequest,
DeleteCloudExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getCloudExadataInfrastructureId(),
"cloudExadataInfrastructureId must not be blank");
return clientCall(request, DeleteCloudExadataInfrastructureResponse::builder)
.logger(LOG, "deleteCloudExadataInfrastructure")
.serviceDetails(
"Database",
"DeleteCloudExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudExadataInfrastructure/DeleteCloudExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteCloudExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudExadataInfrastructures")
.appendPathParam(request.getCloudExadataInfrastructureId())
.appendQueryParam("isDeleteVmClusters", request.getIsDeleteVmClusters())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteCloudExadataInfrastructureResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteCloudExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteCloudVmCluster(
DeleteCloudVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteCloudVmClusterRequest, DeleteCloudVmClusterResponse>
handler) {
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
return clientCall(request, DeleteCloudVmClusterResponse::builder)
.logger(LOG, "deleteCloudVmCluster")
.serviceDetails(
"Database",
"DeleteCloudVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudVmCluster/DeleteCloudVmCluster")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteCloudVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteCloudVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteCloudVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteConsoleConnection(
DeleteConsoleConnectionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteConsoleConnectionRequest, DeleteConsoleConnectionResponse>
handler) {
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
Validate.notBlank(
request.getConsoleConnectionId(), "consoleConnectionId must not be blank");
return clientCall(request, DeleteConsoleConnectionResponse::builder)
.logger(LOG, "deleteConsoleConnection")
.serviceDetails(
"Database",
"DeleteConsoleConnection",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ConsoleConnection/DeleteConsoleConnection")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteConsoleConnectionRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendPathParam("consoleConnections")
.appendPathParam(request.getConsoleConnectionId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-request-id", DeleteConsoleConnectionResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
DeleteConsoleConnectionResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteConsoleHistory(
DeleteConsoleHistoryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteConsoleHistoryRequest, DeleteConsoleHistoryResponse>
handler) {
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
Validate.notBlank(request.getConsoleHistoryId(), "consoleHistoryId must not be blank");
return clientCall(request, DeleteConsoleHistoryResponse::builder)
.logger(LOG, "deleteConsoleHistory")
.serviceDetails(
"Database",
"DeleteConsoleHistory",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ConsoleHistory/DeleteConsoleHistory")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteConsoleHistoryRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendPathParam("consoleHistories")
.appendPathParam(request.getConsoleHistoryId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteConsoleHistoryResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteConsoleHistoryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteDatabase(
DeleteDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteDatabaseRequest, DeleteDatabaseResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
return clientCall(request, DeleteDatabaseResponse::builder)
.logger(LOG, "deleteDatabase")
.serviceDetails(
"Database",
"DeleteDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Database/DeleteDatabase")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendQueryParam("performFinalBackup", request.getPerformFinalBackup())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id", DeleteDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteDatabaseSoftwareImage(
DeleteDatabaseSoftwareImageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteDatabaseSoftwareImageRequest,
DeleteDatabaseSoftwareImageResponse>
handler) {
Validate.notBlank(
request.getDatabaseSoftwareImageId(), "databaseSoftwareImageId must not be blank");
return clientCall(request, DeleteDatabaseSoftwareImageResponse::builder)
.logger(LOG, "deleteDatabaseSoftwareImage")
.serviceDetails(
"Database",
"DeleteDatabaseSoftwareImage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DatabaseSoftwareImage/DeleteDatabaseSoftwareImage")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteDatabaseSoftwareImageRequest::builder)
.basePath("/20160918")
.appendPathParam("databaseSoftwareImages")
.appendPathParam(request.getDatabaseSoftwareImageId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteDatabaseSoftwareImageResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteDatabaseSoftwareImageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteDbHome(
DeleteDbHomeRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getDbHomeId(), "dbHomeId must not be blank");
return clientCall(request, DeleteDbHomeResponse::builder)
.logger(LOG, "deleteDbHome")
.serviceDetails(
"Database",
"DeleteDbHome",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbHome/DeleteDbHome")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteDbHomeRequest::builder)
.basePath("/20160918")
.appendPathParam("dbHomes")
.appendPathParam(request.getDbHomeId())
.appendQueryParam("performFinalBackup", request.getPerformFinalBackup())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id", DeleteDbHomeResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteDbHomeResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteExadataInfrastructure(
DeleteExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExadataInfrastructureRequest,
DeleteExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
return clientCall(request, DeleteExadataInfrastructureResponse::builder)
.logger(LOG, "deleteExadataInfrastructure")
.serviceDetails(
"Database",
"DeleteExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/DeleteExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExadataInfrastructureResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteExadbVmCluster(
DeleteExadbVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExadbVmClusterRequest, DeleteExadbVmClusterResponse>
handler) {
Validate.notBlank(request.getExadbVmClusterId(), "exadbVmClusterId must not be blank");
return clientCall(request, DeleteExadbVmClusterResponse::builder)
.logger(LOG, "deleteExadbVmCluster")
.serviceDetails(
"Database",
"DeleteExadbVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadbVmCluster/DeleteExadbVmCluster")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExadbVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("exadbVmClusters")
.appendPathParam(request.getExadbVmClusterId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExadbVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteExadbVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteExascaleDbStorageVault(
DeleteExascaleDbStorageVaultRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExascaleDbStorageVaultRequest,
DeleteExascaleDbStorageVaultResponse>
handler) {
Validate.notBlank(
request.getExascaleDbStorageVaultId(),
"exascaleDbStorageVaultId must not be blank");
return clientCall(request, DeleteExascaleDbStorageVaultResponse::builder)
.logger(LOG, "deleteExascaleDbStorageVault")
.serviceDetails(
"Database",
"DeleteExascaleDbStorageVault",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExascaleDbStorageVault/DeleteExascaleDbStorageVault")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExascaleDbStorageVaultRequest::builder)
.basePath("/20160918")
.appendPathParam("exascaleDbStorageVaults")
.appendPathParam(request.getExascaleDbStorageVaultId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExascaleDbStorageVaultResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteExascaleDbStorageVaultResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteExecutionAction(
DeleteExecutionActionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExecutionActionRequest, DeleteExecutionActionResponse>
handler) {
Validate.notBlank(request.getExecutionActionId(), "executionActionId must not be blank");
return clientCall(request, DeleteExecutionActionResponse::builder)
.logger(LOG, "deleteExecutionAction")
.serviceDetails(
"Database",
"DeleteExecutionAction",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExecutionAction/DeleteExecutionAction")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExecutionActionRequest::builder)
.basePath("/20160918")
.appendPathParam("executionActions")
.appendPathParam(request.getExecutionActionId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExecutionActionResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteExecutionActionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteExecutionWindow(
DeleteExecutionWindowRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExecutionWindowRequest, DeleteExecutionWindowResponse>
handler) {
Validate.notBlank(request.getExecutionWindowId(), "executionWindowId must not be blank");
return clientCall(request, DeleteExecutionWindowResponse::builder)
.logger(LOG, "deleteExecutionWindow")
.serviceDetails(
"Database",
"DeleteExecutionWindow",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExecutionWindow/DeleteExecutionWindow")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExecutionWindowRequest::builder)
.basePath("/20160918")
.appendPathParam("executionWindows")
.appendPathParam(request.getExecutionWindowId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-request-id", DeleteExecutionWindowResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteExternalContainerDatabase(
DeleteExternalContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExternalContainerDatabaseRequest,
DeleteExternalContainerDatabaseResponse>
handler) {
Validate.notBlank(
request.getExternalContainerDatabaseId(),
"externalContainerDatabaseId must not be blank");
return clientCall(request, DeleteExternalContainerDatabaseResponse::builder)
.logger(LOG, "deleteExternalContainerDatabase")
.serviceDetails(
"Database",
"DeleteExternalContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/DeleteExternalContainerDatabase")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExternalContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.appendPathParam(request.getExternalContainerDatabaseId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExternalContainerDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteExternalContainerDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteExternalDatabaseConnector(
DeleteExternalDatabaseConnectorRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExternalDatabaseConnectorRequest,
DeleteExternalDatabaseConnectorResponse>
handler) {
Validate.notBlank(
request.getExternalDatabaseConnectorId(),
"externalDatabaseConnectorId must not be blank");
return clientCall(request, DeleteExternalDatabaseConnectorResponse::builder)
.logger(LOG, "deleteExternalDatabaseConnector")
.serviceDetails(
"Database",
"DeleteExternalDatabaseConnector",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalDatabaseConnector/DeleteExternalDatabaseConnector")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExternalDatabaseConnectorRequest::builder)
.basePath("/20160918")
.appendPathParam("externaldatabaseconnectors")
.appendPathParam(request.getExternalDatabaseConnectorId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExternalDatabaseConnectorResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteExternalDatabaseConnectorResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteExternalNonContainerDatabase(
DeleteExternalNonContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExternalNonContainerDatabaseRequest,
DeleteExternalNonContainerDatabaseResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
return clientCall(request, DeleteExternalNonContainerDatabaseResponse::builder)
.logger(LOG, "deleteExternalNonContainerDatabase")
.serviceDetails(
"Database",
"DeleteExternalNonContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/DeleteExternalNonContainerDatabase")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExternalNonContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExternalNonContainerDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteExternalNonContainerDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deleteExternalPluggableDatabase(
DeleteExternalPluggableDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteExternalPluggableDatabaseRequest,
DeleteExternalPluggableDatabaseResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
return clientCall(request, DeleteExternalPluggableDatabaseResponse::builder)
.logger(LOG, "deleteExternalPluggableDatabase")
.serviceDetails(
"Database",
"DeleteExternalPluggableDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/DeleteExternalPluggableDatabase")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteExternalPluggableDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteExternalPluggableDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeleteExternalPluggableDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteKeyStore(
DeleteKeyStoreRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteKeyStoreRequest, DeleteKeyStoreResponse>
handler) {
Validate.notBlank(request.getKeyStoreId(), "keyStoreId must not be blank");
return clientCall(request, DeleteKeyStoreResponse::builder)
.logger(LOG, "deleteKeyStore")
.serviceDetails(
"Database",
"DeleteKeyStore",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/KeyStore/DeleteKeyStore")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteKeyStoreRequest::builder)
.basePath("/20160918")
.appendPathParam("keyStores")
.appendPathParam(request.getKeyStoreId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-request-id", DeleteKeyStoreResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteOneoffPatch(
DeleteOneoffPatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteOneoffPatchRequest, DeleteOneoffPatchResponse>
handler) {
Validate.notBlank(request.getOneoffPatchId(), "oneoffPatchId must not be blank");
return clientCall(request, DeleteOneoffPatchResponse::builder)
.logger(LOG, "deleteOneoffPatch")
.serviceDetails(
"Database",
"DeleteOneoffPatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/OneoffPatch/DeleteOneoffPatch")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteOneoffPatchRequest::builder)
.basePath("/20160918")
.appendPathParam("oneoffPatches")
.appendPathParam(request.getOneoffPatchId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id", DeleteOneoffPatchResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteOneoffPatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deletePluggableDatabase(
DeletePluggableDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeletePluggableDatabaseRequest, DeletePluggableDatabaseResponse>
handler) {
Validate.notBlank(
request.getPluggableDatabaseId(), "pluggableDatabaseId must not be blank");
return clientCall(request, DeletePluggableDatabaseResponse::builder)
.logger(LOG, "deletePluggableDatabase")
.serviceDetails(
"Database",
"DeletePluggableDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PluggableDatabase/DeletePluggableDatabase")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeletePluggableDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("pluggableDatabases")
.appendPathParam(request.getPluggableDatabaseId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeletePluggableDatabaseResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeletePluggableDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteScheduledAction(
DeleteScheduledActionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteScheduledActionRequest, DeleteScheduledActionResponse>
handler) {
Validate.notBlank(request.getScheduledActionId(), "scheduledActionId must not be blank");
return clientCall(request, DeleteScheduledActionResponse::builder)
.logger(LOG, "deleteScheduledAction")
.serviceDetails(
"Database",
"DeleteScheduledAction",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ScheduledAction/DeleteScheduledAction")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteScheduledActionRequest::builder)
.basePath("/20160918")
.appendPathParam("scheduledActions")
.appendPathParam(request.getScheduledActionId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteScheduledActionResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteScheduledActionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteSchedulingPlan(
DeleteSchedulingPlanRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteSchedulingPlanRequest, DeleteSchedulingPlanResponse>
handler) {
Validate.notBlank(request.getSchedulingPlanId(), "schedulingPlanId must not be blank");
return clientCall(request, DeleteSchedulingPlanResponse::builder)
.logger(LOG, "deleteSchedulingPlan")
.serviceDetails(
"Database",
"DeleteSchedulingPlan",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPlan/DeleteSchedulingPlan")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteSchedulingPlanRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPlans")
.appendPathParam(request.getSchedulingPlanId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteSchedulingPlanResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteSchedulingPlanResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteSchedulingPolicy(
DeleteSchedulingPolicyRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteSchedulingPolicyRequest, DeleteSchedulingPolicyResponse>
handler) {
Validate.notBlank(request.getSchedulingPolicyId(), "schedulingPolicyId must not be blank");
return clientCall(request, DeleteSchedulingPolicyResponse::builder)
.logger(LOG, "deleteSchedulingPolicy")
.serviceDetails(
"Database",
"DeleteSchedulingPolicy",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPolicy/DeleteSchedulingPolicy")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteSchedulingPolicyRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPolicies")
.appendPathParam(request.getSchedulingPolicyId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-request-id", DeleteSchedulingPolicyResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteSchedulingWindow(
DeleteSchedulingWindowRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteSchedulingWindowRequest, DeleteSchedulingWindowResponse>
handler) {
Validate.notBlank(request.getSchedulingPolicyId(), "schedulingPolicyId must not be blank");
Validate.notBlank(request.getSchedulingWindowId(), "schedulingWindowId must not be blank");
return clientCall(request, DeleteSchedulingWindowResponse::builder)
.logger(LOG, "deleteSchedulingWindow")
.serviceDetails(
"Database",
"DeleteSchedulingWindow",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingWindow/DeleteSchedulingWindow")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteSchedulingWindowRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPolicies")
.appendPathParam(request.getSchedulingPolicyId())
.appendPathParam("schedulingWindows")
.appendPathParam(request.getSchedulingWindowId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-request-id", DeleteSchedulingWindowResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteVmCluster(
DeleteVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteVmClusterRequest, DeleteVmClusterResponse>
handler) {
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
return clientCall(request, DeleteVmClusterResponse::builder)
.logger(LOG, "deleteVmCluster")
.serviceDetails(
"Database",
"DeleteVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmCluster/DeleteVmCluster")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id", DeleteVmClusterResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future deleteVmClusterNetwork(
DeleteVmClusterNetworkRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeleteVmClusterNetworkRequest, DeleteVmClusterNetworkResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Validate.notBlank(request.getVmClusterNetworkId(), "vmClusterNetworkId must not be blank");
return clientCall(request, DeleteVmClusterNetworkResponse::builder)
.logger(LOG, "deleteVmClusterNetwork")
.serviceDetails(
"Database",
"DeleteVmClusterNetwork",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmClusterNetwork/DeleteVmClusterNetwork")
.method(com.oracle.bmc.http.client.Method.DELETE)
.requestBuilder(DeleteVmClusterNetworkRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("vmClusterNetworks")
.appendPathParam(request.getVmClusterNetworkId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DeleteVmClusterNetworkResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DeleteVmClusterNetworkResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
deregisterAutonomousDatabaseDataSafe(
DeregisterAutonomousDatabaseDataSafeRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DeregisterAutonomousDatabaseDataSafeRequest,
DeregisterAutonomousDatabaseDataSafeResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, DeregisterAutonomousDatabaseDataSafeResponse::builder)
.logger(LOG, "deregisterAutonomousDatabaseDataSafe")
.serviceDetails(
"Database",
"DeregisterAutonomousDatabaseDataSafe",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/DeregisterAutonomousDatabaseDataSafe")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DeregisterAutonomousDatabaseDataSafeRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("deregisterDataSafe")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
DeregisterAutonomousDatabaseDataSafeResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DeregisterAutonomousDatabaseDataSafeResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableAutonomousDatabaseManagement(
DisableAutonomousDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableAutonomousDatabaseManagementRequest,
DisableAutonomousDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, DisableAutonomousDatabaseManagementResponse::builder)
.logger(LOG, "disableAutonomousDatabaseManagement")
.serviceDetails(
"Database",
"DisableAutonomousDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/DisableAutonomousDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableAutonomousDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DisableAutonomousDatabaseManagementResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableAutonomousDatabaseManagementResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableAutonomousDatabaseOperationsInsights(
DisableAutonomousDatabaseOperationsInsightsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableAutonomousDatabaseOperationsInsightsRequest,
DisableAutonomousDatabaseOperationsInsightsResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, DisableAutonomousDatabaseOperationsInsightsResponse::builder)
.logger(LOG, "disableAutonomousDatabaseOperationsInsights")
.serviceDetails(
"Database",
"DisableAutonomousDatabaseOperationsInsights",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/DisableAutonomousDatabaseOperationsInsights")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableAutonomousDatabaseOperationsInsightsRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableOperationsInsights")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
DisableAutonomousDatabaseOperationsInsightsResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableAutonomousDatabaseOperationsInsightsResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future disableDatabaseManagement(
DisableDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableDatabaseManagementRequest, DisableDatabaseManagementResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
return clientCall(request, DisableDatabaseManagementResponse::builder)
.logger(LOG, "disableDatabaseManagement")
.serviceDetails(
"Database",
"DisableDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Database/DisableDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleBody(
com.oracle.bmc.database.model.Database.class,
DisableDatabaseManagementResponse.Builder::database)
.handleResponseHeaderString("etag", DisableDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
DisableDatabaseManagementResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", DisableDatabaseManagementResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableExternalContainerDatabaseDatabaseManagement(
DisableExternalContainerDatabaseDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalContainerDatabaseDatabaseManagementRequest,
DisableExternalContainerDatabaseDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getExternalContainerDatabaseId(),
"externalContainerDatabaseId must not be blank");
return clientCall(
request,
DisableExternalContainerDatabaseDatabaseManagementResponse::builder)
.logger(LOG, "disableExternalContainerDatabaseDatabaseManagement")
.serviceDetails(
"Database",
"DisableExternalContainerDatabaseDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/DisableExternalContainerDatabaseDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableExternalContainerDatabaseDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.appendPathParam(request.getExternalContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"etag",
DisableExternalContainerDatabaseDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalContainerDatabaseDatabaseManagementResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalContainerDatabaseDatabaseManagementResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableExternalContainerDatabaseStackMonitoring(
DisableExternalContainerDatabaseStackMonitoringRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalContainerDatabaseStackMonitoringRequest,
DisableExternalContainerDatabaseStackMonitoringResponse>
handler) {
Validate.notBlank(
request.getExternalContainerDatabaseId(),
"externalContainerDatabaseId must not be blank");
return clientCall(request, DisableExternalContainerDatabaseStackMonitoringResponse::builder)
.logger(LOG, "disableExternalContainerDatabaseStackMonitoring")
.serviceDetails(
"Database",
"DisableExternalContainerDatabaseStackMonitoring",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/DisableExternalContainerDatabaseStackMonitoring")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableExternalContainerDatabaseStackMonitoringRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.appendPathParam(request.getExternalContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableStackMonitoring")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalContainerDatabaseStackMonitoringResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalContainerDatabaseStackMonitoringResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future<
DisableExternalNonContainerDatabaseDatabaseManagementResponse>
disableExternalNonContainerDatabaseDatabaseManagement(
DisableExternalNonContainerDatabaseDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalNonContainerDatabaseDatabaseManagementRequest,
DisableExternalNonContainerDatabaseDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
return clientCall(
request,
DisableExternalNonContainerDatabaseDatabaseManagementResponse::builder)
.logger(LOG, "disableExternalNonContainerDatabaseDatabaseManagement")
.serviceDetails(
"Database",
"DisableExternalNonContainerDatabaseDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/DisableExternalNonContainerDatabaseDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(
DisableExternalNonContainerDatabaseDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"etag",
DisableExternalNonContainerDatabaseDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalNonContainerDatabaseDatabaseManagementResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalNonContainerDatabaseDatabaseManagementResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future<
DisableExternalNonContainerDatabaseOperationsInsightsResponse>
disableExternalNonContainerDatabaseOperationsInsights(
DisableExternalNonContainerDatabaseOperationsInsightsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalNonContainerDatabaseOperationsInsightsRequest,
DisableExternalNonContainerDatabaseOperationsInsightsResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
return clientCall(
request,
DisableExternalNonContainerDatabaseOperationsInsightsResponse::builder)
.logger(LOG, "disableExternalNonContainerDatabaseOperationsInsights")
.serviceDetails(
"Database",
"DisableExternalNonContainerDatabaseOperationsInsights",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/DisableExternalNonContainerDatabaseOperationsInsights")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(
DisableExternalNonContainerDatabaseOperationsInsightsRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableOperationsInsights")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"etag",
DisableExternalNonContainerDatabaseOperationsInsightsResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalNonContainerDatabaseOperationsInsightsResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalNonContainerDatabaseOperationsInsightsResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableExternalNonContainerDatabaseStackMonitoring(
DisableExternalNonContainerDatabaseStackMonitoringRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalNonContainerDatabaseStackMonitoringRequest,
DisableExternalNonContainerDatabaseStackMonitoringResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
return clientCall(
request,
DisableExternalNonContainerDatabaseStackMonitoringResponse::builder)
.logger(LOG, "disableExternalNonContainerDatabaseStackMonitoring")
.serviceDetails(
"Database",
"DisableExternalNonContainerDatabaseStackMonitoring",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/DisableExternalNonContainerDatabaseStackMonitoring")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableExternalNonContainerDatabaseStackMonitoringRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableStackMonitoring")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalNonContainerDatabaseStackMonitoringResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalNonContainerDatabaseStackMonitoringResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableExternalPluggableDatabaseDatabaseManagement(
DisableExternalPluggableDatabaseDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalPluggableDatabaseDatabaseManagementRequest,
DisableExternalPluggableDatabaseDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
return clientCall(
request,
DisableExternalPluggableDatabaseDatabaseManagementResponse::builder)
.logger(LOG, "disableExternalPluggableDatabaseDatabaseManagement")
.serviceDetails(
"Database",
"DisableExternalPluggableDatabaseDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/DisableExternalPluggableDatabaseDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableExternalPluggableDatabaseDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"etag",
DisableExternalPluggableDatabaseDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalPluggableDatabaseDatabaseManagementResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalPluggableDatabaseDatabaseManagementResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableExternalPluggableDatabaseOperationsInsights(
DisableExternalPluggableDatabaseOperationsInsightsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalPluggableDatabaseOperationsInsightsRequest,
DisableExternalPluggableDatabaseOperationsInsightsResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
return clientCall(
request,
DisableExternalPluggableDatabaseOperationsInsightsResponse::builder)
.logger(LOG, "disableExternalPluggableDatabaseOperationsInsights")
.serviceDetails(
"Database",
"DisableExternalPluggableDatabaseOperationsInsights",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/DisableExternalPluggableDatabaseOperationsInsights")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableExternalPluggableDatabaseOperationsInsightsRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableOperationsInsights")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"etag",
DisableExternalPluggableDatabaseOperationsInsightsResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalPluggableDatabaseOperationsInsightsResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalPluggableDatabaseOperationsInsightsResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disableExternalPluggableDatabaseStackMonitoring(
DisableExternalPluggableDatabaseStackMonitoringRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisableExternalPluggableDatabaseStackMonitoringRequest,
DisableExternalPluggableDatabaseStackMonitoringResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
return clientCall(request, DisableExternalPluggableDatabaseStackMonitoringResponse::builder)
.logger(LOG, "disableExternalPluggableDatabaseStackMonitoring")
.serviceDetails(
"Database",
"DisableExternalPluggableDatabaseStackMonitoring",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/DisableExternalPluggableDatabaseStackMonitoring")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisableExternalPluggableDatabaseStackMonitoringRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("disableStackMonitoring")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleResponseHeaderString(
"opc-work-request-id",
DisableExternalPluggableDatabaseStackMonitoringResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisableExternalPluggableDatabaseStackMonitoringResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
disablePluggableDatabaseManagement(
DisablePluggableDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DisablePluggableDatabaseManagementRequest,
DisablePluggableDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getPluggableDatabaseId(), "pluggableDatabaseId must not be blank");
return clientCall(request, DisablePluggableDatabaseManagementResponse::builder)
.logger(LOG, "disablePluggableDatabaseManagement")
.serviceDetails(
"Database",
"DisablePluggableDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PluggableDatabase/DisablePluggableDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DisablePluggableDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("pluggableDatabases")
.appendPathParam(request.getPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("disablePluggableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleBody(
com.oracle.bmc.database.model.PluggableDatabase.class,
DisablePluggableDatabaseManagementResponse.Builder::pluggableDatabase)
.handleResponseHeaderString(
"etag", DisablePluggableDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
DisablePluggableDatabaseManagementResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
DisablePluggableDatabaseManagementResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
downloadExadataInfrastructureConfigFile(
DownloadExadataInfrastructureConfigFileRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DownloadExadataInfrastructureConfigFileRequest,
DownloadExadataInfrastructureConfigFileResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
return clientCall(request, DownloadExadataInfrastructureConfigFileResponse::builder)
.logger(LOG, "downloadExadataInfrastructureConfigFile")
.serviceDetails(
"Database",
"DownloadExadataInfrastructureConfigFile",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/DownloadExadataInfrastructureConfigFile")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DownloadExadataInfrastructureConfigFileRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("actions")
.appendPathParam("downloadConfigFile")
.accept("application/octet-stream")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.handleBody(
java.io.InputStream.class,
DownloadExadataInfrastructureConfigFileResponse.Builder::inputStream)
.handleResponseHeaderString(
"etag", DownloadExadataInfrastructureConfigFileResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
DownloadExadataInfrastructureConfigFileResponse.Builder::opcRequestId)
.handleResponseHeaderLong(
"content-length",
DownloadExadataInfrastructureConfigFileResponse.Builder::contentLength)
.handleResponseHeaderDate(
"last-modified",
DownloadExadataInfrastructureConfigFileResponse.Builder::lastModified)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future downloadOneoffPatch(
DownloadOneoffPatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DownloadOneoffPatchRequest, DownloadOneoffPatchResponse>
handler) {
Validate.notBlank(request.getOneoffPatchId(), "oneoffPatchId must not be blank");
return clientCall(request, DownloadOneoffPatchResponse::builder)
.logger(LOG, "downloadOneoffPatch")
.serviceDetails(
"Database",
"DownloadOneoffPatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/OneoffPatch/DownloadOneoffPatch")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DownloadOneoffPatchRequest::builder)
.basePath("/20160918")
.appendPathParam("oneoffPatches")
.appendPathParam(request.getOneoffPatchId())
.appendPathParam("actions")
.appendPathParam("downloadOneoffPatch")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.handleBody(
com.oracle.bmc.database.model.DownloadOneoffPatch.class,
DownloadOneoffPatchResponse.Builder::downloadOneoffPatch)
.handleResponseHeaderString("etag", DownloadOneoffPatchResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", DownloadOneoffPatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future downloadValidationReport(
DownloadValidationReportRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DownloadValidationReportRequest, DownloadValidationReportResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Validate.notBlank(request.getVmClusterNetworkId(), "vmClusterNetworkId must not be blank");
return clientCall(request, DownloadValidationReportResponse::builder)
.logger(LOG, "downloadValidationReport")
.serviceDetails(
"Database",
"DownloadValidationReport",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmClusterNetwork/DownloadValidationReport")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DownloadValidationReportRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("vmClusterNetworks")
.appendPathParam(request.getVmClusterNetworkId())
.appendPathParam("actions")
.appendPathParam("downloadValidationReport")
.accept("application/octet-stream")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.handleBody(
java.io.InputStream.class,
DownloadValidationReportResponse.Builder::inputStream)
.handleResponseHeaderString("etag", DownloadValidationReportResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", DownloadValidationReportResponse.Builder::opcRequestId)
.handleResponseHeaderLong(
"content-length", DownloadValidationReportResponse.Builder::contentLength)
.handleResponseHeaderDate(
"last-modified", DownloadValidationReportResponse.Builder::lastModified)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
downloadVmClusterNetworkConfigFile(
DownloadVmClusterNetworkConfigFileRequest request,
final com.oracle.bmc.responses.AsyncHandler<
DownloadVmClusterNetworkConfigFileRequest,
DownloadVmClusterNetworkConfigFileResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Validate.notBlank(request.getVmClusterNetworkId(), "vmClusterNetworkId must not be blank");
return clientCall(request, DownloadVmClusterNetworkConfigFileResponse::builder)
.logger(LOG, "downloadVmClusterNetworkConfigFile")
.serviceDetails(
"Database",
"DownloadVmClusterNetworkConfigFile",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmClusterNetwork/DownloadVmClusterNetworkConfigFile")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(DownloadVmClusterNetworkConfigFileRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("vmClusterNetworks")
.appendPathParam(request.getVmClusterNetworkId())
.appendPathParam("actions")
.appendPathParam("downloadConfigFile")
.accept("application/octet-stream")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.handleBody(
java.io.InputStream.class,
DownloadVmClusterNetworkConfigFileResponse.Builder::inputStream)
.handleResponseHeaderString(
"etag", DownloadVmClusterNetworkConfigFileResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
DownloadVmClusterNetworkConfigFileResponse.Builder::opcRequestId)
.handleResponseHeaderLong(
"content-length",
DownloadVmClusterNetworkConfigFileResponse.Builder::contentLength)
.handleResponseHeaderDate(
"last-modified",
DownloadVmClusterNetworkConfigFileResponse.Builder::lastModified)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableAutonomousDatabaseManagement(
EnableAutonomousDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableAutonomousDatabaseManagementRequest,
EnableAutonomousDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, EnableAutonomousDatabaseManagementResponse::builder)
.logger(LOG, "enableAutonomousDatabaseManagement")
.serviceDetails(
"Database",
"EnableAutonomousDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/EnableAutonomousDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableAutonomousDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
EnableAutonomousDatabaseManagementResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableAutonomousDatabaseManagementResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableAutonomousDatabaseOperationsInsights(
EnableAutonomousDatabaseOperationsInsightsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableAutonomousDatabaseOperationsInsightsRequest,
EnableAutonomousDatabaseOperationsInsightsResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, EnableAutonomousDatabaseOperationsInsightsResponse::builder)
.logger(LOG, "enableAutonomousDatabaseOperationsInsights")
.serviceDetails(
"Database",
"EnableAutonomousDatabaseOperationsInsights",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/EnableAutonomousDatabaseOperationsInsights")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableAutonomousDatabaseOperationsInsightsRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableOperationsInsights")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleResponseHeaderString(
"opc-work-request-id",
EnableAutonomousDatabaseOperationsInsightsResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableAutonomousDatabaseOperationsInsightsResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future enableDatabaseManagement(
EnableDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableDatabaseManagementRequest, EnableDatabaseManagementResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Objects.requireNonNull(
request.getEnableDatabaseManagementDetails(),
"enableDatabaseManagementDetails is required");
return clientCall(request, EnableDatabaseManagementResponse::builder)
.logger(LOG, "enableDatabaseManagement")
.serviceDetails(
"Database",
"EnableDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Database/EnableDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.Database.class,
EnableDatabaseManagementResponse.Builder::database)
.handleResponseHeaderString("etag", EnableDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
EnableDatabaseManagementResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id", EnableDatabaseManagementResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalContainerDatabaseDatabaseManagement(
EnableExternalContainerDatabaseDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalContainerDatabaseDatabaseManagementRequest,
EnableExternalContainerDatabaseDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getExternalContainerDatabaseId(),
"externalContainerDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalContainerDatabaseDatabaseManagementDetails(),
"enableExternalContainerDatabaseDatabaseManagementDetails is required");
return clientCall(
request, EnableExternalContainerDatabaseDatabaseManagementResponse::builder)
.logger(LOG, "enableExternalContainerDatabaseDatabaseManagement")
.serviceDetails(
"Database",
"EnableExternalContainerDatabaseDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/EnableExternalContainerDatabaseDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableExternalContainerDatabaseDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.appendPathParam(request.getExternalContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag",
EnableExternalContainerDatabaseDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalContainerDatabaseDatabaseManagementResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalContainerDatabaseDatabaseManagementResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalContainerDatabaseStackMonitoring(
EnableExternalContainerDatabaseStackMonitoringRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalContainerDatabaseStackMonitoringRequest,
EnableExternalContainerDatabaseStackMonitoringResponse>
handler) {
Validate.notBlank(
request.getExternalContainerDatabaseId(),
"externalContainerDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalContainerDatabaseStackMonitoringDetails(),
"enableExternalContainerDatabaseStackMonitoringDetails is required");
return clientCall(request, EnableExternalContainerDatabaseStackMonitoringResponse::builder)
.logger(LOG, "enableExternalContainerDatabaseStackMonitoring")
.serviceDetails(
"Database",
"EnableExternalContainerDatabaseStackMonitoring",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/EnableExternalContainerDatabaseStackMonitoring")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableExternalContainerDatabaseStackMonitoringRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.appendPathParam(request.getExternalContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableStackMonitoring")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalContainerDatabaseStackMonitoringResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalContainerDatabaseStackMonitoringResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalNonContainerDatabaseDatabaseManagement(
EnableExternalNonContainerDatabaseDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalNonContainerDatabaseDatabaseManagementRequest,
EnableExternalNonContainerDatabaseDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalNonContainerDatabaseDatabaseManagementDetails(),
"enableExternalNonContainerDatabaseDatabaseManagementDetails is required");
return clientCall(
request,
EnableExternalNonContainerDatabaseDatabaseManagementResponse::builder)
.logger(LOG, "enableExternalNonContainerDatabaseDatabaseManagement")
.serviceDetails(
"Database",
"EnableExternalNonContainerDatabaseDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/EnableExternalNonContainerDatabaseDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(
EnableExternalNonContainerDatabaseDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag",
EnableExternalNonContainerDatabaseDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalNonContainerDatabaseDatabaseManagementResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalNonContainerDatabaseDatabaseManagementResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalNonContainerDatabaseOperationsInsights(
EnableExternalNonContainerDatabaseOperationsInsightsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalNonContainerDatabaseOperationsInsightsRequest,
EnableExternalNonContainerDatabaseOperationsInsightsResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalNonContainerDatabaseOperationsInsightsDetails(),
"enableExternalNonContainerDatabaseOperationsInsightsDetails is required");
return clientCall(
request,
EnableExternalNonContainerDatabaseOperationsInsightsResponse::builder)
.logger(LOG, "enableExternalNonContainerDatabaseOperationsInsights")
.serviceDetails(
"Database",
"EnableExternalNonContainerDatabaseOperationsInsights",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/EnableExternalNonContainerDatabaseOperationsInsights")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(
EnableExternalNonContainerDatabaseOperationsInsightsRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableOperationsInsights")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag",
EnableExternalNonContainerDatabaseOperationsInsightsResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalNonContainerDatabaseOperationsInsightsResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalNonContainerDatabaseOperationsInsightsResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalNonContainerDatabaseStackMonitoring(
EnableExternalNonContainerDatabaseStackMonitoringRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalNonContainerDatabaseStackMonitoringRequest,
EnableExternalNonContainerDatabaseStackMonitoringResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalNonContainerDatabaseStackMonitoringDetails(),
"enableExternalNonContainerDatabaseStackMonitoringDetails is required");
return clientCall(
request, EnableExternalNonContainerDatabaseStackMonitoringResponse::builder)
.logger(LOG, "enableExternalNonContainerDatabaseStackMonitoring")
.serviceDetails(
"Database",
"EnableExternalNonContainerDatabaseStackMonitoring",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/EnableExternalNonContainerDatabaseStackMonitoring")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableExternalNonContainerDatabaseStackMonitoringRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableStackMonitoring")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalNonContainerDatabaseStackMonitoringResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalNonContainerDatabaseStackMonitoringResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalPluggableDatabaseDatabaseManagement(
EnableExternalPluggableDatabaseDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalPluggableDatabaseDatabaseManagementRequest,
EnableExternalPluggableDatabaseDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalPluggableDatabaseDatabaseManagementDetails(),
"enableExternalPluggableDatabaseDatabaseManagementDetails is required");
return clientCall(
request, EnableExternalPluggableDatabaseDatabaseManagementResponse::builder)
.logger(LOG, "enableExternalPluggableDatabaseDatabaseManagement")
.serviceDetails(
"Database",
"EnableExternalPluggableDatabaseDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/EnableExternalPluggableDatabaseDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableExternalPluggableDatabaseDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag",
EnableExternalPluggableDatabaseDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalPluggableDatabaseDatabaseManagementResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalPluggableDatabaseDatabaseManagementResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalPluggableDatabaseOperationsInsights(
EnableExternalPluggableDatabaseOperationsInsightsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalPluggableDatabaseOperationsInsightsRequest,
EnableExternalPluggableDatabaseOperationsInsightsResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalPluggableDatabaseOperationsInsightsDetails(),
"enableExternalPluggableDatabaseOperationsInsightsDetails is required");
return clientCall(
request, EnableExternalPluggableDatabaseOperationsInsightsResponse::builder)
.logger(LOG, "enableExternalPluggableDatabaseOperationsInsights")
.serviceDetails(
"Database",
"EnableExternalPluggableDatabaseOperationsInsights",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/EnableExternalPluggableDatabaseOperationsInsights")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableExternalPluggableDatabaseOperationsInsightsRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableOperationsInsights")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"etag",
EnableExternalPluggableDatabaseOperationsInsightsResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalPluggableDatabaseOperationsInsightsResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalPluggableDatabaseOperationsInsightsResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enableExternalPluggableDatabaseStackMonitoring(
EnableExternalPluggableDatabaseStackMonitoringRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnableExternalPluggableDatabaseStackMonitoringRequest,
EnableExternalPluggableDatabaseStackMonitoringResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnableExternalPluggableDatabaseStackMonitoringDetails(),
"enableExternalPluggableDatabaseStackMonitoringDetails is required");
return clientCall(request, EnableExternalPluggableDatabaseStackMonitoringResponse::builder)
.logger(LOG, "enableExternalPluggableDatabaseStackMonitoring")
.serviceDetails(
"Database",
"EnableExternalPluggableDatabaseStackMonitoring",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/EnableExternalPluggableDatabaseStackMonitoring")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnableExternalPluggableDatabaseStackMonitoringRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("enableStackMonitoring")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleResponseHeaderString(
"opc-work-request-id",
EnableExternalPluggableDatabaseStackMonitoringResponse.Builder
::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnableExternalPluggableDatabaseStackMonitoringResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
enablePluggableDatabaseManagement(
EnablePluggableDatabaseManagementRequest request,
final com.oracle.bmc.responses.AsyncHandler<
EnablePluggableDatabaseManagementRequest,
EnablePluggableDatabaseManagementResponse>
handler) {
Validate.notBlank(
request.getPluggableDatabaseId(), "pluggableDatabaseId must not be blank");
Objects.requireNonNull(
request.getEnablePluggableDatabaseManagementDetails(),
"enablePluggableDatabaseManagementDetails is required");
return clientCall(request, EnablePluggableDatabaseManagementResponse::builder)
.logger(LOG, "enablePluggableDatabaseManagement")
.serviceDetails(
"Database",
"EnablePluggableDatabaseManagement",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PluggableDatabase/EnablePluggableDatabaseManagement")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(EnablePluggableDatabaseManagementRequest::builder)
.basePath("/20160918")
.appendPathParam("pluggableDatabases")
.appendPathParam(request.getPluggableDatabaseId())
.appendPathParam("actions")
.appendPathParam("enablePluggableDatabaseManagement")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.PluggableDatabase.class,
EnablePluggableDatabaseManagementResponse.Builder::pluggableDatabase)
.handleResponseHeaderString(
"etag", EnablePluggableDatabaseManagementResponse.Builder::etag)
.handleResponseHeaderString(
"opc-work-request-id",
EnablePluggableDatabaseManagementResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"opc-request-id",
EnablePluggableDatabaseManagementResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
failOverAutonomousDatabase(
FailOverAutonomousDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
FailOverAutonomousDatabaseRequest,
FailOverAutonomousDatabaseResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, FailOverAutonomousDatabaseResponse::builder)
.logger(LOG, "failOverAutonomousDatabase")
.serviceDetails(
"Database",
"FailOverAutonomousDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/FailOverAutonomousDatabase")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(FailOverAutonomousDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("failover")
.appendQueryParam("peerDbId", request.getPeerDbId())
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabase.class,
FailOverAutonomousDatabaseResponse.Builder::autonomousDatabase)
.handleResponseHeaderString(
"etag", FailOverAutonomousDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", FailOverAutonomousDatabaseResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
FailOverAutonomousDatabaseResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future<
FailoverAutonomousContainerDatabaseDataguardAssociationResponse>
failoverAutonomousContainerDatabaseDataguardAssociation(
FailoverAutonomousContainerDatabaseDataguardAssociationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
FailoverAutonomousContainerDatabaseDataguardAssociationRequest,
FailoverAutonomousContainerDatabaseDataguardAssociationResponse>
handler) {
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
Validate.notBlank(
request.getAutonomousContainerDatabaseDataguardAssociationId(),
"autonomousContainerDatabaseDataguardAssociationId must not be blank");
return clientCall(
request,
FailoverAutonomousContainerDatabaseDataguardAssociationResponse::builder)
.logger(LOG, "failoverAutonomousContainerDatabaseDataguardAssociation")
.serviceDetails(
"Database",
"FailoverAutonomousContainerDatabaseDataguardAssociation",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabaseDataguardAssociation/FailoverAutonomousContainerDatabaseDataguardAssociation")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(
FailoverAutonomousContainerDatabaseDataguardAssociationRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.appendPathParam("autonomousContainerDatabaseDataguardAssociations")
.appendPathParam(request.getAutonomousContainerDatabaseDataguardAssociationId())
.appendPathParam("actions")
.appendPathParam("failover")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.handleBody(
com.oracle.bmc.database.model
.AutonomousContainerDatabaseDataguardAssociation.class,
FailoverAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::autonomousContainerDatabaseDataguardAssociation)
.handleResponseHeaderString(
"etag",
FailoverAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::etag)
.handleResponseHeaderString(
"opc-request-id",
FailoverAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
FailoverAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
failoverDataGuardAssociation(
FailoverDataGuardAssociationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
FailoverDataGuardAssociationRequest,
FailoverDataGuardAssociationResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Validate.notBlank(
request.getDataGuardAssociationId(), "dataGuardAssociationId must not be blank");
Objects.requireNonNull(
request.getFailoverDataGuardAssociationDetails(),
"failoverDataGuardAssociationDetails is required");
return clientCall(request, FailoverDataGuardAssociationResponse::builder)
.logger(LOG, "failoverDataGuardAssociation")
.serviceDetails(
"Database",
"FailoverDataGuardAssociation",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DataGuardAssociation/FailoverDataGuardAssociation")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(FailoverDataGuardAssociationRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("dataGuardAssociations")
.appendPathParam(request.getDataGuardAssociationId())
.appendPathParam("actions")
.appendPathParam("failover")
.accept("application/json")
.appendHeader("if-match", request.getIfMatch())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.DataGuardAssociation.class,
FailoverDataGuardAssociationResponse.Builder::dataGuardAssociation)
.handleResponseHeaderString(
"opc-work-request-id",
FailoverDataGuardAssociationResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString(
"etag", FailoverDataGuardAssociationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
FailoverDataGuardAssociationResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
generateAutonomousDatabaseWallet(
GenerateAutonomousDatabaseWalletRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GenerateAutonomousDatabaseWalletRequest,
GenerateAutonomousDatabaseWalletResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
Objects.requireNonNull(
request.getGenerateAutonomousDatabaseWalletDetails(),
"generateAutonomousDatabaseWalletDetails is required");
return clientCall(request, GenerateAutonomousDatabaseWalletResponse::builder)
.logger(LOG, "generateAutonomousDatabaseWallet")
.serviceDetails(
"Database",
"GenerateAutonomousDatabaseWallet",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/GenerateAutonomousDatabaseWallet")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(GenerateAutonomousDatabaseWalletRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("actions")
.appendPathParam("generateWallet")
.accept("application/octet-stream")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
java.io.InputStream.class,
GenerateAutonomousDatabaseWalletResponse.Builder::inputStream)
.handleResponseHeaderString(
"etag", GenerateAutonomousDatabaseWalletResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GenerateAutonomousDatabaseWalletResponse.Builder::opcRequestId)
.handleResponseHeaderLong(
"content-length",
GenerateAutonomousDatabaseWalletResponse.Builder::contentLength)
.handleResponseHeaderDate(
"last-modified",
GenerateAutonomousDatabaseWalletResponse.Builder::lastModified)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
generateRecommendedVmClusterNetwork(
GenerateRecommendedVmClusterNetworkRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GenerateRecommendedVmClusterNetworkRequest,
GenerateRecommendedVmClusterNetworkResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Objects.requireNonNull(
request.getGenerateRecommendedNetworkDetails(),
"generateRecommendedNetworkDetails is required");
return clientCall(request, GenerateRecommendedVmClusterNetworkResponse::builder)
.logger(LOG, "generateRecommendedVmClusterNetwork")
.serviceDetails(
"Database",
"GenerateRecommendedVmClusterNetwork",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/GenerateRecommendedVmClusterNetwork")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(GenerateRecommendedVmClusterNetworkRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("vmClusterNetworks")
.appendPathParam("actions")
.appendPathParam("generateRecommendedNetwork")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.VmClusterNetworkDetails.class,
GenerateRecommendedVmClusterNetworkResponse.Builder
::vmClusterNetworkDetails)
.handleResponseHeaderString(
"etag", GenerateRecommendedVmClusterNetworkResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GenerateRecommendedVmClusterNetworkResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getApplicationVip(
GetApplicationVipRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetApplicationVipRequest, GetApplicationVipResponse>
handler) {
Validate.notBlank(request.getApplicationVipId(), "applicationVipId must not be blank");
return clientCall(request, GetApplicationVipResponse::builder)
.logger(LOG, "getApplicationVip")
.serviceDetails(
"Database",
"GetApplicationVip",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ApplicationVip/GetApplicationVip")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetApplicationVipRequest::builder)
.basePath("/20160918")
.appendPathParam("applicationVip")
.appendPathParam(request.getApplicationVipId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ApplicationVip.class,
GetApplicationVipResponse.Builder::applicationVip)
.handleResponseHeaderString("etag", GetApplicationVipResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetApplicationVipResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousContainerDatabase(
GetAutonomousContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousContainerDatabaseRequest,
GetAutonomousContainerDatabaseResponse>
handler) {
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
return clientCall(request, GetAutonomousContainerDatabaseResponse::builder)
.logger(LOG, "getAutonomousContainerDatabase")
.serviceDetails(
"Database",
"GetAutonomousContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabase/GetAutonomousContainerDatabase")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.AutonomousContainerDatabase.class,
GetAutonomousContainerDatabaseResponse.Builder::autonomousContainerDatabase)
.handleResponseHeaderString(
"etag", GetAutonomousContainerDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousContainerDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousContainerDatabaseDataguardAssociation(
GetAutonomousContainerDatabaseDataguardAssociationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousContainerDatabaseDataguardAssociationRequest,
GetAutonomousContainerDatabaseDataguardAssociationResponse>
handler) {
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
Validate.notBlank(
request.getAutonomousContainerDatabaseDataguardAssociationId(),
"autonomousContainerDatabaseDataguardAssociationId must not be blank");
return clientCall(
request,
GetAutonomousContainerDatabaseDataguardAssociationResponse::builder)
.logger(LOG, "getAutonomousContainerDatabaseDataguardAssociation")
.serviceDetails(
"Database",
"GetAutonomousContainerDatabaseDataguardAssociation",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabaseDataguardAssociation/GetAutonomousContainerDatabaseDataguardAssociation")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousContainerDatabaseDataguardAssociationRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.appendPathParam("autonomousContainerDatabaseDataguardAssociations")
.appendPathParam(request.getAutonomousContainerDatabaseDataguardAssociationId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model
.AutonomousContainerDatabaseDataguardAssociation.class,
GetAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::autonomousContainerDatabaseDataguardAssociation)
.handleResponseHeaderString(
"etag",
GetAutonomousContainerDatabaseDataguardAssociationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousContainerDatabaseDataguardAssociationResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousContainerDatabaseResourceUsage(
GetAutonomousContainerDatabaseResourceUsageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousContainerDatabaseResourceUsageRequest,
GetAutonomousContainerDatabaseResourceUsageResponse>
handler) {
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
return clientCall(request, GetAutonomousContainerDatabaseResourceUsageResponse::builder)
.logger(LOG, "getAutonomousContainerDatabaseResourceUsage")
.serviceDetails(
"Database",
"GetAutonomousContainerDatabaseResourceUsage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabase/GetAutonomousContainerDatabaseResourceUsage")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousContainerDatabaseResourceUsageRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.appendPathParam("resourceUsage")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousContainerDatabaseResourceUsage
.class,
GetAutonomousContainerDatabaseResourceUsageResponse.Builder
::autonomousContainerDatabaseResourceUsage)
.handleResponseHeaderString(
"etag", GetAutonomousContainerDatabaseResourceUsageResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousContainerDatabaseResourceUsageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getAutonomousDatabase(
GetAutonomousDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousDatabaseRequest, GetAutonomousDatabaseResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, GetAutonomousDatabaseResponse::builder)
.logger(LOG, "getAutonomousDatabase")
.serviceDetails(
"Database",
"GetAutonomousDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/GetAutonomousDatabase")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabase.class,
GetAutonomousDatabaseResponse.Builder::autonomousDatabase)
.handleResponseHeaderString("etag", GetAutonomousDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetAutonomousDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousDatabaseBackup(
GetAutonomousDatabaseBackupRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousDatabaseBackupRequest,
GetAutonomousDatabaseBackupResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseBackupId(),
"autonomousDatabaseBackupId must not be blank");
return clientCall(request, GetAutonomousDatabaseBackupResponse::builder)
.logger(LOG, "getAutonomousDatabaseBackup")
.serviceDetails(
"Database",
"GetAutonomousDatabaseBackup",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseBackup/GetAutonomousDatabaseBackup")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousDatabaseBackupRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseBackups")
.appendPathParam(request.getAutonomousDatabaseBackupId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseBackup.class,
GetAutonomousDatabaseBackupResponse.Builder::autonomousDatabaseBackup)
.handleResponseHeaderString(
"etag", GetAutonomousDatabaseBackupResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetAutonomousDatabaseBackupResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousDatabaseDataguardAssociation(
GetAutonomousDatabaseDataguardAssociationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousDatabaseDataguardAssociationRequest,
GetAutonomousDatabaseDataguardAssociationResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
Validate.notBlank(
request.getAutonomousDatabaseDataguardAssociationId(),
"autonomousDatabaseDataguardAssociationId must not be blank");
return clientCall(request, GetAutonomousDatabaseDataguardAssociationResponse::builder)
.logger(LOG, "getAutonomousDatabaseDataguardAssociation")
.serviceDetails(
"Database",
"GetAutonomousDatabaseDataguardAssociation",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseDataguardAssociation/GetAutonomousDatabaseDataguardAssociation")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousDatabaseDataguardAssociationRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("autonomousDatabaseDataguardAssociations")
.appendPathParam(request.getAutonomousDatabaseDataguardAssociationId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseDataguardAssociation.class,
GetAutonomousDatabaseDataguardAssociationResponse.Builder
::autonomousDatabaseDataguardAssociation)
.handleResponseHeaderString(
"etag", GetAutonomousDatabaseDataguardAssociationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousDatabaseDataguardAssociationResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousDatabaseRegionalWallet(
GetAutonomousDatabaseRegionalWalletRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousDatabaseRegionalWalletRequest,
GetAutonomousDatabaseRegionalWalletResponse>
handler) {
return clientCall(request, GetAutonomousDatabaseRegionalWalletResponse::builder)
.logger(LOG, "getAutonomousDatabaseRegionalWallet")
.serviceDetails(
"Database",
"GetAutonomousDatabaseRegionalWallet",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseWallet/GetAutonomousDatabaseRegionalWallet")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousDatabaseRegionalWalletRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam("wallet")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseWallet.class,
GetAutonomousDatabaseRegionalWalletResponse.Builder
::autonomousDatabaseWallet)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousDatabaseRegionalWalletResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousDatabaseSoftwareImage(
GetAutonomousDatabaseSoftwareImageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousDatabaseSoftwareImageRequest,
GetAutonomousDatabaseSoftwareImageResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseSoftwareImageId(),
"autonomousDatabaseSoftwareImageId must not be blank");
return clientCall(request, GetAutonomousDatabaseSoftwareImageResponse::builder)
.logger(LOG, "getAutonomousDatabaseSoftwareImage")
.serviceDetails(
"Database",
"GetAutonomousDatabaseSoftwareImage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseSoftwareImage/GetAutonomousDatabaseSoftwareImage")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousDatabaseSoftwareImageRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseSoftwareImages")
.appendPathParam(request.getAutonomousDatabaseSoftwareImageId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseSoftwareImage.class,
GetAutonomousDatabaseSoftwareImageResponse.Builder
::autonomousDatabaseSoftwareImage)
.handleResponseHeaderString(
"etag", GetAutonomousDatabaseSoftwareImageResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousDatabaseSoftwareImageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousDatabaseWallet(
GetAutonomousDatabaseWalletRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousDatabaseWalletRequest,
GetAutonomousDatabaseWalletResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, GetAutonomousDatabaseWalletResponse::builder)
.logger(LOG, "getAutonomousDatabaseWallet")
.serviceDetails(
"Database",
"GetAutonomousDatabaseWallet",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseWallet/GetAutonomousDatabaseWallet")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousDatabaseWalletRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("wallet")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseWallet.class,
GetAutonomousDatabaseWalletResponse.Builder::autonomousDatabaseWallet)
.handleResponseHeaderString(
"opc-request-id", GetAutonomousDatabaseWalletResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousExadataInfrastructure(
GetAutonomousExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousExadataInfrastructureRequest,
GetAutonomousExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getAutonomousExadataInfrastructureId(),
"autonomousExadataInfrastructureId must not be blank");
return clientCall(request, GetAutonomousExadataInfrastructureResponse::builder)
.logger(LOG, "getAutonomousExadataInfrastructure")
.serviceDetails(
"Database",
"GetAutonomousExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousExadataInfrastructure/GetAutonomousExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousExadataInfrastructures")
.appendPathParam(request.getAutonomousExadataInfrastructureId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.AutonomousExadataInfrastructure.class,
GetAutonomousExadataInfrastructureResponse.Builder
::autonomousExadataInfrastructure)
.handleResponseHeaderString(
"etag", GetAutonomousExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getAutonomousPatch(
GetAutonomousPatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousPatchRequest, GetAutonomousPatchResponse>
handler) {
Validate.notBlank(request.getAutonomousPatchId(), "autonomousPatchId must not be blank");
return clientCall(request, GetAutonomousPatchResponse::builder)
.logger(LOG, "getAutonomousPatch")
.serviceDetails(
"Database",
"GetAutonomousPatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousPatch/GetAutonomousPatch")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousPatchRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousPatches")
.appendPathParam(request.getAutonomousPatchId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.AutonomousPatch.class,
GetAutonomousPatchResponse.Builder::autonomousPatch)
.handleResponseHeaderString("etag", GetAutonomousPatchResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetAutonomousPatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousVirtualMachine(
GetAutonomousVirtualMachineRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousVirtualMachineRequest,
GetAutonomousVirtualMachineResponse>
handler) {
Validate.notBlank(
request.getAutonomousVirtualMachineId(),
"autonomousVirtualMachineId must not be blank");
return clientCall(request, GetAutonomousVirtualMachineResponse::builder)
.logger(LOG, "getAutonomousVirtualMachine")
.serviceDetails(
"Database",
"GetAutonomousVirtualMachine",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousVirtualMachine/GetAutonomousVirtualMachine")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousVirtualMachineRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousVirtualMachines")
.appendPathParam(request.getAutonomousVirtualMachineId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousVirtualMachine.class,
GetAutonomousVirtualMachineResponse.Builder::autonomousVirtualMachine)
.handleResponseHeaderString(
"etag", GetAutonomousVirtualMachineResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetAutonomousVirtualMachineResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getAutonomousVmCluster(
GetAutonomousVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousVmClusterRequest, GetAutonomousVmClusterResponse>
handler) {
Validate.notBlank(
request.getAutonomousVmClusterId(), "autonomousVmClusterId must not be blank");
return clientCall(request, GetAutonomousVmClusterResponse::builder)
.logger(LOG, "getAutonomousVmCluster")
.serviceDetails(
"Database",
"GetAutonomousVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousVmCluster/GetAutonomousVmCluster")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousVmClusters")
.appendPathParam(request.getAutonomousVmClusterId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousVmCluster.class,
GetAutonomousVmClusterResponse.Builder::autonomousVmCluster)
.handleResponseHeaderString("etag", GetAutonomousVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetAutonomousVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getAutonomousVmClusterResourceUsage(
GetAutonomousVmClusterResourceUsageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetAutonomousVmClusterResourceUsageRequest,
GetAutonomousVmClusterResourceUsageResponse>
handler) {
Validate.notBlank(
request.getAutonomousVmClusterId(), "autonomousVmClusterId must not be blank");
return clientCall(request, GetAutonomousVmClusterResourceUsageResponse::builder)
.logger(LOG, "getAutonomousVmClusterResourceUsage")
.serviceDetails(
"Database",
"GetAutonomousVmClusterResourceUsage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousVmCluster/GetAutonomousVmClusterResourceUsage")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetAutonomousVmClusterResourceUsageRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousVmClusters")
.appendPathParam(request.getAutonomousVmClusterId())
.appendPathParam("resourceUsage")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousVmClusterResourceUsage.class,
GetAutonomousVmClusterResourceUsageResponse.Builder
::autonomousVmClusterResourceUsage)
.handleResponseHeaderString(
"etag", GetAutonomousVmClusterResourceUsageResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetAutonomousVmClusterResourceUsageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getBackup(
GetBackupRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getBackupId(), "backupId must not be blank");
return clientCall(request, GetBackupResponse::builder)
.logger(LOG, "getBackup")
.serviceDetails(
"Database",
"GetBackup",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Backup/GetBackup")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetBackupRequest::builder)
.basePath("/20160918")
.appendPathParam("backups")
.appendPathParam(request.getBackupId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.Backup.class,
GetBackupResponse.Builder::backup)
.handleResponseHeaderString("etag", GetBackupResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetBackupResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getBackupDestination(
GetBackupDestinationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetBackupDestinationRequest, GetBackupDestinationResponse>
handler) {
Validate.notBlank(
request.getBackupDestinationId(), "backupDestinationId must not be blank");
return clientCall(request, GetBackupDestinationResponse::builder)
.logger(LOG, "getBackupDestination")
.serviceDetails(
"Database",
"GetBackupDestination",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/BackupDestination/GetBackupDestination")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetBackupDestinationRequest::builder)
.basePath("/20160918")
.appendPathParam("backupDestinations")
.appendPathParam(request.getBackupDestinationId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.BackupDestination.class,
GetBackupDestinationResponse.Builder::backupDestination)
.handleResponseHeaderString("etag", GetBackupDestinationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetBackupDestinationResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getCloudAutonomousVmCluster(
GetCloudAutonomousVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudAutonomousVmClusterRequest,
GetCloudAutonomousVmClusterResponse>
handler) {
Validate.notBlank(
request.getCloudAutonomousVmClusterId(),
"cloudAutonomousVmClusterId must not be blank");
return clientCall(request, GetCloudAutonomousVmClusterResponse::builder)
.logger(LOG, "getCloudAutonomousVmCluster")
.serviceDetails(
"Database",
"GetCloudAutonomousVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudAutonomousVmCluster/GetCloudAutonomousVmCluster")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudAutonomousVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudAutonomousVmClusters")
.appendPathParam(request.getCloudAutonomousVmClusterId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.CloudAutonomousVmCluster.class,
GetCloudAutonomousVmClusterResponse.Builder::cloudAutonomousVmCluster)
.handleResponseHeaderString(
"etag", GetCloudAutonomousVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetCloudAutonomousVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getCloudAutonomousVmClusterResourceUsage(
GetCloudAutonomousVmClusterResourceUsageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudAutonomousVmClusterResourceUsageRequest,
GetCloudAutonomousVmClusterResourceUsageResponse>
handler) {
Validate.notBlank(
request.getCloudAutonomousVmClusterId(),
"cloudAutonomousVmClusterId must not be blank");
return clientCall(request, GetCloudAutonomousVmClusterResourceUsageResponse::builder)
.logger(LOG, "getCloudAutonomousVmClusterResourceUsage")
.serviceDetails(
"Database",
"GetCloudAutonomousVmClusterResourceUsage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudAutonomousVmCluster/GetCloudAutonomousVmClusterResourceUsage")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudAutonomousVmClusterResourceUsageRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudAutonomousVmClusters")
.appendPathParam(request.getCloudAutonomousVmClusterId())
.appendPathParam("resourceUsage")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.CloudAutonomousVmClusterResourceUsage.class,
GetCloudAutonomousVmClusterResourceUsageResponse.Builder
::cloudAutonomousVmClusterResourceUsage)
.handleResponseHeaderString(
"etag", GetCloudAutonomousVmClusterResourceUsageResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetCloudAutonomousVmClusterResourceUsageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getCloudExadataInfrastructure(
GetCloudExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudExadataInfrastructureRequest,
GetCloudExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getCloudExadataInfrastructureId(),
"cloudExadataInfrastructureId must not be blank");
return clientCall(request, GetCloudExadataInfrastructureResponse::builder)
.logger(LOG, "getCloudExadataInfrastructure")
.serviceDetails(
"Database",
"GetCloudExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudExadataInfrastructure/GetCloudExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudExadataInfrastructures")
.appendPathParam(request.getCloudExadataInfrastructureId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.CloudExadataInfrastructure.class,
GetCloudExadataInfrastructureResponse.Builder::cloudExadataInfrastructure)
.handleResponseHeaderString(
"etag", GetCloudExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetCloudExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getCloudExadataInfrastructureUnallocatedResources(
GetCloudExadataInfrastructureUnallocatedResourcesRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudExadataInfrastructureUnallocatedResourcesRequest,
GetCloudExadataInfrastructureUnallocatedResourcesResponse>
handler) {
Validate.notBlank(
request.getCloudExadataInfrastructureId(),
"cloudExadataInfrastructureId must not be blank");
return clientCall(
request, GetCloudExadataInfrastructureUnallocatedResourcesResponse::builder)
.logger(LOG, "getCloudExadataInfrastructureUnallocatedResources")
.serviceDetails(
"Database",
"GetCloudExadataInfrastructureUnallocatedResources",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudExadataInfrastructureUnallocatedResources/GetCloudExadataInfrastructureUnallocatedResources")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudExadataInfrastructureUnallocatedResourcesRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudExadataInfrastructures")
.appendPathParam(request.getCloudExadataInfrastructureId())
.appendPathParam("unAllocatedResources")
.appendListQueryParam(
"dbServers",
request.getDbServers(),
com.oracle.bmc.util.internal.CollectionFormatType.Multi)
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.CloudExadataInfrastructureUnallocatedResources
.class,
GetCloudExadataInfrastructureUnallocatedResourcesResponse.Builder
::cloudExadataInfrastructureUnallocatedResources)
.handleResponseHeaderString(
"etag",
GetCloudExadataInfrastructureUnallocatedResourcesResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetCloudExadataInfrastructureUnallocatedResourcesResponse.Builder
::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getCloudVmCluster(
GetCloudVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudVmClusterRequest, GetCloudVmClusterResponse>
handler) {
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
return clientCall(request, GetCloudVmClusterResponse::builder)
.logger(LOG, "getCloudVmCluster")
.serviceDetails(
"Database",
"GetCloudVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudVmCluster/GetCloudVmCluster")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.CloudVmCluster.class,
GetCloudVmClusterResponse.Builder::cloudVmCluster)
.handleResponseHeaderString("etag", GetCloudVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetCloudVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getCloudVmClusterIormConfig(
GetCloudVmClusterIormConfigRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudVmClusterIormConfigRequest,
GetCloudVmClusterIormConfigResponse>
handler) {
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
return clientCall(request, GetCloudVmClusterIormConfigResponse::builder)
.logger(LOG, "getCloudVmClusterIormConfig")
.serviceDetails(
"Database",
"GetCloudVmClusterIormConfig",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/CloudVmCluster/GetCloudVmClusterIormConfig")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudVmClusterIormConfigRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.appendPathParam("CloudVmClusterIormConfig")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExadataIormConfig.class,
GetCloudVmClusterIormConfigResponse.Builder::exadataIormConfig)
.handleResponseHeaderString(
"opc-request-id", GetCloudVmClusterIormConfigResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"etag", GetCloudVmClusterIormConfigResponse.Builder::etag)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getCloudVmClusterUpdate(
GetCloudVmClusterUpdateRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudVmClusterUpdateRequest, GetCloudVmClusterUpdateResponse>
handler) {
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
Validate.notBlank(request.getUpdateId(), "updateId must not be blank");
return clientCall(request, GetCloudVmClusterUpdateResponse::builder)
.logger(LOG, "getCloudVmClusterUpdate")
.serviceDetails(
"Database",
"GetCloudVmClusterUpdate",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Update/GetCloudVmClusterUpdate")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudVmClusterUpdateRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.appendPathParam("updates")
.appendPathParam(request.getUpdateId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.Update.class,
GetCloudVmClusterUpdateResponse.Builder::update)
.handleResponseHeaderString(
"opc-request-id", GetCloudVmClusterUpdateResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getCloudVmClusterUpdateHistoryEntry(
GetCloudVmClusterUpdateHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetCloudVmClusterUpdateHistoryEntryRequest,
GetCloudVmClusterUpdateHistoryEntryResponse>
handler) {
Validate.notBlank(request.getCloudVmClusterId(), "cloudVmClusterId must not be blank");
Validate.notBlank(
request.getUpdateHistoryEntryId(), "updateHistoryEntryId must not be blank");
return clientCall(request, GetCloudVmClusterUpdateHistoryEntryResponse::builder)
.logger(LOG, "getCloudVmClusterUpdateHistoryEntry")
.serviceDetails(
"Database",
"GetCloudVmClusterUpdateHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/UpdateHistoryEntry/GetCloudVmClusterUpdateHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetCloudVmClusterUpdateHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("cloudVmClusters")
.appendPathParam(request.getCloudVmClusterId())
.appendPathParam("updateHistoryEntries")
.appendPathParam(request.getUpdateHistoryEntryId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.UpdateHistoryEntry.class,
GetCloudVmClusterUpdateHistoryEntryResponse.Builder::updateHistoryEntry)
.handleResponseHeaderString(
"etag", GetCloudVmClusterUpdateHistoryEntryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetCloudVmClusterUpdateHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getConsoleConnection(
GetConsoleConnectionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetConsoleConnectionRequest, GetConsoleConnectionResponse>
handler) {
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
Validate.notBlank(
request.getConsoleConnectionId(), "consoleConnectionId must not be blank");
return clientCall(request, GetConsoleConnectionResponse::builder)
.logger(LOG, "getConsoleConnection")
.serviceDetails(
"Database",
"GetConsoleConnection",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ConsoleConnection/GetConsoleConnection")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetConsoleConnectionRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendPathParam("consoleConnections")
.appendPathParam(request.getConsoleConnectionId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.ConsoleConnection.class,
GetConsoleConnectionResponse.Builder::consoleConnection)
.handleResponseHeaderString("etag", GetConsoleConnectionResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetConsoleConnectionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getConsoleHistory(
GetConsoleHistoryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetConsoleHistoryRequest, GetConsoleHistoryResponse>
handler) {
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
Validate.notBlank(request.getConsoleHistoryId(), "consoleHistoryId must not be blank");
return clientCall(request, GetConsoleHistoryResponse::builder)
.logger(LOG, "getConsoleHistory")
.serviceDetails(
"Database",
"GetConsoleHistory",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ConsoleHistory/GetConsoleHistory")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetConsoleHistoryRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendPathParam("consoleHistories")
.appendPathParam(request.getConsoleHistoryId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ConsoleHistory.class,
GetConsoleHistoryResponse.Builder::consoleHistory)
.handleResponseHeaderString(
"opc-request-id", GetConsoleHistoryResponse.Builder::opcRequestId)
.handleResponseHeaderString("etag", GetConsoleHistoryResponse.Builder::etag)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getConsoleHistoryContent(
GetConsoleHistoryContentRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetConsoleHistoryContentRequest, GetConsoleHistoryContentResponse>
handler) {
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
Validate.notBlank(request.getConsoleHistoryId(), "consoleHistoryId must not be blank");
return clientCall(request, GetConsoleHistoryContentResponse::builder)
.logger(LOG, "getConsoleHistoryContent")
.serviceDetails(
"Database",
"GetConsoleHistoryContent",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ConsoleHistory/GetConsoleHistoryContent")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetConsoleHistoryContentRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.appendPathParam("consoleHistories")
.appendPathParam(request.getConsoleHistoryId())
.appendPathParam("content")
.accept("application/octet-stream")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
java.io.InputStream.class,
GetConsoleHistoryContentResponse.Builder::inputStream)
.handleResponseHeaderString(
"opc-request-id", GetConsoleHistoryContentResponse.Builder::opcRequestId)
.handleResponseHeaderString("etag", GetConsoleHistoryContentResponse.Builder::etag)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDataGuardAssociation(
GetDataGuardAssociationRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDataGuardAssociationRequest, GetDataGuardAssociationResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Validate.notBlank(
request.getDataGuardAssociationId(), "dataGuardAssociationId must not be blank");
return clientCall(request, GetDataGuardAssociationResponse::builder)
.logger(LOG, "getDataGuardAssociation")
.serviceDetails(
"Database",
"GetDataGuardAssociation",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DataGuardAssociation/GetDataGuardAssociation")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDataGuardAssociationRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("dataGuardAssociations")
.appendPathParam(request.getDataGuardAssociationId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.DataGuardAssociation.class,
GetDataGuardAssociationResponse.Builder::dataGuardAssociation)
.handleResponseHeaderString("etag", GetDataGuardAssociationResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDataGuardAssociationResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDatabase(
GetDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
return clientCall(request, GetDatabaseResponse::builder)
.logger(LOG, "getDatabase")
.serviceDetails(
"Database",
"GetDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Database/GetDatabase")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.Database.class,
GetDatabaseResponse.Builder::database)
.handleResponseHeaderString("etag", GetDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDatabaseSoftwareImage(
GetDatabaseSoftwareImageRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDatabaseSoftwareImageRequest, GetDatabaseSoftwareImageResponse>
handler) {
Validate.notBlank(
request.getDatabaseSoftwareImageId(), "databaseSoftwareImageId must not be blank");
return clientCall(request, GetDatabaseSoftwareImageResponse::builder)
.logger(LOG, "getDatabaseSoftwareImage")
.serviceDetails(
"Database",
"GetDatabaseSoftwareImage",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DatabaseSoftwareImage/GetDatabaseSoftwareImage")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDatabaseSoftwareImageRequest::builder)
.basePath("/20160918")
.appendPathParam("databaseSoftwareImages")
.appendPathParam(request.getDatabaseSoftwareImageId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.DatabaseSoftwareImage.class,
GetDatabaseSoftwareImageResponse.Builder::databaseSoftwareImage)
.handleResponseHeaderString("etag", GetDatabaseSoftwareImageResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDatabaseSoftwareImageResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getDatabaseUpgradeHistoryEntry(
GetDatabaseUpgradeHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDatabaseUpgradeHistoryEntryRequest,
GetDatabaseUpgradeHistoryEntryResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Validate.notBlank(
request.getUpgradeHistoryEntryId(), "upgradeHistoryEntryId must not be blank");
return clientCall(request, GetDatabaseUpgradeHistoryEntryResponse::builder)
.logger(LOG, "getDatabaseUpgradeHistoryEntry")
.serviceDetails(
"Database",
"GetDatabaseUpgradeHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DatabaseUpgradeHistoryEntry/GetDatabaseUpgradeHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDatabaseUpgradeHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("upgradeHistoryEntries")
.appendPathParam(request.getUpgradeHistoryEntryId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.DatabaseUpgradeHistoryEntry.class,
GetDatabaseUpgradeHistoryEntryResponse.Builder::databaseUpgradeHistoryEntry)
.handleResponseHeaderString(
"opc-request-id",
GetDatabaseUpgradeHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDbHome(
GetDbHomeRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getDbHomeId(), "dbHomeId must not be blank");
return clientCall(request, GetDbHomeResponse::builder)
.logger(LOG, "getDbHome")
.serviceDetails(
"Database",
"GetDbHome",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbHome/GetDbHome")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbHomeRequest::builder)
.basePath("/20160918")
.appendPathParam("dbHomes")
.appendPathParam(request.getDbHomeId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.DbHome.class,
GetDbHomeResponse.Builder::dbHome)
.handleResponseHeaderString("etag", GetDbHomeResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDbHomeResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDbHomePatch(
GetDbHomePatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDbHomePatchRequest, GetDbHomePatchResponse>
handler) {
Validate.notBlank(request.getDbHomeId(), "dbHomeId must not be blank");
Validate.notBlank(request.getPatchId(), "patchId must not be blank");
return clientCall(request, GetDbHomePatchResponse::builder)
.logger(LOG, "getDbHomePatch")
.serviceDetails(
"Database",
"GetDbHomePatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Patch/GetDbHomePatch")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbHomePatchRequest::builder)
.basePath("/20160918")
.appendPathParam("dbHomes")
.appendPathParam(request.getDbHomeId())
.appendPathParam("patches")
.appendPathParam(request.getPatchId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.Patch.class,
GetDbHomePatchResponse.Builder::patch)
.handleResponseHeaderString(
"opc-request-id", GetDbHomePatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getDbHomePatchHistoryEntry(
GetDbHomePatchHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDbHomePatchHistoryEntryRequest,
GetDbHomePatchHistoryEntryResponse>
handler) {
Validate.notBlank(request.getDbHomeId(), "dbHomeId must not be blank");
Validate.notBlank(
request.getPatchHistoryEntryId(), "patchHistoryEntryId must not be blank");
return clientCall(request, GetDbHomePatchHistoryEntryResponse::builder)
.logger(LOG, "getDbHomePatchHistoryEntry")
.serviceDetails(
"Database",
"GetDbHomePatchHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PatchHistoryEntry/GetDbHomePatchHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbHomePatchHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("dbHomes")
.appendPathParam(request.getDbHomeId())
.appendPathParam("patchHistoryEntries")
.appendPathParam(request.getPatchHistoryEntryId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.PatchHistoryEntry.class,
GetDbHomePatchHistoryEntryResponse.Builder::patchHistoryEntry)
.handleResponseHeaderString(
"etag", GetDbHomePatchHistoryEntryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDbHomePatchHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDbNode(
GetDbNodeRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getDbNodeId(), "dbNodeId must not be blank");
return clientCall(request, GetDbNodeResponse::builder)
.logger(LOG, "getDbNode")
.serviceDetails(
"Database",
"GetDbNode",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbNode/GetDbNode")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbNodeRequest::builder)
.basePath("/20160918")
.appendPathParam("dbNodes")
.appendPathParam(request.getDbNodeId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.DbNode.class,
GetDbNodeResponse.Builder::dbNode)
.handleResponseHeaderString("etag", GetDbNodeResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDbNodeResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDbServer(
GetDbServerRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Objects.requireNonNull(
request.getExadataInfrastructureId(), "exadataInfrastructureId is required");
Validate.notBlank(request.getDbServerId(), "dbServerId must not be blank");
return clientCall(request, GetDbServerResponse::builder)
.logger(LOG, "getDbServer")
.serviceDetails(
"Database",
"GetDbServer",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbServer/GetDbServer")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbServerRequest::builder)
.basePath("/20160918")
.appendPathParam("dbServers")
.appendPathParam(request.getDbServerId())
.appendQueryParam("exadataInfrastructureId", request.getExadataInfrastructureId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.DbServer.class,
GetDbServerResponse.Builder::dbServer)
.handleResponseHeaderString("etag", GetDbServerResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDbServerResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDbSystem(
GetDbSystemRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getDbSystemId(), "dbSystemId must not be blank");
return clientCall(request, GetDbSystemResponse::builder)
.logger(LOG, "getDbSystem")
.serviceDetails(
"Database",
"GetDbSystem",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbSystem/GetDbSystem")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbSystemRequest::builder)
.basePath("/20160918")
.appendPathParam("dbSystems")
.appendPathParam(request.getDbSystemId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.DbSystem.class,
GetDbSystemResponse.Builder::dbSystem)
.handleResponseHeaderString("etag", GetDbSystemResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetDbSystemResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getDbSystemPatch(
GetDbSystemPatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDbSystemPatchRequest, GetDbSystemPatchResponse>
handler) {
Validate.notBlank(request.getDbSystemId(), "dbSystemId must not be blank");
Validate.notBlank(request.getPatchId(), "patchId must not be blank");
return clientCall(request, GetDbSystemPatchResponse::builder)
.logger(LOG, "getDbSystemPatch")
.serviceDetails(
"Database",
"GetDbSystemPatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Patch/GetDbSystemPatch")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbSystemPatchRequest::builder)
.basePath("/20160918")
.appendPathParam("dbSystems")
.appendPathParam(request.getDbSystemId())
.appendPathParam("patches")
.appendPathParam(request.getPatchId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.Patch.class,
GetDbSystemPatchResponse.Builder::patch)
.handleResponseHeaderString(
"opc-request-id", GetDbSystemPatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getDbSystemPatchHistoryEntry(
GetDbSystemPatchHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDbSystemPatchHistoryEntryRequest,
GetDbSystemPatchHistoryEntryResponse>
handler) {
Validate.notBlank(request.getDbSystemId(), "dbSystemId must not be blank");
Validate.notBlank(
request.getPatchHistoryEntryId(), "patchHistoryEntryId must not be blank");
return clientCall(request, GetDbSystemPatchHistoryEntryResponse::builder)
.logger(LOG, "getDbSystemPatchHistoryEntry")
.serviceDetails(
"Database",
"GetDbSystemPatchHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PatchHistoryEntry/GetDbSystemPatchHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbSystemPatchHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("dbSystems")
.appendPathParam(request.getDbSystemId())
.appendPathParam("patchHistoryEntries")
.appendPathParam(request.getPatchHistoryEntryId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.PatchHistoryEntry.class,
GetDbSystemPatchHistoryEntryResponse.Builder::patchHistoryEntry)
.handleResponseHeaderString(
"etag", GetDbSystemPatchHistoryEntryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetDbSystemPatchHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getDbSystemUpgradeHistoryEntry(
GetDbSystemUpgradeHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetDbSystemUpgradeHistoryEntryRequest,
GetDbSystemUpgradeHistoryEntryResponse>
handler) {
Validate.notBlank(request.getDbSystemId(), "dbSystemId must not be blank");
Validate.notBlank(
request.getUpgradeHistoryEntryId(), "upgradeHistoryEntryId must not be blank");
return clientCall(request, GetDbSystemUpgradeHistoryEntryResponse::builder)
.logger(LOG, "getDbSystemUpgradeHistoryEntry")
.serviceDetails(
"Database",
"GetDbSystemUpgradeHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbSystemUpgradeHistoryEntry/GetDbSystemUpgradeHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetDbSystemUpgradeHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("dbSystems")
.appendPathParam(request.getDbSystemId())
.appendPathParam("upgradeHistoryEntries")
.appendPathParam(request.getUpgradeHistoryEntryId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.DbSystemUpgradeHistoryEntry.class,
GetDbSystemUpgradeHistoryEntryResponse.Builder::dbSystemUpgradeHistoryEntry)
.handleResponseHeaderString(
"opc-request-id",
GetDbSystemUpgradeHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExadataInfrastructure(
GetExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExadataInfrastructureRequest, GetExadataInfrastructureResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
return clientCall(request, GetExadataInfrastructureResponse::builder)
.logger(LOG, "getExadataInfrastructure")
.serviceDetails(
"Database",
"GetExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructure/GetExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendListQueryParam(
"excludedFields",
request.getExcludedFields(),
com.oracle.bmc.util.internal.CollectionFormatType.Multi)
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExadataInfrastructure.class,
GetExadataInfrastructureResponse.Builder::exadataInfrastructure)
.handleResponseHeaderString("etag", GetExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetExadataInfrastructureResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getExadataInfrastructureOcpus(
GetExadataInfrastructureOcpusRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExadataInfrastructureOcpusRequest,
GetExadataInfrastructureOcpusResponse>
handler) {
Validate.notBlank(
request.getAutonomousExadataInfrastructureId(),
"autonomousExadataInfrastructureId must not be blank");
return clientCall(request, GetExadataInfrastructureOcpusResponse::builder)
.logger(LOG, "getExadataInfrastructureOcpus")
.serviceDetails(
"Database",
"GetExadataInfrastructureOcpus",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/OCPUs/GetExadataInfrastructureOcpus")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExadataInfrastructureOcpusRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousExadataInfrastructures")
.appendPathParam(request.getAutonomousExadataInfrastructureId())
.appendPathParam("ocpus")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.OCPUs.class,
GetExadataInfrastructureOcpusResponse.Builder::oCPUs)
.handleResponseHeaderString(
"opc-request-id",
GetExadataInfrastructureOcpusResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getExadataInfrastructureUnAllocatedResources(
GetExadataInfrastructureUnAllocatedResourcesRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExadataInfrastructureUnAllocatedResourcesRequest,
GetExadataInfrastructureUnAllocatedResourcesResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
return clientCall(request, GetExadataInfrastructureUnAllocatedResourcesResponse::builder)
.logger(LOG, "getExadataInfrastructureUnAllocatedResources")
.serviceDetails(
"Database",
"GetExadataInfrastructureUnAllocatedResources",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadataInfrastructureUnAllocatedResources/GetExadataInfrastructureUnAllocatedResources")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExadataInfrastructureUnAllocatedResourcesRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("unAllocatedResources")
.appendListQueryParam(
"dbServers",
request.getDbServers(),
com.oracle.bmc.util.internal.CollectionFormatType.Multi)
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExadataInfrastructureUnAllocatedResources
.class,
GetExadataInfrastructureUnAllocatedResourcesResponse.Builder
::exadataInfrastructureUnAllocatedResources)
.handleResponseHeaderString(
"etag", GetExadataInfrastructureUnAllocatedResourcesResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetExadataInfrastructureUnAllocatedResourcesResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExadataIormConfig(
GetExadataIormConfigRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExadataIormConfigRequest, GetExadataIormConfigResponse>
handler) {
Validate.notBlank(request.getDbSystemId(), "dbSystemId must not be blank");
return clientCall(request, GetExadataIormConfigResponse::builder)
.logger(LOG, "getExadataIormConfig")
.serviceDetails(
"Database",
"GetExadataIormConfig",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbSystem/GetExadataIormConfig")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExadataIormConfigRequest::builder)
.basePath("/20160918")
.appendPathParam("dbSystems")
.appendPathParam(request.getDbSystemId())
.appendPathParam("ExadataIormConfig")
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExadataIormConfig.class,
GetExadataIormConfigResponse.Builder::exadataIormConfig)
.handleResponseHeaderString(
"opc-request-id", GetExadataIormConfigResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExadbVmCluster(
GetExadbVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExadbVmClusterRequest, GetExadbVmClusterResponse>
handler) {
Validate.notBlank(request.getExadbVmClusterId(), "exadbVmClusterId must not be blank");
return clientCall(request, GetExadbVmClusterResponse::builder)
.logger(LOG, "getExadbVmCluster")
.serviceDetails(
"Database",
"GetExadbVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadbVmCluster/GetExadbVmCluster")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExadbVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("exadbVmClusters")
.appendPathParam(request.getExadbVmClusterId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExadbVmCluster.class,
GetExadbVmClusterResponse.Builder::exadbVmCluster)
.handleResponseHeaderString("etag", GetExadbVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetExadbVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExadbVmClusterUpdate(
GetExadbVmClusterUpdateRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExadbVmClusterUpdateRequest, GetExadbVmClusterUpdateResponse>
handler) {
Validate.notBlank(request.getExadbVmClusterId(), "exadbVmClusterId must not be blank");
Validate.notBlank(request.getUpdateId(), "updateId must not be blank");
return clientCall(request, GetExadbVmClusterUpdateResponse::builder)
.logger(LOG, "getExadbVmClusterUpdate")
.serviceDetails(
"Database",
"GetExadbVmClusterUpdate",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadbVmClusterUpdate/GetExadbVmClusterUpdate")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExadbVmClusterUpdateRequest::builder)
.basePath("/20160918")
.appendPathParam("exadbVmClusters")
.appendPathParam(request.getExadbVmClusterId())
.appendPathParam("updates")
.appendPathParam(request.getUpdateId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExadbVmClusterUpdate.class,
GetExadbVmClusterUpdateResponse.Builder::exadbVmClusterUpdate)
.handleResponseHeaderString(
"opc-request-id", GetExadbVmClusterUpdateResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getExadbVmClusterUpdateHistoryEntry(
GetExadbVmClusterUpdateHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExadbVmClusterUpdateHistoryEntryRequest,
GetExadbVmClusterUpdateHistoryEntryResponse>
handler) {
Validate.notBlank(request.getExadbVmClusterId(), "exadbVmClusterId must not be blank");
Validate.notBlank(
request.getUpdateHistoryEntryId(), "updateHistoryEntryId must not be blank");
return clientCall(request, GetExadbVmClusterUpdateHistoryEntryResponse::builder)
.logger(LOG, "getExadbVmClusterUpdateHistoryEntry")
.serviceDetails(
"Database",
"GetExadbVmClusterUpdateHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExadbVmClusterUpdateHistoryEntry/GetExadbVmClusterUpdateHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExadbVmClusterUpdateHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("exadbVmClusters")
.appendPathParam(request.getExadbVmClusterId())
.appendPathParam("updateHistoryEntries")
.appendPathParam(request.getUpdateHistoryEntryId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExadbVmClusterUpdateHistoryEntry.class,
GetExadbVmClusterUpdateHistoryEntryResponse.Builder
::exadbVmClusterUpdateHistoryEntry)
.handleResponseHeaderString(
"etag", GetExadbVmClusterUpdateHistoryEntryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetExadbVmClusterUpdateHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExascaleDbStorageVault(
GetExascaleDbStorageVaultRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExascaleDbStorageVaultRequest, GetExascaleDbStorageVaultResponse>
handler) {
Validate.notBlank(
request.getExascaleDbStorageVaultId(),
"exascaleDbStorageVaultId must not be blank");
return clientCall(request, GetExascaleDbStorageVaultResponse::builder)
.logger(LOG, "getExascaleDbStorageVault")
.serviceDetails(
"Database",
"GetExascaleDbStorageVault",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExascaleDbStorageVault/GetExascaleDbStorageVault")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExascaleDbStorageVaultRequest::builder)
.basePath("/20160918")
.appendPathParam("exascaleDbStorageVaults")
.appendPathParam(request.getExascaleDbStorageVaultId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExascaleDbStorageVault.class,
GetExascaleDbStorageVaultResponse.Builder::exascaleDbStorageVault)
.handleResponseHeaderString("etag", GetExascaleDbStorageVaultResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetExascaleDbStorageVaultResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExecutionAction(
GetExecutionActionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExecutionActionRequest, GetExecutionActionResponse>
handler) {
Validate.notBlank(request.getExecutionActionId(), "executionActionId must not be blank");
return clientCall(request, GetExecutionActionResponse::builder)
.logger(LOG, "getExecutionAction")
.serviceDetails(
"Database",
"GetExecutionAction",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExecutionAction/GetExecutionAction")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExecutionActionRequest::builder)
.basePath("/20160918")
.appendPathParam("executionActions")
.appendPathParam(request.getExecutionActionId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExecutionAction.class,
GetExecutionActionResponse.Builder::executionAction)
.handleResponseHeaderString("etag", GetExecutionActionResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetExecutionActionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExecutionWindow(
GetExecutionWindowRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExecutionWindowRequest, GetExecutionWindowResponse>
handler) {
Validate.notBlank(request.getExecutionWindowId(), "executionWindowId must not be blank");
return clientCall(request, GetExecutionWindowResponse::builder)
.logger(LOG, "getExecutionWindow")
.serviceDetails(
"Database",
"GetExecutionWindow",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExecutionWindow/GetExecutionWindow")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExecutionWindowRequest::builder)
.basePath("/20160918")
.appendPathParam("executionWindows")
.appendPathParam(request.getExecutionWindowId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExecutionWindow.class,
GetExecutionWindowResponse.Builder::executionWindow)
.handleResponseHeaderString("etag", GetExecutionWindowResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetExecutionWindowResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getExternalBackupJob(
GetExternalBackupJobRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExternalBackupJobRequest, GetExternalBackupJobResponse>
handler) {
Validate.notBlank(request.getBackupId(), "backupId must not be blank");
return clientCall(request, GetExternalBackupJobResponse::builder)
.logger(LOG, "getExternalBackupJob")
.serviceDetails(
"Database",
"GetExternalBackupJob",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalBackupJob/GetExternalBackupJob")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExternalBackupJobRequest::builder)
.basePath("/20160918")
.appendPathParam("externalBackupJobs")
.appendPathParam(request.getBackupId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.ExternalBackupJob.class,
GetExternalBackupJobResponse.Builder::externalBackupJob)
.handleResponseHeaderString("etag", GetExternalBackupJobResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetExternalBackupJobResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getExternalContainerDatabase(
GetExternalContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExternalContainerDatabaseRequest,
GetExternalContainerDatabaseResponse>
handler) {
Validate.notBlank(
request.getExternalContainerDatabaseId(),
"externalContainerDatabaseId must not be blank");
return clientCall(request, GetExternalContainerDatabaseResponse::builder)
.logger(LOG, "getExternalContainerDatabase")
.serviceDetails(
"Database",
"GetExternalContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalContainerDatabase/GetExternalContainerDatabase")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExternalContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalcontainerdatabases")
.appendPathParam(request.getExternalContainerDatabaseId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExternalContainerDatabase.class,
GetExternalContainerDatabaseResponse.Builder::externalContainerDatabase)
.handleResponseHeaderString(
"etag", GetExternalContainerDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetExternalContainerDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getExternalDatabaseConnector(
GetExternalDatabaseConnectorRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExternalDatabaseConnectorRequest,
GetExternalDatabaseConnectorResponse>
handler) {
Validate.notBlank(
request.getExternalDatabaseConnectorId(),
"externalDatabaseConnectorId must not be blank");
return clientCall(request, GetExternalDatabaseConnectorResponse::builder)
.logger(LOG, "getExternalDatabaseConnector")
.serviceDetails(
"Database",
"GetExternalDatabaseConnector",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalDatabaseConnector/GetExternalDatabaseConnector")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExternalDatabaseConnectorRequest::builder)
.basePath("/20160918")
.appendPathParam("externaldatabaseconnectors")
.appendPathParam(request.getExternalDatabaseConnectorId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExternalDatabaseConnector.class,
GetExternalDatabaseConnectorResponse.Builder::externalDatabaseConnector)
.handleResponseHeaderString(
"etag", GetExternalDatabaseConnectorResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetExternalDatabaseConnectorResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getExternalNonContainerDatabase(
GetExternalNonContainerDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExternalNonContainerDatabaseRequest,
GetExternalNonContainerDatabaseResponse>
handler) {
Validate.notBlank(
request.getExternalNonContainerDatabaseId(),
"externalNonContainerDatabaseId must not be blank");
return clientCall(request, GetExternalNonContainerDatabaseResponse::builder)
.logger(LOG, "getExternalNonContainerDatabase")
.serviceDetails(
"Database",
"GetExternalNonContainerDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalNonContainerDatabase/GetExternalNonContainerDatabase")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExternalNonContainerDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalnoncontainerdatabases")
.appendPathParam(request.getExternalNonContainerDatabaseId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExternalNonContainerDatabase.class,
GetExternalNonContainerDatabaseResponse.Builder
::externalNonContainerDatabase)
.handleResponseHeaderString(
"etag", GetExternalNonContainerDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetExternalNonContainerDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getExternalPluggableDatabase(
GetExternalPluggableDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetExternalPluggableDatabaseRequest,
GetExternalPluggableDatabaseResponse>
handler) {
Validate.notBlank(
request.getExternalPluggableDatabaseId(),
"externalPluggableDatabaseId must not be blank");
return clientCall(request, GetExternalPluggableDatabaseResponse::builder)
.logger(LOG, "getExternalPluggableDatabase")
.serviceDetails(
"Database",
"GetExternalPluggableDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ExternalPluggableDatabase/GetExternalPluggableDatabase")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetExternalPluggableDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("externalpluggabledatabases")
.appendPathParam(request.getExternalPluggableDatabaseId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ExternalPluggableDatabase.class,
GetExternalPluggableDatabaseResponse.Builder::externalPluggableDatabase)
.handleResponseHeaderString(
"etag", GetExternalPluggableDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetExternalPluggableDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getInfrastructureTargetVersions(
GetInfrastructureTargetVersionsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetInfrastructureTargetVersionsRequest,
GetInfrastructureTargetVersionsResponse>
handler) {
Objects.requireNonNull(request.getCompartmentId(), "compartmentId is required");
return clientCall(request, GetInfrastructureTargetVersionsResponse::builder)
.logger(LOG, "getInfrastructureTargetVersions")
.serviceDetails(
"Database",
"GetInfrastructureTargetVersions",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/InfrastructureTargetVersion/GetInfrastructureTargetVersions")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetInfrastructureTargetVersionsRequest::builder)
.basePath("/20160918")
.appendPathParam("infrastructureTargetVersions")
.appendQueryParam("compartmentId", request.getCompartmentId())
.appendQueryParam("targetResourceId", request.getTargetResourceId())
.appendEnumQueryParam("targetResourceType", request.getTargetResourceType())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.InfrastructureTargetVersion.class,
GetInfrastructureTargetVersionsResponse.Builder
::infrastructureTargetVersion)
.handleResponseHeaderString(
"opc-request-id",
GetInfrastructureTargetVersionsResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
GetInfrastructureTargetVersionsResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getKeyStore(
GetKeyStoreRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getKeyStoreId(), "keyStoreId must not be blank");
return clientCall(request, GetKeyStoreResponse::builder)
.logger(LOG, "getKeyStore")
.serviceDetails(
"Database",
"GetKeyStore",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/KeyStore/GetKeyStore")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetKeyStoreRequest::builder)
.basePath("/20160918")
.appendPathParam("keyStores")
.appendPathParam(request.getKeyStoreId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.KeyStore.class,
GetKeyStoreResponse.Builder::keyStore)
.handleResponseHeaderString("etag", GetKeyStoreResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetKeyStoreResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getMaintenanceRun(
GetMaintenanceRunRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetMaintenanceRunRequest, GetMaintenanceRunResponse>
handler) {
Validate.notBlank(request.getMaintenanceRunId(), "maintenanceRunId must not be blank");
return clientCall(request, GetMaintenanceRunResponse::builder)
.logger(LOG, "getMaintenanceRun")
.serviceDetails(
"Database",
"GetMaintenanceRun",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/MaintenanceRun/GetMaintenanceRun")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetMaintenanceRunRequest::builder)
.basePath("/20160918")
.appendPathParam("maintenanceRuns")
.appendPathParam(request.getMaintenanceRunId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.MaintenanceRun.class,
GetMaintenanceRunResponse.Builder::maintenanceRun)
.handleResponseHeaderString("etag", GetMaintenanceRunResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetMaintenanceRunResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getMaintenanceRunHistory(
GetMaintenanceRunHistoryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetMaintenanceRunHistoryRequest, GetMaintenanceRunHistoryResponse>
handler) {
Validate.notBlank(
request.getMaintenanceRunHistoryId(), "maintenanceRunHistoryId must not be blank");
return clientCall(request, GetMaintenanceRunHistoryResponse::builder)
.logger(LOG, "getMaintenanceRunHistory")
.serviceDetails(
"Database",
"GetMaintenanceRunHistory",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/MaintenanceRunHistory/GetMaintenanceRunHistory")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetMaintenanceRunHistoryRequest::builder)
.basePath("/20160918")
.appendPathParam("maintenanceRunHistory")
.appendPathParam(request.getMaintenanceRunHistoryId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.MaintenanceRunHistory.class,
GetMaintenanceRunHistoryResponse.Builder::maintenanceRunHistory)
.handleResponseHeaderString("etag", GetMaintenanceRunHistoryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetMaintenanceRunHistoryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getOneoffPatch(
GetOneoffPatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetOneoffPatchRequest, GetOneoffPatchResponse>
handler) {
Validate.notBlank(request.getOneoffPatchId(), "oneoffPatchId must not be blank");
return clientCall(request, GetOneoffPatchResponse::builder)
.logger(LOG, "getOneoffPatch")
.serviceDetails(
"Database",
"GetOneoffPatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/OneoffPatch/GetOneoffPatch")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetOneoffPatchRequest::builder)
.basePath("/20160918")
.appendPathParam("oneoffPatches")
.appendPathParam(request.getOneoffPatchId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.OneoffPatch.class,
GetOneoffPatchResponse.Builder::oneoffPatch)
.handleResponseHeaderString("etag", GetOneoffPatchResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetOneoffPatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getPdbConversionHistoryEntry(
GetPdbConversionHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetPdbConversionHistoryEntryRequest,
GetPdbConversionHistoryEntryResponse>
handler) {
Validate.notBlank(request.getDatabaseId(), "databaseId must not be blank");
Validate.notBlank(
request.getPdbConversionHistoryEntryId(),
"pdbConversionHistoryEntryId must not be blank");
return clientCall(request, GetPdbConversionHistoryEntryResponse::builder)
.logger(LOG, "getPdbConversionHistoryEntry")
.serviceDetails(
"Database",
"GetPdbConversionHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PdbConversionHistoryEntry/GetPdbConversionHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetPdbConversionHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("databases")
.appendPathParam(request.getDatabaseId())
.appendPathParam("pdbConversionHistoryEntries")
.appendPathParam(request.getPdbConversionHistoryEntryId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.PdbConversionHistoryEntry.class,
GetPdbConversionHistoryEntryResponse.Builder::pdbConversionHistoryEntry)
.handleResponseHeaderString(
"opc-request-id",
GetPdbConversionHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getPluggableDatabase(
GetPluggableDatabaseRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetPluggableDatabaseRequest, GetPluggableDatabaseResponse>
handler) {
Validate.notBlank(
request.getPluggableDatabaseId(), "pluggableDatabaseId must not be blank");
return clientCall(request, GetPluggableDatabaseResponse::builder)
.logger(LOG, "getPluggableDatabase")
.serviceDetails(
"Database",
"GetPluggableDatabase",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PluggableDatabase/GetPluggableDatabase")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetPluggableDatabaseRequest::builder)
.basePath("/20160918")
.appendPathParam("pluggableDatabases")
.appendPathParam(request.getPluggableDatabaseId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.PluggableDatabase.class,
GetPluggableDatabaseResponse.Builder::pluggableDatabase)
.handleResponseHeaderString("etag", GetPluggableDatabaseResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetPluggableDatabaseResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getScheduledAction(
GetScheduledActionRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetScheduledActionRequest, GetScheduledActionResponse>
handler) {
Validate.notBlank(request.getScheduledActionId(), "scheduledActionId must not be blank");
return clientCall(request, GetScheduledActionResponse::builder)
.logger(LOG, "getScheduledAction")
.serviceDetails(
"Database",
"GetScheduledAction",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ScheduledAction/GetScheduledAction")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetScheduledActionRequest::builder)
.basePath("/20160918")
.appendPathParam("scheduledActions")
.appendPathParam(request.getScheduledActionId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.ScheduledAction.class,
GetScheduledActionResponse.Builder::scheduledAction)
.handleResponseHeaderString("etag", GetScheduledActionResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetScheduledActionResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getSchedulingPlan(
GetSchedulingPlanRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetSchedulingPlanRequest, GetSchedulingPlanResponse>
handler) {
Validate.notBlank(request.getSchedulingPlanId(), "schedulingPlanId must not be blank");
return clientCall(request, GetSchedulingPlanResponse::builder)
.logger(LOG, "getSchedulingPlan")
.serviceDetails(
"Database",
"GetSchedulingPlan",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPlan/GetSchedulingPlan")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetSchedulingPlanRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPlans")
.appendPathParam(request.getSchedulingPlanId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.SchedulingPlan.class,
GetSchedulingPlanResponse.Builder::schedulingPlan)
.handleResponseHeaderString("etag", GetSchedulingPlanResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetSchedulingPlanResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getSchedulingPolicy(
GetSchedulingPolicyRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetSchedulingPolicyRequest, GetSchedulingPolicyResponse>
handler) {
Validate.notBlank(request.getSchedulingPolicyId(), "schedulingPolicyId must not be blank");
return clientCall(request, GetSchedulingPolicyResponse::builder)
.logger(LOG, "getSchedulingPolicy")
.serviceDetails(
"Database",
"GetSchedulingPolicy",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingPolicy/GetSchedulingPolicy")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetSchedulingPolicyRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPolicies")
.appendPathParam(request.getSchedulingPolicyId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.SchedulingPolicy.class,
GetSchedulingPolicyResponse.Builder::schedulingPolicy)
.handleResponseHeaderString("etag", GetSchedulingPolicyResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetSchedulingPolicyResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getSchedulingWindow(
GetSchedulingWindowRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetSchedulingWindowRequest, GetSchedulingWindowResponse>
handler) {
Validate.notBlank(request.getSchedulingPolicyId(), "schedulingPolicyId must not be blank");
Validate.notBlank(request.getSchedulingWindowId(), "schedulingWindowId must not be blank");
return clientCall(request, GetSchedulingWindowResponse::builder)
.logger(LOG, "getSchedulingWindow")
.serviceDetails(
"Database",
"GetSchedulingWindow",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/SchedulingWindow/GetSchedulingWindow")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetSchedulingWindowRequest::builder)
.basePath("/20160918")
.appendPathParam("schedulingPolicies")
.appendPathParam(request.getSchedulingPolicyId())
.appendPathParam("schedulingWindows")
.appendPathParam(request.getSchedulingWindowId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.SchedulingWindow.class,
GetSchedulingWindowResponse.Builder::schedulingWindow)
.handleResponseHeaderString("etag", GetSchedulingWindowResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetSchedulingWindowResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getVmCluster(
GetVmClusterRequest request,
final com.oracle.bmc.responses.AsyncHandler
handler) {
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
return clientCall(request, GetVmClusterResponse::builder)
.logger(LOG, "getVmCluster")
.serviceDetails(
"Database",
"GetVmCluster",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmCluster/GetVmCluster")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetVmClusterRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.VmCluster.class,
GetVmClusterResponse.Builder::vmCluster)
.handleResponseHeaderString("etag", GetVmClusterResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetVmClusterResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getVmClusterNetwork(
GetVmClusterNetworkRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetVmClusterNetworkRequest, GetVmClusterNetworkResponse>
handler) {
Validate.notBlank(
request.getExadataInfrastructureId(), "exadataInfrastructureId must not be blank");
Validate.notBlank(request.getVmClusterNetworkId(), "vmClusterNetworkId must not be blank");
return clientCall(request, GetVmClusterNetworkResponse::builder)
.logger(LOG, "getVmClusterNetwork")
.serviceDetails(
"Database",
"GetVmClusterNetwork",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmClusterNetwork/GetVmClusterNetwork")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetVmClusterNetworkRequest::builder)
.basePath("/20160918")
.appendPathParam("exadataInfrastructures")
.appendPathParam(request.getExadataInfrastructureId())
.appendPathParam("vmClusterNetworks")
.appendPathParam(request.getVmClusterNetworkId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.VmClusterNetwork.class,
GetVmClusterNetworkResponse.Builder::vmClusterNetwork)
.handleResponseHeaderString("etag", GetVmClusterNetworkResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", GetVmClusterNetworkResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getVmClusterPatch(
GetVmClusterPatchRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetVmClusterPatchRequest, GetVmClusterPatchResponse>
handler) {
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
Validate.notBlank(request.getPatchId(), "patchId must not be blank");
return clientCall(request, GetVmClusterPatchResponse::builder)
.logger(LOG, "getVmClusterPatch")
.serviceDetails(
"Database",
"GetVmClusterPatch",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/Patch/GetVmClusterPatch")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetVmClusterPatchRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.appendPathParam("patches")
.appendPathParam(request.getPatchId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.Patch.class,
GetVmClusterPatchResponse.Builder::patch)
.handleResponseHeaderString(
"opc-request-id", GetVmClusterPatchResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getVmClusterPatchHistoryEntry(
GetVmClusterPatchHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetVmClusterPatchHistoryEntryRequest,
GetVmClusterPatchHistoryEntryResponse>
handler) {
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
Validate.notBlank(
request.getPatchHistoryEntryId(), "patchHistoryEntryId must not be blank");
return clientCall(request, GetVmClusterPatchHistoryEntryResponse::builder)
.logger(LOG, "getVmClusterPatchHistoryEntry")
.serviceDetails(
"Database",
"GetVmClusterPatchHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/PatchHistoryEntry/GetVmClusterPatchHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetVmClusterPatchHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.appendPathParam("patchHistoryEntries")
.appendPathParam(request.getPatchHistoryEntryId())
.accept("application/json")
.handleBody(
com.oracle.bmc.database.model.PatchHistoryEntry.class,
GetVmClusterPatchHistoryEntryResponse.Builder::patchHistoryEntry)
.handleResponseHeaderString(
"etag", GetVmClusterPatchHistoryEntryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetVmClusterPatchHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future getVmClusterUpdate(
GetVmClusterUpdateRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetVmClusterUpdateRequest, GetVmClusterUpdateResponse>
handler) {
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
Validate.notBlank(request.getUpdateId(), "updateId must not be blank");
return clientCall(request, GetVmClusterUpdateResponse::builder)
.logger(LOG, "getVmClusterUpdate")
.serviceDetails(
"Database",
"GetVmClusterUpdate",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmClusterUpdate/GetVmClusterUpdate")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetVmClusterUpdateRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.appendPathParam("updates")
.appendPathParam(request.getUpdateId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.VmClusterUpdate.class,
GetVmClusterUpdateResponse.Builder::vmClusterUpdate)
.handleResponseHeaderString(
"opc-request-id", GetVmClusterUpdateResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
getVmClusterUpdateHistoryEntry(
GetVmClusterUpdateHistoryEntryRequest request,
final com.oracle.bmc.responses.AsyncHandler<
GetVmClusterUpdateHistoryEntryRequest,
GetVmClusterUpdateHistoryEntryResponse>
handler) {
Validate.notBlank(request.getVmClusterId(), "vmClusterId must not be blank");
Validate.notBlank(
request.getUpdateHistoryEntryId(), "updateHistoryEntryId must not be blank");
return clientCall(request, GetVmClusterUpdateHistoryEntryResponse::builder)
.logger(LOG, "getVmClusterUpdateHistoryEntry")
.serviceDetails(
"Database",
"GetVmClusterUpdateHistoryEntry",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/VmClusterUpdateHistoryEntry/GetVmClusterUpdateHistoryEntry")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(GetVmClusterUpdateHistoryEntryRequest::builder)
.basePath("/20160918")
.appendPathParam("vmClusters")
.appendPathParam(request.getVmClusterId())
.appendPathParam("updateHistoryEntries")
.appendPathParam(request.getUpdateHistoryEntryId())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.VmClusterUpdateHistoryEntry.class,
GetVmClusterUpdateHistoryEntryResponse.Builder::vmClusterUpdateHistoryEntry)
.handleResponseHeaderString(
"etag", GetVmClusterUpdateHistoryEntryResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
GetVmClusterUpdateHistoryEntryResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
launchAutonomousExadataInfrastructure(
LaunchAutonomousExadataInfrastructureRequest request,
final com.oracle.bmc.responses.AsyncHandler<
LaunchAutonomousExadataInfrastructureRequest,
LaunchAutonomousExadataInfrastructureResponse>
handler) {
Objects.requireNonNull(
request.getLaunchAutonomousExadataInfrastructureDetails(),
"launchAutonomousExadataInfrastructureDetails is required");
return clientCall(request, LaunchAutonomousExadataInfrastructureResponse::builder)
.logger(LOG, "launchAutonomousExadataInfrastructure")
.serviceDetails(
"Database",
"LaunchAutonomousExadataInfrastructure",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousExadataInfrastructure/LaunchAutonomousExadataInfrastructure")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(LaunchAutonomousExadataInfrastructureRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousExadataInfrastructures")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.AutonomousExadataInfrastructure.class,
LaunchAutonomousExadataInfrastructureResponse.Builder
::autonomousExadataInfrastructure)
.handleResponseHeaderString(
"etag", LaunchAutonomousExadataInfrastructureResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id",
LaunchAutonomousExadataInfrastructureResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-work-request-id",
LaunchAutonomousExadataInfrastructureResponse.Builder::opcWorkRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future launchDbSystem(
LaunchDbSystemRequest request,
final com.oracle.bmc.responses.AsyncHandler<
LaunchDbSystemRequest, LaunchDbSystemResponse>
handler) {
Objects.requireNonNull(
request.getLaunchDbSystemDetails(), "launchDbSystemDetails is required");
return clientCall(request, LaunchDbSystemResponse::builder)
.logger(LOG, "launchDbSystem")
.serviceDetails(
"Database",
"LaunchDbSystem",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/DbSystem/LaunchDbSystem")
.method(com.oracle.bmc.http.client.Method.POST)
.requestBuilder(LaunchDbSystemRequest::builder)
.basePath("/20160918")
.appendPathParam("dbSystems")
.accept("application/json")
.appendHeader("opc-retry-token", request.getOpcRetryToken())
.hasBody()
.handleBody(
com.oracle.bmc.database.model.DbSystem.class,
LaunchDbSystemResponse.Builder::dbSystem)
.handleResponseHeaderString(
"opc-work-request-id", LaunchDbSystemResponse.Builder::opcWorkRequestId)
.handleResponseHeaderString("etag", LaunchDbSystemResponse.Builder::etag)
.handleResponseHeaderString(
"opc-request-id", LaunchDbSystemResponse.Builder::opcRequestId)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future listApplicationVips(
ListApplicationVipsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListApplicationVipsRequest, ListApplicationVipsResponse>
handler) {
Objects.requireNonNull(request.getCompartmentId(), "compartmentId is required");
Objects.requireNonNull(request.getCloudVmClusterId(), "cloudVmClusterId is required");
return clientCall(request, ListApplicationVipsResponse::builder)
.logger(LOG, "listApplicationVips")
.serviceDetails(
"Database",
"ListApplicationVips",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/ApplicationVipSummary/ListApplicationVips")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListApplicationVipsRequest::builder)
.basePath("/20160918")
.appendPathParam("applicationVip")
.appendQueryParam("compartmentId", request.getCompartmentId())
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.appendQueryParam("cloudVmClusterId", request.getCloudVmClusterId())
.appendEnumQueryParam("sortOrder", request.getSortOrder())
.appendEnumQueryParam("sortBy", request.getSortBy())
.appendEnumQueryParam("lifecycleState", request.getLifecycleState())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBodyList(
com.oracle.bmc.database.model.ApplicationVipSummary.class,
ListApplicationVipsResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id", ListApplicationVipsResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page", ListApplicationVipsResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousContainerDatabaseDataguardAssociations(
ListAutonomousContainerDatabaseDataguardAssociationsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousContainerDatabaseDataguardAssociationsRequest,
ListAutonomousContainerDatabaseDataguardAssociationsResponse>
handler) {
Validate.notBlank(
request.getAutonomousContainerDatabaseId(),
"autonomousContainerDatabaseId must not be blank");
return clientCall(
request,
ListAutonomousContainerDatabaseDataguardAssociationsResponse::builder)
.logger(LOG, "listAutonomousContainerDatabaseDataguardAssociations")
.serviceDetails(
"Database",
"ListAutonomousContainerDatabaseDataguardAssociations",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabaseDataguardAssociation/ListAutonomousContainerDatabaseDataguardAssociations")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(
ListAutonomousContainerDatabaseDataguardAssociationsRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendPathParam(request.getAutonomousContainerDatabaseId())
.appendPathParam("autonomousContainerDatabaseDataguardAssociations")
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.accept("application/json")
.handleBodyList(
com.oracle.bmc.database.model
.AutonomousContainerDatabaseDataguardAssociation.class,
ListAutonomousContainerDatabaseDataguardAssociationsResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousContainerDatabaseDataguardAssociationsResponse.Builder
::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
ListAutonomousContainerDatabaseDataguardAssociationsResponse.Builder
::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousContainerDatabaseVersions(
ListAutonomousContainerDatabaseVersionsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousContainerDatabaseVersionsRequest,
ListAutonomousContainerDatabaseVersionsResponse>
handler) {
Objects.requireNonNull(request.getCompartmentId(), "compartmentId is required");
Objects.requireNonNull(request.getServiceComponent(), "serviceComponent is required");
return clientCall(request, ListAutonomousContainerDatabaseVersionsResponse::builder)
.logger(LOG, "listAutonomousContainerDatabaseVersions")
.serviceDetails(
"Database",
"ListAutonomousContainerDatabaseVersions",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabaseVersionSummary/ListAutonomousContainerDatabaseVersions")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousContainerDatabaseVersionsRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabaseVersions")
.appendQueryParam("compartmentId", request.getCompartmentId())
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.appendEnumQueryParam("sortOrder", request.getSortOrder())
.appendEnumQueryParam("serviceComponent", request.getServiceComponent())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBodyList(
com.oracle.bmc.database.model.AutonomousContainerDatabaseVersionSummary
.class,
ListAutonomousContainerDatabaseVersionsResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousContainerDatabaseVersionsResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
ListAutonomousContainerDatabaseVersionsResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousContainerDatabases(
ListAutonomousContainerDatabasesRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousContainerDatabasesRequest,
ListAutonomousContainerDatabasesResponse>
handler) {
Objects.requireNonNull(request.getCompartmentId(), "compartmentId is required");
return clientCall(request, ListAutonomousContainerDatabasesResponse::builder)
.logger(LOG, "listAutonomousContainerDatabases")
.serviceDetails(
"Database",
"ListAutonomousContainerDatabases",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousContainerDatabase/ListAutonomousContainerDatabases")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousContainerDatabasesRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousContainerDatabases")
.appendQueryParam("compartmentId", request.getCompartmentId())
.appendQueryParam(
"autonomousExadataInfrastructureId",
request.getAutonomousExadataInfrastructureId())
.appendQueryParam("autonomousVmClusterId", request.getAutonomousVmClusterId())
.appendEnumQueryParam("infrastructureType", request.getInfrastructureType())
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.appendEnumQueryParam("sortBy", request.getSortBy())
.appendEnumQueryParam("sortOrder", request.getSortOrder())
.appendEnumQueryParam("lifecycleState", request.getLifecycleState())
.appendQueryParam("availabilityDomain", request.getAvailabilityDomain())
.appendQueryParam("displayName", request.getDisplayName())
.appendQueryParam(
"serviceLevelAgreementType", request.getServiceLevelAgreementType())
.appendQueryParam(
"cloudAutonomousVmClusterId", request.getCloudAutonomousVmClusterId())
.accept("application/json")
.handleBodyList(
com.oracle.bmc.database.model.AutonomousContainerDatabaseSummary.class,
ListAutonomousContainerDatabasesResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousContainerDatabasesResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
ListAutonomousContainerDatabasesResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousDatabaseBackups(
ListAutonomousDatabaseBackupsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousDatabaseBackupsRequest,
ListAutonomousDatabaseBackupsResponse>
handler) {
return clientCall(request, ListAutonomousDatabaseBackupsResponse::builder)
.logger(LOG, "listAutonomousDatabaseBackups")
.serviceDetails(
"Database",
"ListAutonomousDatabaseBackups",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseBackup/ListAutonomousDatabaseBackups")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousDatabaseBackupsRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseBackups")
.appendQueryParam("autonomousDatabaseId", request.getAutonomousDatabaseId())
.appendQueryParam("compartmentId", request.getCompartmentId())
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.appendEnumQueryParam("sortBy", request.getSortBy())
.appendEnumQueryParam("sortOrder", request.getSortOrder())
.appendEnumQueryParam("lifecycleState", request.getLifecycleState())
.appendQueryParam("displayName", request.getDisplayName())
.appendQueryParam("type", request.getType())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBodyList(
com.oracle.bmc.database.model.AutonomousDatabaseBackupSummary.class,
ListAutonomousDatabaseBackupsResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousDatabaseBackupsResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page", ListAutonomousDatabaseBackupsResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousDatabaseCharacterSets(
ListAutonomousDatabaseCharacterSetsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousDatabaseCharacterSetsRequest,
ListAutonomousDatabaseCharacterSetsResponse>
handler) {
return clientCall(request, ListAutonomousDatabaseCharacterSetsResponse::builder)
.logger(LOG, "listAutonomousDatabaseCharacterSets")
.serviceDetails(
"Database",
"ListAutonomousDatabaseCharacterSets",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseCharacterSets/ListAutonomousDatabaseCharacterSets")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousDatabaseCharacterSetsRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseCharacterSets")
.appendQueryParam("isShared", request.getIsShared())
.appendQueryParam("isDedicated", request.getIsDedicated())
.appendEnumQueryParam("characterSetType", request.getCharacterSetType())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBodyList(
com.oracle.bmc.database.model.AutonomousDatabaseCharacterSets.class,
ListAutonomousDatabaseCharacterSetsResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousDatabaseCharacterSetsResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
ListAutonomousDatabaseCharacterSetsResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousDatabaseClones(
ListAutonomousDatabaseClonesRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousDatabaseClonesRequest,
ListAutonomousDatabaseClonesResponse>
handler) {
Objects.requireNonNull(request.getCompartmentId(), "compartmentId is required");
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, ListAutonomousDatabaseClonesResponse::builder)
.logger(LOG, "listAutonomousDatabaseClones")
.serviceDetails(
"Database",
"ListAutonomousDatabaseClones",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ListAutonomousDatabaseClones")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousDatabaseClonesRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("clones")
.appendQueryParam("compartmentId", request.getCompartmentId())
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.appendEnumQueryParam("sortOrder", request.getSortOrder())
.appendQueryParam("displayName", request.getDisplayName())
.appendEnumQueryParam("lifecycleState", request.getLifecycleState())
.appendEnumQueryParam("sortBy", request.getSortBy())
.appendEnumQueryParam("cloneType", request.getCloneType())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBodyList(
com.oracle.bmc.database.model.AutonomousDatabaseSummary.class,
ListAutonomousDatabaseClonesResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousDatabaseClonesResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page", ListAutonomousDatabaseClonesResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousDatabaseDataguardAssociations(
ListAutonomousDatabaseDataguardAssociationsRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousDatabaseDataguardAssociationsRequest,
ListAutonomousDatabaseDataguardAssociationsResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, ListAutonomousDatabaseDataguardAssociationsResponse::builder)
.logger(LOG, "listAutonomousDatabaseDataguardAssociations")
.serviceDetails(
"Database",
"ListAutonomousDatabaseDataguardAssociations",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseDataguardAssociation/ListAutonomousDatabaseDataguardAssociations")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousDatabaseDataguardAssociationsRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("autonomousDatabaseDataguardAssociations")
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.accept("application/json")
.handleBodyList(
com.oracle.bmc.database.model.AutonomousDatabaseDataguardAssociation.class,
ListAutonomousDatabaseDataguardAssociationsResponse.Builder::items)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousDatabaseDataguardAssociationsResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
ListAutonomousDatabaseDataguardAssociationsResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousDatabasePeers(
ListAutonomousDatabasePeersRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousDatabasePeersRequest,
ListAutonomousDatabasePeersResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, ListAutonomousDatabasePeersResponse::builder)
.logger(LOG, "listAutonomousDatabasePeers")
.serviceDetails(
"Database",
"ListAutonomousDatabasePeers",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ListAutonomousDatabasePeers")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousDatabasePeersRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("peers")
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabasePeerCollection.class,
ListAutonomousDatabasePeersResponse.Builder
::autonomousDatabasePeerCollection)
.handleResponseHeaderString(
"opc-request-id", ListAutonomousDatabasePeersResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page", ListAutonomousDatabasePeersResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousDatabaseRefreshableClones(
ListAutonomousDatabaseRefreshableClonesRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousDatabaseRefreshableClonesRequest,
ListAutonomousDatabaseRefreshableClonesResponse>
handler) {
Validate.notBlank(
request.getAutonomousDatabaseId(), "autonomousDatabaseId must not be blank");
return clientCall(request, ListAutonomousDatabaseRefreshableClonesResponse::builder)
.logger(LOG, "listAutonomousDatabaseRefreshableClones")
.serviceDetails(
"Database",
"ListAutonomousDatabaseRefreshableClones",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabase/ListAutonomousDatabaseRefreshableClones")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousDatabaseRefreshableClonesRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabases")
.appendPathParam(request.getAutonomousDatabaseId())
.appendPathParam("refreshableClones")
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.RefreshableCloneCollection.class,
ListAutonomousDatabaseRefreshableClonesResponse.Builder
::refreshableCloneCollection)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousDatabaseRefreshableClonesResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
ListAutonomousDatabaseRefreshableClonesResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future
listAutonomousDatabaseSoftwareImages(
ListAutonomousDatabaseSoftwareImagesRequest request,
final com.oracle.bmc.responses.AsyncHandler<
ListAutonomousDatabaseSoftwareImagesRequest,
ListAutonomousDatabaseSoftwareImagesResponse>
handler) {
Objects.requireNonNull(request.getCompartmentId(), "compartmentId is required");
Objects.requireNonNull(request.getImageShapeFamily(), "imageShapeFamily is required");
return clientCall(request, ListAutonomousDatabaseSoftwareImagesResponse::builder)
.logger(LOG, "listAutonomousDatabaseSoftwareImages")
.serviceDetails(
"Database",
"ListAutonomousDatabaseSoftwareImages",
"https://docs.oracle.com/iaas/api/#/en/database/20160918/AutonomousDatabaseSoftwareImage/ListAutonomousDatabaseSoftwareImages")
.method(com.oracle.bmc.http.client.Method.GET)
.requestBuilder(ListAutonomousDatabaseSoftwareImagesRequest::builder)
.basePath("/20160918")
.appendPathParam("autonomousDatabaseSoftwareImages")
.appendQueryParam("compartmentId", request.getCompartmentId())
.appendQueryParam("limit", request.getLimit())
.appendQueryParam("page", request.getPage())
.appendEnumQueryParam("sortOrder", request.getSortOrder())
.appendEnumQueryParam("sortBy", request.getSortBy())
.appendEnumQueryParam("lifecycleState", request.getLifecycleState())
.appendQueryParam("displayName", request.getDisplayName())
.appendEnumQueryParam("imageShapeFamily", request.getImageShapeFamily())
.accept("application/json")
.appendHeader("opc-request-id", request.getOpcRequestId())
.handleBody(
com.oracle.bmc.database.model.AutonomousDatabaseSoftwareImageCollection
.class,
ListAutonomousDatabaseSoftwareImagesResponse.Builder
::autonomousDatabaseSoftwareImageCollection)
.handleResponseHeaderString(
"opc-request-id",
ListAutonomousDatabaseSoftwareImagesResponse.Builder::opcRequestId)
.handleResponseHeaderString(
"opc-next-page",
ListAutonomousDatabaseSoftwareImagesResponse.Builder::opcNextPage)
.callAsync(handler);
}
@Override
public java.util.concurrent.Future