com.microsoft.azure.CloudException Java Examples

/**
 * Runs the action and assert that action throws CloudException with CloudError.Code
 * property set to 'PreconditionFailed'.
 *
 * @param action action to run
 */
private void ensureETagExceptionIsThrown(final Action0 action) {
    boolean isCloudExceptionThrown = false;
    boolean isCloudErrorSet = false;
    boolean isPreconditionFailedCodeSet = false;
    try {
        action.call();
    } catch (CloudException exception) {
        isCloudExceptionThrown = true;
        CloudError cloudError = exception.body();
        if (cloudError != null) {
            isCloudErrorSet = true;
            isPreconditionFailedCodeSet = cloudError.code().contains("PreconditionFailed");
        }
    }
    Assert.assertTrue("Expected CloudException is not thrown", isCloudExceptionThrown);
    Assert.assertTrue("Expected CloudError property is not set in CloudException", isCloudErrorSet);
    Assert.assertTrue("Expected PreconditionFailed code is not set indicating ETag concurrency check failure", isPreconditionFailedCodeSet);
}
 

private <T> Optional<String> handleDeleteErrors(Consumer<String> deleteConsumer, String resourceType, String resourceId, boolean cancelException) {
    try {
        LOGGER.debug("Deleteing {} {}", resourceType, resourceId);
        deleteConsumer.accept(resourceId);
        return Optional.empty();
    } catch (CloudException e) {
        LOGGER.warn("Exception during resource delete", e);
        Optional<String> errorMessageOptional = getErrorMessage(resourceType, resourceId, e);
        if (errorMessageOptional.isEmpty()) {
            return Optional.empty();
        }
        if (cancelException) {
            LOGGER.warn(errorMessageOptional.get());
            LOGGER.warn("{} {} deletion failed, continuing because termination is forced", resourceType, resourceId);
            return errorMessageOptional;
        } else {
            LOGGER.warn(errorMessageOptional.get());
            throw new CloudConnectorException(errorMessageOptional.get(), e);
        }
    }
}
 

@Override
public void validate(ConfigProblemSetBuilder p, AzureBaseImage n) {

  AzureCredentials credentials =
      credentialsList.get(
          0); // The first credentials should be fine since we're validating against public images
  AzureComputeClient computeClient = credentials.getComputeClient();
  AzureBaseImage.AzureOperatingSystemSettings osSettings = n.getBaseImage();
  String version = osSettings.getVersion();

  try {
    computeClient.getVMImage(
        "westus", osSettings.getPublisher(), osSettings.getOffer(), osSettings.getSku(), version);
  } catch (Exception e) {
    String message =
        e instanceof CloudException
            ? CloudException.class.cast(e).body().message()
            : e.getMessage();
    p.addProblem(
            Problem.Severity.WARNING,
            "Error getting image '" + n.getNodeName() + "' in region 'westus': " + message)
        .setRemediation(
            "If you are not targeting 'westus' and know the image is available in other regions, you can ignore this warning and select a different region when baking images. See available images here: https://aka.ms/azspinimage");
  }
}
 

private ServiceResponse<Void> beginPowerOffDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<Void>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<Void> beginDeleteDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<Void>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .register(204, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<VaultInner> beginCreateOrUpdateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<VaultInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<VaultInner>() { }.getType())
            .register(201, new TypeToken<VaultInner>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<Void> deleteDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<Void>() { }.getType())
            .register(204, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<EffectiveNetworkSecurityGroupListResultInner> beginListEffectiveNetworkSecurityGroupsDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<EffectiveNetworkSecurityGroupListResultInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<EffectiveNetworkSecurityGroupListResultInner>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<FailoverGroupInner> beginCreateOrUpdateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<FailoverGroupInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<FailoverGroupInner>() { }.getType())
            .register(201, new TypeToken<FailoverGroupInner>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<RestorePointInner> beginCreateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<RestorePointInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<RestorePointInner>() { }.getType())
            .register(201, new TypeToken<RestorePointInner>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<RegistryInner> beginUpdateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<RegistryInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<RegistryInner>() { }.getType())
            .register(201, new TypeToken<RegistryInner>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<WorkspaceInner> beginCreateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<WorkspaceInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<WorkspaceInner>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<Void> beginDeleteDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<Void>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .register(204, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<Void> beginStartDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<Void>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<Void> beginCreateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<Void>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<ThroughputSettingsGetResultsInner> beginUpdateCassandraTableThroughputDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<ThroughputSettingsGetResultsInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<ThroughputSettingsGetResultsInner>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<DatabaseInner> beginUpdateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<DatabaseInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<DatabaseInner>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<ExpressRouteCircuitAuthorizationInner> beginCreateOrUpdateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<ExpressRouteCircuitAuthorizationInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<ExpressRouteCircuitAuthorizationInner>() { }.getType())
            .register(201, new TypeToken<ExpressRouteCircuitAuthorizationInner>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<OpenShiftManagedClusterInner> beginCreateOrUpdateDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<OpenShiftManagedClusterInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<OpenShiftManagedClusterInner>() { }.getType())
            .register(201, new TypeToken<OpenShiftManagedClusterInner>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<CassandraKeyspaceGetResultsInner> beginCreateUpdateCassandraKeyspaceDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<CassandraKeyspaceGetResultsInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<CassandraKeyspaceGetResultsInner>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<Void> beginDeleteDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<Void, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<Void>() { }.getType())
            .register(202, new TypeToken<Void>() { }.getType())
            .register(204, new TypeToken<Void>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl1<FailoverGroupInner>> listByServerDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl1<FailoverGroupInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl1<FailoverGroupInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl1<SensitivityLabelInner>> listCurrentByDatabaseNextDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl1<SensitivityLabelInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl1<SensitivityLabelInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl1<GalleryApplicationVersionInner>> listByGalleryApplicationNextDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl1<GalleryApplicationVersionInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl1<GalleryApplicationVersionInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl<SecurityRuleInner>> listNextDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl<SecurityRuleInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl<SecurityRuleInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl<RegistryInner>> listDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl<RegistryInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl<RegistryInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl<AutoApprovedPrivateLinkServiceInner>> listAutoApprovedPrivateLinkServicesNextDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl<AutoApprovedPrivateLinkServiceInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl<AutoApprovedPrivateLinkServiceInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<SensitivityLabelInner> getDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<SensitivityLabelInner, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<SensitivityLabelInner>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl1<DomainInner>> listDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl1<DomainInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl1<DomainInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}
 

private ServiceResponse<PageImpl<FileServerInner>> listByWorkspaceNextDelegate(Response<ResponseBody> response) throws CloudException, IOException, IllegalArgumentException {
    return this.client.restClient().responseBuilderFactory().<PageImpl<FileServerInner>, CloudException>newInstance(this.client.serializerAdapter())
            .register(200, new TypeToken<PageImpl<FileServerInner>>() { }.getType())
            .registerError(CloudException.class)
            .build(response);
}