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) }); }