/// <summary> /// Returns the connection ARN and details such as status, owner, and provider type. /// </summary> /// <param name="request">Container for the necessary parameters to execute the GetConnection 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 GetConnection service method, as returned by CodeStarconnections.</returns> /// <exception cref="Amazon.CodeStarconnections.Model.ResourceNotFoundException"> /// Resource not found. Verify the connection resource ARN and try again. /// </exception> /// <exception cref="Amazon.CodeStarconnections.Model.ResourceUnavailableException"> /// Resource not found. Verify the ARN for the host resource and try again. /// </exception> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/codestar-connections-2019-12-01/GetConnection">REST API Reference for GetConnection Operation</seealso> public virtual Task<GetConnectionResponse> GetConnectionAsync(GetConnectionRequest request, System.Threading.CancellationToken cancellationToken = default(CancellationToken)) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionResponseUnmarshaller.Instance; return InvokeAsync<GetConnectionResponse>(request, options, cancellationToken); }
internal virtual GetConnectionResponse GetConnection(GetConnectionRequest request) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionResponseUnmarshaller.Instance; return Invoke<GetConnectionResponse>(request, options); }
public Handle_Returns ( WebApplicationFactory <Startup> aWebApplicationFactory, JsonSerializerSettings aJsonSerializerSettings ) : base(aWebApplicationFactory, aJsonSerializerSettings) { GetConnectionRequest = CreateValidGetConnectionRequest(); }
/// <summary> /// Initiates the asynchronous execution of the GetConnection operation. /// </summary> /// /// <param name="request">Container for the necessary parameters to execute the GetConnection operation on AmazonApiGatewayManagementApiClient.</param> /// <param name="callback">An AsyncCallback delegate that is invoked when the operation completes.</param> /// <param name="state">A user-defined state object that is passed to the callback procedure. Retrieve this object from within the callback /// procedure using the AsyncState property.</param> /// /// <returns>An IAsyncResult that can be used to poll or wait for results, or both; this value is also needed when invoking EndGetConnection /// operation.</returns> /// <seealso href="http://docs.aws.amazon.com/goto/WebAPI/apigatewaymanagementapi-2018-11-29/GetConnection">REST API Reference for GetConnection Operation</seealso> public virtual IAsyncResult BeginGetConnection(GetConnectionRequest request, AsyncCallback callback, object state) { var options = new InvokeOptions(); options.RequestMarshaller = GetConnectionRequestMarshaller.Instance; options.ResponseUnmarshaller = GetConnectionResponseUnmarshaller.Instance; return(BeginInvoke(request, options, callback, state)); }
/// <summary> /// Creates a waiter using the provided configuration. /// </summary> /// <param name="request">Request to send.</param> /// <param name="config">Wait Configuration</param> /// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param> /// <returns>a new Oci.common.Waiter instance</returns> public Waiter <GetConnectionRequest, GetConnectionResponse> ForConnection(GetConnectionRequest request, WaiterConfiguration config, params LifecycleStates[] targetStates) { var agent = new WaiterAgent <GetConnectionRequest, GetConnectionResponse>( request, request => client.GetConnection(request), response => targetStates.Contains(response.Connection.LifecycleState.Value), targetStates.Contains(LifecycleStates.Deleted) ); return(new Waiter <GetConnectionRequest, GetConnectionResponse>(config, agent)); }
/// <summary>Snippet for GetConnection</summary> /// <remarks> /// This snippet has been automatically generated for illustrative purposes only. /// It may require modifications to work in your environment. /// </remarks> public void GetConnectionRequestObject() { // Create client ConnectionServiceClient connectionServiceClient = ConnectionServiceClient.Create(); // Initialize request argument(s) GetConnectionRequest request = new GetConnectionRequest { ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"), }; // Make the request Connection response = connectionServiceClient.GetConnection(request); }
/// <summary>Snippet for GetConnectionAsync</summary> public async Task GetConnectionRequestObjectAsync() { // Snippet: GetConnectionAsync(GetConnectionRequest, CallSettings) // Additional: GetConnectionAsync(GetConnectionRequest, CancellationToken) // Create client ConnectionServiceClient connectionServiceClient = await ConnectionServiceClient.CreateAsync(); // Initialize request argument(s) GetConnectionRequest request = new GetConnectionRequest { ConnectionName = ConnectionName.FromProjectLocationConnection("[PROJECT]", "[LOCATION]", "[CONNECTION]"), }; // Make the request Connection response = await connectionServiceClient.GetConnectionAsync(request); // End snippet }
/// <summary> /// Gets an existing APConnection by type and id. /// </summary> /// <param name="type">The type (relation name) of the connection.</param> /// <param name="id">The id of the connection.</param> /// <param name="options">Request specific api options. These will override the global settings for the app for this request.</param> /// <returns>The matching APConnection object.</returns> public async static Task <APConnection> GetAsync(string relation, string id, ApiOptions options = null) { var request = new GetConnectionRequest { Relation = relation, Id = id }; ApiOptions.Apply(request, options); var response = await request.ExecuteAsync(); if (response.Status.IsSuccessful == false) { throw response.Status.ToFault(); } else { return(response.Connection); } }
internal static void ValidateGetConnectionResponse(GetConnectionRequest aGetConnectionRequest, GetConnectionResponse aGetConnectionResponse) { aGetConnectionResponse.CorrelationId.Should().Be(aGetConnectionRequest.CorrelationId); aGetConnectionResponse.ConnectionRecord.Should().NotBeNull(); aGetConnectionResponse.ConnectionRecord.Alias.Name.Should().BeNull(); aGetConnectionResponse.ConnectionRecord.Alias.ImageUrl.Should().BeNull(); aGetConnectionResponse.ConnectionRecord.CreatedAtUtc.HasValue.Should().BeTrue(); aGetConnectionResponse.ConnectionRecord.Endpoint.Should().BeNull(); aGetConnectionResponse.ConnectionRecord.MultiPartyInvitation.Should().BeFalse(); aGetConnectionResponse.ConnectionRecord.Id.Should().Be(aGetConnectionRequest.ConnectionId); aGetConnectionResponse.ConnectionRecord.MyDid.Should().BeNull(); aGetConnectionResponse.ConnectionRecord.MyVk.Should().BeNull(); aGetConnectionResponse.ConnectionRecord.State.Should().Be(ConnectionState.Invited); aGetConnectionResponse.ConnectionRecord.TheirDid.Should().BeNull(); aGetConnectionResponse.ConnectionRecord.TheirVk.Should().BeNull(); aGetConnectionResponse.ConnectionRecord.TypeName.Should().Be("AF.ConnectionRecord"); aGetConnectionResponse.ConnectionRecord.UpdatedAtUtc.HasValue.Should().BeFalse(); }
private void HandleOutput(GetConnectionRequest request) { var waiterConfig = new WaiterConfiguration { MaxAttempts = MaxWaitAttempts, GetNextDelayInSeconds = (_) => WaitIntervalSeconds }; switch (ParameterSetName) { case LifecycleStateParamSet: response = client.Waiters.ForConnection(request, waiterConfig, WaitForLifecycleState).Execute(); break; case Default: response = client.GetConnection(request).GetAwaiter().GetResult(); break; } WriteOutput(response, response.Connection); }
protected override void ProcessRecord() { base.ProcessRecord(); GetConnectionRequest request; try { request = new GetConnectionRequest { ConnectionId = ConnectionId, OpcRequestId = OpcRequestId }; HandleOutput(request); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
protected override void ProcessRecord() { base.ProcessRecord(); GetConnectionRequest request; try { request = new GetConnectionRequest { WorkspaceId = WorkspaceId, ConnectionKey = ConnectionKey, OpcRequestId = OpcRequestId }; response = client.GetConnection(request).GetAwaiter().GetResult(); WriteOutput(response, response.Connection); FinishProcessing(response); } catch (Exception ex) { TerminatingErrorDuringExecution(ex); } }
/// <summary> /// Creates a waiter using default wait configuration. /// </summary> /// <param name="request">Request to send.</param> /// <param name="targetStates">Desired resource states. If multiple states are provided then the waiter will return once the resource reaches any of the provided states</param> /// <returns>a new Oci.common.Waiter instance</returns> public Waiter <GetConnectionRequest, GetConnectionResponse> ForConnection(GetConnectionRequest request, params LifecycleStates[] targetStates) { return(this.ForConnection(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates)); }