/// <summary>
/// Gets detailed information about a stream, including the number of partitions.
/// </summary>
/// <param name="request">The request object containing the details to send. Required.</param>
/// <param name="retryConfiguration">The retry configuration that will be used by to send this request. Optional.</param>
/// <param name="cancellationToken">The cancellation token to cancel this operation. Optional.</param>
/// <returns>A response object containing details about the completed operation</returns>
/// <example>Click <a href="https://docs.cloud.oracle.com/en-us/iaas/tools/dot-net-examples/latest/streaming/GetStream.cs.html">here</a> to see an example of how to use GetStream API.</example>
public async Task <GetStreamResponse> GetStream(GetStreamRequest request, RetryConfiguration retryConfiguration = null, CancellationToken cancellationToken = default)
{
logger.Trace("Called getStream");
Uri uri = new Uri(this.restClient.GetEndpoint(), System.IO.Path.Combine(basePathWithoutHost, "/streams/{streamId}".Trim('/')));
HttpMethod method = new HttpMethod("GET");
HttpRequestMessage requestMessage = Converter.ToHttpRequestMessage(uri, method, request);
requestMessage.Headers.Add("Accept", "application/json");
GenericRetrier retryingClient = Retrier.GetPreferredRetrier(retryConfiguration, this.retryConfiguration);
HttpResponseMessage responseMessage;
try
{
if (retryingClient != null)
{
responseMessage = await retryingClient.MakeRetryingCall(this.restClient.HttpSend, requestMessage, cancellationToken).ConfigureAwait(false);
}
else
{
responseMessage = await this.restClient.HttpSend(requestMessage).ConfigureAwait(false);
}
this.restClient.CheckHttpResponseMessage(requestMessage, responseMessage);
return(Converter.FromHttpResponseMessage <GetStreamResponse>(responseMessage));
}
catch (Exception e)
{
logger.Error($"GetStream failed with error: {e.Message}");
throw;
}
}
private static async Task <Stream> GetStream(StreamAdminClient adminClient, string streamId)
{
GetStreamRequest getStreamRequest = new GetStreamRequest
{
StreamId = streamId
};
GetStreamResponse getStreamResponse = await adminClient.GetStream(getStreamRequest);
return(getStreamResponse.Stream);
}
public static async Task MainNonRegionalClient()
{
logger.Info("Starting example");
var provider = new ConfigFileAuthenticationDetailsProvider("DEFAULT");
string compartmentId = Environment.GetEnvironmentVariable("OCI_COMPARTMENT_ID");
StreamAdminClient streamAdminClient = new StreamAdminClient(provider);
StreamClient streamClient = new StreamClient(provider);
string streamId = null;
try
{
Stream stream = await GetOrCreateStream(streamAdminClient, compartmentId, STREAM_NAME, PARTITIONS);
streamId = stream.Id;
// Streams are assigned a specific endpoint url based on where they are provisioned.
// Create a stream client using the provided message endpoint.
streamClient.SetEndpoint(stream.MessagesEndpoint);
// publish some messages to the stream
await PublishExampleMessages(streamClient, streamId);
// give the streaming service a second to propagate messages
await Task.Delay(1000);
// Use a cursor for getting messages
// A cursor can be created at a given partition/offset.
// This gives explicit offset management control to the consumer.
logger.Info("Starting a simple message loop with a partition cursor");
string partitionCursor = await GetCursorByPartition(streamClient, streamId, "0");
await SimpleMessageLoop(streamClient, streamId, partitionCursor);
}
catch (Exception e)
{
logger.Error($"NonRegional client example failed: {e}");
}
finally
{
// Cleanup; remember to delete streams which are not in use.
await DeleteStream(streamAdminClient, streamId);
// Stream deletion is an asynchronous operation, give it some time to complete.
GetStreamRequest getStreamRequest = new GetStreamRequest
{
StreamId = streamId
};
streamAdminClient.Waiters.ForStream(getStreamRequest, Stream.LifecycleStateEnum.Deleted).Execute();
streamAdminClient.Dispose();
logger.Info("End example");
}
}
/// <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 <GetStreamRequest, GetStreamResponse> ForStream(GetStreamRequest request, WaiterConfiguration config, params Stream.LifecycleStateEnum[] targetStates)
{
var agent = new WaiterAgent <GetStreamRequest, GetStreamResponse>(
request,
request => client.GetStream(request),
response => targetStates.Contains(response.Stream.LifecycleState.Value),
targetStates.Contains(Stream.LifecycleStateEnum.Deleted)
);
return(new Waiter <GetStreamRequest, GetStreamResponse>(config, agent));
}
private void HandleOutput(GetStreamRequest request)
{
var waiterConfig = new WaiterConfiguration
{
MaxAttempts = MaxWaitAttempts,
GetNextDelayInSeconds = (_) => WaitIntervalSeconds
};
switch (ParameterSetName)
{
case LifecycleStateParamSet:
response = client.Waiters.ForStream(request, waiterConfig, WaitForLifecycleState).Execute();
break;
case Default:
response = client.GetStream(request).GetAwaiter().GetResult();
break;
}
WriteOutput(response, response.Stream);
}
protected override void ProcessRecord()
{
base.ProcessRecord();
GetStreamRequest request;
try
{
request = new GetStreamRequest
{
StreamId = StreamId,
OpcRequestId = OpcRequestId
};
HandleOutput(request);
FinishProcessing(response);
}
catch (Exception ex)
{
TerminatingErrorDuringExecution(ex);
}
}
private static async Task DeleteStream(StreamAdminClient adminClient, String streamId)
{
logger.Info($"Deleting stream {streamId}");
DeleteStreamRequest deleteStreamRequest = new DeleteStreamRequest
{
StreamId = streamId
};
await adminClient.DeleteStream(deleteStreamRequest);
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetStreamRequest getStreamRequest = new GetStreamRequest
{
StreamId = streamId
};
adminClient.Waiters.ForStream(getStreamRequest, waiterConfiguration, Stream.LifecycleStateEnum.Deleted).Execute();
}
private static async Task <Stream> GetOrCreateStream(StreamAdminClient client, string compartmentId, string streamName, int partitions)
{
ListStreamsRequest listRequest = new ListStreamsRequest
{
CompartmentId = compartmentId,
LifecycleState = Stream.LifecycleStateEnum.Active,
Name = streamName
};
ListStreamsResponse listStreamsResponse = await client.ListStreams(listRequest);
if (listStreamsResponse.Items.Count != 0)
{
// if we find an active stream with the correct name, we'll use it.
logger.Info($"An active stream named {streamName} was found");
string streamId = listStreamsResponse.Items[0].Id;
return(await GetStream(client, streamId));
}
logger.Info($"No active stream named {streamName} was found; creating it now");
Stream createdStream = await CreateStream(client, compartmentId, streamName, partitions);
// GetStream provides details about a specific stream.
// Since stream creation is asynchronous; we need to wait for the stream to become active.
WaiterConfiguration waiterConfiguration = new WaiterConfiguration
{
MaxAttempts = 20,
GetNextDelayInSeconds = DelayStrategy.GetExponentialDelayInSeconds
};
GetStreamRequest streamRequest = new GetStreamRequest
{
StreamId = createdStream.Id
};
Stream activeStream = client.Waiters.ForStream(streamRequest, waiterConfiguration, Stream.LifecycleStateEnum.Active).Execute().Stream;
// Give a little time for the stream to be ready.
await Task.Delay(1000);
return(activeStream);
}
/// <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 <GetStreamRequest, GetStreamResponse> ForStream(GetStreamRequest request, params Stream.LifecycleStateEnum[] targetStates)
{
return(this.ForStream(request, WaiterConfiguration.DefaultWaiterConfiguration, targetStates));
}