private static RegisterResourceRequest CreateRegisterResourceRequest(string type, string name, bool custom, ResourceOptions options)
{
var customOpts = options as CustomResourceOptions;
var deleteBeforeReplace = customOpts?.DeleteBeforeReplace;
var request = new RegisterResourceRequest()
{
Type = type,
Name = name,
Custom = custom,
Protect = options.Protect ?? false,
Version = options.Version ?? "",
ImportId = customOpts?.ImportId ?? "",
AcceptSecrets = true,
DeleteBeforeReplace = deleteBeforeReplace ?? false,
DeleteBeforeReplaceDefined = deleteBeforeReplace != null,
CustomTimeouts = new RegisterResourceRequest.Types.CustomTimeouts
{
Create = TimeoutString(options.CustomTimeouts?.Create),
Delete = TimeoutString(options.CustomTimeouts?.Delete),
Update = TimeoutString(options.CustomTimeouts?.Update),
},
};
if (customOpts != null)
{
request.AdditionalSecretOutputs.AddRange(customOpts.AdditionalSecretOutputs);
}
request.IgnoreChanges.AddRange(options.IgnoreChanges);
return(request);
}
/// <summary>
/// Registers the resource as managed by the Data Catalog.
///
///
/// <para>
/// To add or update data, Lake Formation needs read/write access to the chosen Amazon
/// S3 path. Choose a role that you know has permission to do this, or choose the AWSServiceRoleForLakeFormationDataAccess
/// service-linked role. When you register the first Amazon S3 path, the service-linked
/// role and a new inline policy are created on your behalf. Lake Formation adds the first
/// path to the inline policy and attaches it to the service-linked role. When you register
/// subsequent paths, Lake Formation adds the path to the existing policy.
/// </para>
///
/// <para>
/// The following request registers a new location and gives AWS Lake Formation permission
/// to use the service-linked role to access that location.
/// </para>
///
/// <para>
/// <code>ResourceArn = arn:aws:s3:::my-bucket UseServiceLinkedRole = true</code>
/// </para>
///
/// <para>
/// If <code>UseServiceLinkedRole</code> is not set to true, you must provide or set the
/// <code>RoleArn</code>:
/// </para>
///
/// <para>
/// <code>arn:aws:iam::12345:role/my-data-access-role</code>
/// </para>
/// </summary>
/// <param name="request">Container for the necessary parameters to execute the RegisterResource service method.</param>
/// <param name="cancellationToken">
/// A cancellation token that can be used by other objects or threads to receive notice of cancellation.
/// </param>
///
/// <returns>The response from the RegisterResource service method, as returned by LakeFormation.</returns>
/// <exception cref="Amazon.LakeFormation.Model.AlreadyExistsException">
/// A resource to be created or added already exists.
/// </exception>
/// <exception cref="Amazon.LakeFormation.Model.InternalServiceException">
/// An internal service error occurred.
/// </exception>
/// <exception cref="Amazon.LakeFormation.Model.InvalidInputException">
/// The input provided was not valid.
/// </exception>
/// <exception cref="Amazon.LakeFormation.Model.OperationTimeoutException">
/// The operation timed out.
/// </exception>
/// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/lakeformation-2017-03-31/RegisterResource">REST API Reference for RegisterResource Operation</seealso>
public virtual Task <RegisterResourceResponse> RegisterResourceAsync(RegisterResourceRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken))
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterResourceResponseUnmarshaller.Instance;
return(InvokeAsync <RegisterResourceResponse>(request, options, cancellationToken));
}
internal virtual RegisterResourceResponse RegisterResource(RegisterResourceRequest request)
{
var options = new InvokeOptions();
options.RequestMarshaller = RegisterResourceRequestMarshaller.Instance;
options.ResponseUnmarshaller = RegisterResourceResponseUnmarshaller.Instance;
return(Invoke <RegisterResourceResponse>(request, options));
}
private static void PopulateRequest(RegisterResourceRequest request, PrepareResult prepareResult)
{
request.Object = prepareResult.SerializedProps;
request.Parent = prepareResult.ParentUrn;
request.Provider = prepareResult.ProviderRef;
request.Aliases.AddRange(prepareResult.Aliases);
request.Dependencies.AddRange(prepareResult.AllDirectDependencyURNs);
foreach (var(key, resourceURNs) in prepareResult.PropertyToDirectDependencyURNs)
{
var deps = new RegisterResourceRequest.Types.PropertyDependencies();
deps.Urns.AddRange(resourceURNs);
request.PropertyDependencies.Add(key, deps);
}
}
public async Task <RegisterResourceResponse> RegisterResourceAsync(Resource resource, RegisterResourceRequest request) => await this._client.RegisterResourceAsync(request);
public async Task <RegisterResourceResponse> RegisterResourceAsync(Resource resource, RegisterResourceRequest request)
{
lock (this.Resources)
{
this.Resources.Add(resource);
}
if (request.Type == Stack._rootPulumiStackTypeName)
{
return(new RegisterResourceResponse
{
Urn = NewUrn(request.Parent, request.Type, request.Name),
Object = new Struct(),
});
}
var(id, state) = await _mocks.NewResourceAsync(new MockResourceArgs
{
Type = request.Type,
Name = request.Name,
Inputs = ToDictionary(request.Object),
Provider = request.Provider,
Id = request.ImportId,
}).ConfigureAwait(false);
var urn = NewUrn(request.Parent, request.Type, request.Name);
var serializedState = await SerializeToDictionary(state).ConfigureAwait(false);
lock (_registeredResources)
{
var builder = ImmutableDictionary.CreateBuilder <string, object>();
builder.Add("urn", urn);
builder.Add("id", id ?? request.ImportId);
builder.Add("state", serializedState);
_registeredResources[urn] = builder.ToImmutable();
}
return(new RegisterResourceResponse
{
Id = id ?? request.ImportId,
Urn = urn,
Object = Serializer.CreateStruct(serializedState),
});
}
public async Task <RegisterResourceResponse> RegisterResourceAsync(Resource resource, RegisterResourceRequest request)
{
if (request.Type == Stack._rootPulumiStackTypeName)
{
return(new RegisterResourceResponse
{
Urn = NewUrn(request.Parent, request.Type, request.Name),
});
}
var(id, state) = await _mocks.NewResourceAsync(request.Type, request.Name, ToDictionary(request.Object),
request.Provider, request.ImportId).ConfigureAwait(false);
lock (this.Resources)
{
this.Resources.Add(resource);
}
return(new RegisterResourceResponse
{
Id = id ?? request.ImportId,
Urn = NewUrn(request.Parent, request.Type, request.Name),
Object = await SerializeAsync(state).ConfigureAwait(false)
});
}
