public async Task SimpleOverview()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Sample: SimpleOverview
// First create a topic.
PublisherServiceApiClient publisherService = await PublisherServiceApiClient.CreateAsync();
TopicName topicName = new TopicName(projectId, topicId);
publisherService.CreateTopic(topicName);
// Subscribe to the topic.
SubscriberServiceApiClient subscriberService = await SubscriberServiceApiClient.CreateAsync();
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriberService.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
// Publish a message to the topic using PublisherClient.
PublisherClient publisher = await PublisherClient.CreateAsync(topicName);
// PublishAsync() has various overloads. Here we're using the string overload.
string messageId = await publisher.PublishAsync("Hello, Pubsub");
// PublisherClient instance should be shutdown after use.
// The TimeSpan specifies for how long to attempt to publish locally queued messages.
await publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
// Pull messages from the subscription using SimpleSubscriber.
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName);
List <PubsubMessage> receivedMessages = new List <PubsubMessage>();
// Start the subscriber listening for messages.
await subscriber.StartAsync((msg, cancellationToken) =>
{
receivedMessages.Add(msg);
Console.WriteLine($"Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}");
Console.WriteLine($"Text: '{msg.Data.ToStringUtf8()}'");
// Stop this subscriber after one message is received.
// This is non-blocking, and the returned Task may be awaited.
subscriber.StopAsync(TimeSpan.FromSeconds(15));
// Return Reply.Ack to indicate this message has been handled.
return(Task.FromResult(SubscriberClient.Reply.Ack));
});
// Tidy up by deleting the subscription and the topic.
subscriberService.DeleteSubscription(subscriptionName);
publisherService.DeleteTopic(topicName);
// End sample
Assert.Equal(1, receivedMessages.Count);
Assert.Equal("Hello, Pubsub", receivedMessages[0].Data.ToStringUtf8());
}
private async Task <string> PublishAsync <T>(TopicName topicName, string emulatorHostAndPort, T message)
{
PublisherClient publisher = await PublisherClient.CreateAsync(topicName,
new PublisherClient.ClientCreationSettings(null, null, ChannelCredentials.Insecure, emulatorHostAndPort));
// PublishAsync() has various overloads. Here we're using the string overload.
string messageId = await publisher.PublishAsync(serializer(message), System.Text.Encoding.UTF8);
// PublisherClient instance should be shutdown after use.
// The TimeSpan specifies for how long to attempt to publish locally queued messages.
await publisher.ShutdownAsync(TimeSpan.FromSeconds(15)); //?
return(messageId);
}
public async Task Write(string eventData, HttpContext context)
{
PublisherClient publisher = null;
foreach (var topicId in _topicIds)
{
var topicName = new TopicName(_projectId, topicId);
_logger.LogInformation($"Publishing to topic '{topicId}' with data '{eventData}");
publisher = await PublisherClient.CreateAsync(topicName);
await publisher.PublishAsync(eventData);
}
if (publisher != null)
{
await publisher.ShutdownAsync(TimeSpan.FromSeconds(10));
}
}
public async Task Write(object eventData, HttpContext context)
{
PublisherClient publisher = null;
foreach (var topicId in _topicIds)
{
var topicName = new TopicName(_projectId, topicId);
publisher = await PublisherClient.CreateAsync(topicName);
var message = JsonConvert.SerializeObject(eventData);
_logger.LogInformation($"Publishing to topic '{topicId}' with message '{message}'");
await publisher.PublishAsync(message);
}
if (publisher != null)
{
await publisher.ShutdownAsync(TimeSpan.FromSeconds(10));
}
}
public async Task ShutdownPublisherAsync(string topic, CancellationToken hardStopToken)
{
PublisherClient client = await TryGetPublisherClient(topic);
await client.ShutdownAsync(hardStopToken);
}
public async Task WithEmulatorAsync(string projectId, string topicId, string subscriptionId)
{
// Use EmulatorDetection.EmulatorOrProduction to create service clients that will
// that will connect to the PubSub emulator if the PUBSUB_EMULATOR_HOST environment
// variable is set, but will otherwise connect to the production environment.
// Create the PublisherServiceApiClient using the PublisherServiceApiClientBuilder
// and setting the EmulatorDection property.
PublisherServiceApiClient publisherService = await new PublisherServiceApiClientBuilder
{
EmulatorDetection = EmulatorDetection.EmulatorOrProduction
}.BuildAsync();
// Use the client as you'd normally do, to create a topic in this example.
TopicName topicName = new TopicName(projectId, topicId);
publisherService.CreateTopic(topicName);
// Create the SubscriberServiceApiClient using the SubscriberServiceApiClientBuilder
// and setting the EmulatorDection property.
SubscriberServiceApiClient subscriberService = await new SubscriberServiceApiClientBuilder
{
EmulatorDetection = EmulatorDetection.EmulatorOrProduction
}.BuildAsync();
// Use the client as you'd normally do, to create a subscription in this example.
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriberService.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
// Create the PublisherClient using PublisherClient.ClientCreationSettings
// and call the WithEmulatorDection method.
PublisherClient publisher = await PublisherClient.CreateAsync(
topicName,
new PublisherClient.ClientCreationSettings()
.WithEmulatorDetection(EmulatorDetection.EmulatorOrProduction));
// Use the client as you'd normally do, to send a message in this example.
await publisher.PublishAsync("Hello, Pubsub");
await publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
// Create the SubscriberClient using SubscriberClient.ClientCreationSettings
// and call the WithEmulatorDection method.
SubscriberClient subscriber = await SubscriberClient.CreateAsync(
subscriptionName,
new SubscriberClient.ClientCreationSettings()
.WithEmulatorDetection(EmulatorDetection.EmulatorOrProduction));
List <PubsubMessage> receivedMessages = new List <PubsubMessage>();
// Use the client as you'd normally do, to listen for messages in this example.
await subscriber.StartAsync((msg, cancellationToken) =>
{
receivedMessages.Add(msg);
Console.WriteLine($"Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}");
Console.WriteLine($"Text: '{msg.Data.ToStringUtf8()}'");
// In this example we stop the subscriber when the message is received.
// You may leave the subscriber running, and it will continue to received published messages
// if any.
// This is non-blocking, and the returned Task may be awaited.
subscriber.StopAsync(TimeSpan.FromSeconds(15));
// Return Reply.Ack to indicate this message has been handled.
return(Task.FromResult(SubscriberClient.Reply.Ack));
});
}
public void Dispose()
{
_logger.Debug("[GCPFanout.Dispose()] Delete topic: {_topicID}.", _topicID);
_publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
_publisherService.DeleteTopic(_topicName);
}
