/// <summary>
/// Creates the topic and subscription, if they don't already exist. You should call this
/// once at the beginning of your app.
/// </summary>
// [START createtopicandsubscription]
public void CreateTopicAndSubscription()
{
try
{
_pub.CreateTopic(_topicName);
_logger.LogVerbose("Created topic " + _topicName);
}
catch (Grpc.Core.RpcException e)
when(e.Status.StatusCode == Grpc.Core.StatusCode.AlreadyExists)
{
// The topic already exists. Ok.
_logger.LogError(_topicName + " already exists", e);
}
try
{
_sub.CreateSubscription(_subscriptionName, _topicName, null, 0);
_logger.LogVerbose("Created subscription " + _subscriptionName);
}
catch (Grpc.Core.RpcException e)
when(e.Status.StatusCode == Grpc.Core.StatusCode.AlreadyExists)
{
// The subscription already exists. Ok.
_logger.LogError(_subscriptionName + " already exists", e);
}
}
public void CallSettings_Client()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: CallSettings_ClientWide
// Create a default PublisherSettings, with a custom header for calls to all RPC methods.
PublisherSettings publisherSettings = new PublisherSettings
{
CallSettings = new CallSettings
{
Headers = new Metadata
{
{ "ClientVersion", "1.0.0" }
},
}
};
PublisherClient client = PublisherClient.Create(settings: publisherSettings);
// Format topicName from the projectId and topicId.
string topicName = PublisherClient.FormatTopicName(projectId, topicId);
// The custom 'ClientVersion' header will be included in the RPC call, due to
// the client being configured with 'publishersettings' above.
Topic topic = client.CreateTopic(topicName);
// End sample
}
public void Publish()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Snippet: Publish
PublisherClient client = PublisherClient.Create();
// Make sure we have a topic to publish to
string topicName = PublisherClient.FormatTopicName(projectId, topicId);
client.CreateTopic(topicName);
PubsubMessage message = new PubsubMessage
{
// The data is any arbitrary ByteString. Here, we're using text.
Data = ByteString.CopyFromUtf8("Hello, Pubsub"),
// The attributes provide metadata in a string-to-string dictionary.
Attributes =
{
{ "description", "Simple text message" }
}
};
client.Publish(topicName, new[] { message });
// End snippet
}
/// <summary>
/// Create a topic and subscription once.
/// </summary>
/// <param name="provider"></param>
void CreateTopicAndSubscriptionOnce(PublisherClient publisher,
TopicName topicName)
{
if (s_topicAndSubscriptionExist)
return;
try
{
publisher.CreateTopic(topicName);
}
catch (Grpc.Core.RpcException e)
when (e.Status.StatusCode == Grpc.Core.StatusCode.AlreadyExists)
{
}
var subscriptionName = new SubscriptionName(
_options.ProjectId, _options.SubscriptionId);
var pushConfig = new PushConfig()
{
PushEndpoint = $"https://{_options.ProjectId}.appspot.com/Push"
};
try
{
_subscriber.CreateSubscription(subscriptionName, topicName,
pushConfig, 20);
}
catch (Grpc.Core.RpcException e)
when (e.Status.StatusCode == Grpc.Core.StatusCode.AlreadyExists)
{
_subscriber.ModifyPushConfig(subscriptionName, pushConfig);
}
s_topicAndSubscriptionExist = true;
}
public static void Main(string[] args)
{
// Instantiates a client
PublisherClient publisher = PublisherClient.Create();
// Your Google Cloud Platform project ID
string projectId = "YOUR-PROJECT-ID";
// [END pubsub_quickstart]
Debug.Assert(projectId != "YOUR-PROJECT" + "-ID",
"Edit Program.cs and replace YOUR-PROJECT-ID with your project id.");
// [START pubsub_quickstart]
// The name for the new topic
var topicName = new TopicName(projectId, "my-new-topic");
// Creates the new topic
try
{
Topic topic = publisher.CreateTopic(topicName);
Console.WriteLine($"Topic {topic.Name} created.");
}
catch (Grpc.Core.RpcException e)
when(e.Status.StatusCode == Grpc.Core.StatusCode.AlreadyExists)
{
Console.WriteLine($"Topic {topicName} already exists.");
}
}
//Create Topic per Rule
public TopicName CreatePubSubTopic(String topicId)
{
TopicName topicName = new TopicName(ProjectId, topicId);
PublisherClient.CreateTopic(topicName);
return(topicName);
}
public void CreateTopic(string topicId, PublisherClient publisher)
{
// [START create_topic]
string topicName = PublisherClient.FormatTopicName(_projectId,
topicId);
publisher.CreateTopic(topicName);
// [END create_topic]
}
public void Overview()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Sample: Overview
// First create a topic.
PublisherClient publisher = PublisherClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
// Subscribe to the topic.
SubscriberClient subscriber = SubscriberClient.Create();
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriber.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
// Publish a message to the topic.
PubsubMessage message = new PubsubMessage
{
// The data is any arbitrary ByteString. Here, we're using text.
Data = ByteString.CopyFromUtf8("Hello, Pubsub"),
// The attributes provide metadata in a string-to-string dictionary.
Attributes =
{
{ "description", "Simple text message" }
}
};
publisher.Publish(topicName, new[] { message });
// Pull messages from the subscription. We're returning immediately, whether or not there
// are messages; in other cases you'll want to allow the call to wait until a message arrives.
PullResponse response = subscriber.Pull(subscriptionName, returnImmediately: true, maxMessages: 10);
foreach (ReceivedMessage received in response.ReceivedMessages)
{
PubsubMessage msg = received.Message;
Console.WriteLine($"Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}");
Console.WriteLine($"Text: '{msg.Data.ToStringUtf8()}'");
}
// Acknowledge that we've received the messages. If we don't do this within 60 seconds (as specified
// when we created the subscription) we'll receive the messages again when we next pull.
subscriber.Acknowledge(subscriptionName, response.ReceivedMessages.Select(m => m.AckId));
// Tidy up by deleting the subscription and the topic.
subscriber.DeleteSubscription(subscriptionName);
publisher.DeleteTopic(topicName);
// End sample
Assert.Equal(1, response.ReceivedMessages.Count);
Assert.Equal("Hello, Pubsub", response.ReceivedMessages[0].Message.Data.ToStringUtf8());
Assert.Equal("Simple text message", response.ReceivedMessages[0].Message.Attributes["description"]);
}
public async Task SimpleOverview()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Sample: SimpleOverview
// First create a topic.
PublisherClient publisher = await PublisherClient.CreateAsync();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
// Subscribe to the topic.
SubscriberClient subscriber = await SubscriberClient.CreateAsync();
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriber.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
// Publish a message to the topic using SimplePublisher.
SimplePublisher simplePublisher = await SimplePublisher.CreateAsync(topicName);
// PublishAsync() has various overloads. Here we're using the string overload.
string messageId = await simplePublisher.PublishAsync("Hello, Pubsub");
// SimplePublisher should be shutdown after use.
// The TimeSpan specifies for how long to attempt to publish locally queued messages.
await simplePublisher.ShutdownAsync(TimeSpan.FromSeconds(15));
// Pull messages from the subscription using SimpleSubscriber.
SimpleSubscriber simpleSubscriber = await SimpleSubscriber.CreateAsync(subscriptionName);
List <PubsubMessage> receivedMessages = new List <PubsubMessage>();
// Start the subscriber listening for messages.
await simpleSubscriber.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.
simpleSubscriber.StopAsync(TimeSpan.FromSeconds(15));
// Return Reply.Ack to indicate this message has been handled.
return(Task.FromResult(SimpleSubscriber.Reply.Ack));
});
// Tidy up by deleting the subscription and the topic.
subscriber.DeleteSubscription(subscriptionName);
publisher.DeleteTopic(topicName);
// End sample
Assert.Equal(1, receivedMessages.Count);
Assert.Equal("Hello, Pubsub", receivedMessages[0].Data.ToStringUtf8());
}
// [START retry]
public void RpcRetry(string topicId, string subscriptionId,
PublisherClient publisher, SubscriberClient subscriber)
{
string topicName = PublisherClient.FormatTopicName(_projectId, topicId);
string subscriptionName =
SubscriberClient.FormatSubscriptionName(_projectId, subscriptionId);
var delayMs = _retryDelayMs;
for (int tries = 1; true; ++tries)
{
try
{
// Subscribe to Topic
// This may fail if the Subscription already exists or
// the Topic has not yet been created.
subscriber.CreateSubscription(subscriptionName, topicName,
pushConfig: null, ackDeadlineSeconds: 60);
break;
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
break;
}
catch (RpcException) when(tries < _retryCount)
{
System.Threading.Thread.Sleep(delayMs);
delayMs *= 2; // Exponential back-off.
}
catch (RpcException) when(tries == _retryCount)
{
//Number of retries set in _retryCount has been reached
break;
}
}
// Create Topic
delayMs = _retryDelayMs;
for (int tries = 1; true; ++tries)
{
try
{
publisher.CreateTopic(topicName);
break;
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
break;
}
catch (RpcException) when(tries < 3)
{
System.Threading.Thread.Sleep(delayMs);
delayMs *= 2; // Exponential back-off.
}
}
}
public void CreateTopic()
{
// Snippet: CreateTopic(string,CallSettings)
// Create client
PublisherClient publisherClient = PublisherClient.Create();
// Initialize request argument(s)
string formattedName = PublisherClient.FormatTopicName("[PROJECT]", "[TOPIC]");
// Make the request
Topic response = publisherClient.CreateTopic(formattedName);
// End snippet
}
public void CreateTopic()
{
// Snippet: CreateTopic(TopicName,CallSettings)
// Create client
PublisherClient publisherClient = PublisherClient.Create();
// Initialize request argument(s)
TopicName name = new TopicName("[PROJECT]", "[TOPIC]");
// Make the request
Topic response = publisherClient.CreateTopic(name);
// End snippet
}
public void CreateTopic()
{
// <CreateTopic>
PublisherClient client = PublisherClient.Create();
// Alternative: use a known topic resource name
// projects/{PROJECT_ID}/topics/{TOPIC_ID}
string topicName = PublisherClient.GetTopicName("{PROJECT_ID}", "{TOPIC_ID}");
Topic topic = client.CreateTopic(topicName);
Console.WriteLine($"Created {topic.Name}");
// </CreateTopic>
}
public void CreateTopic()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Snippet: CreateTopic(TopicName,*)
PublisherClient client = PublisherClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
Topic topic = client.CreateTopic(topicName);
Console.WriteLine($"Created {topic.Name}");
// End snippet
}
public void CreateTopic(string topicId, PublisherClient publisher)
{
// [START create_topic]
TopicName topicName = new TopicName(_projectId, topicId);
try
{
publisher.CreateTopic(topicName);
}
catch (RpcException e)
when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
// [END create_topic]
}
public void Emulator()
{
// Sample: Emulator
// For example, "localhost:8615"
string emulatorHostAndPort = Environment.GetEnvironmentVariable("PUBSUB_EMULATOR_HOST");
Channel channel = new Channel(emulatorHostAndPort, ChannelCredentials.Insecure);
PublisherClient client = PublisherClient.Create(channel);
client.CreateTopic(new TopicName("project", "topic"));
foreach (var topic in client.ListTopics(new ProjectName("project")))
{
Console.WriteLine(topic.Name);
}
// End sample
}
public void CreateTopic()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Snippet: CreateTopic
PublisherClient client = PublisherClient.Create();
// Alternative: use a known topic resource name
// "projects/{PROJECT_ID}/topics/{TOPIC_ID}"
string topicName = PublisherClient.FormatTopicName(projectId, topicId);
Topic topic = client.CreateTopic(topicName);
Console.WriteLine($"Created {topic.Name}");
// End snippet
}
public void PerRpc()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: PerRpc
// Create a PublisherClient with default settings.
PublisherClient client = PublisherClient.Create();
// Create a topic name from the projectId and topicId.
TopicName topicName = new TopicName(projectId, topicId);
// Create a CallSettings with a custom header.
CallSettings callSettings = new CallSettings(null, null, null, metadata => metadata.Add("ClientVersion", "1.0.0"), null, null);
// This will cause the custom 'ClientVersion' header to be included in the RPC call.
Topic topic = client.CreateTopic(topicName, callSettings);
// End sample
}
public void CallSettings_Overrides()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
DateTime deadline = DateTime.MaxValue;
CancellationToken cancellationToken = new CancellationTokenSource().Token;
// Sample: CallSettings_Overrides
// Create a default PublisherSettings, with customizations for CreateTopic RPCs:
// * A custom "ClientVersion" header.
// * A custom 5-second timeout Timing.
// * No cancellation token.
PublisherSettings publisherSettings = new PublisherSettings();
publisherSettings.CreateTopicSettings.Headers = new Metadata
{
{ "ClientVersion", "1.0.0" }
};
publisherSettings.CreateTopicSettings.Timing = CallTiming.FromTimeout(TimeSpan.FromSeconds(5));
publisherSettings.CreateTopicSettings.CancellationToken = CancellationToken.None;
// Override the above Timing and CancellationToken in the client-wide CallSettings;
// the Headers are not overridden.
publisherSettings.CallSettings = new CallSettings
{
Timing = CallTiming.FromDeadline(deadline),
CancellationToken = CancellationToken.None,
};
// Create the client with the configured publisherSettings
PublisherClient client = PublisherClient.Create(settings: publisherSettings);
// Format topicName from the projectId and topicId.
string topicName = PublisherClient.FormatTopicName(projectId, topicId);
// Call CreateTopic(). Override only the CancellationToken, using a per-RPC-method CallSettings.
// The CallSettings used during this RPC invocation is:
// * A custom "ClientVersion" header.
// * A Timing deadline of 'deadline' (*not* the overridden 5-second timeout).
// * The CancellationToken 'cancellationToken' (*not* CancellationToken.None).
Topic topic = client.CreateTopic(topicName, new CallSettings
{
CancellationToken = cancellationToken
});
// End sample
}
public void NotificationsOverview()
{
string projectId = _fixture.ProjectId;
string bucket = _fixture.BucketName;
string topicId = "topic-" + Guid.NewGuid().ToString().ToLowerInvariant();
// Sample: NotificationsOverview
// First create a Pub/Sub topic.
PublisherClient publisherClient = PublisherClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisherClient.CreateTopic(topicName);
// Prepare the topic for Storage notifications. The Storage Service Account must have Publish permission
// for the topic. The code below adds the service account into the "roles/pubsub.publisher" role for the topic.
// Determine the Storage Service Account name to use in IAM operations.
StorageClient storageClient = StorageClient.Create();
string storageServiceAccount = $"serviceAccount:{storageClient.GetStorageServiceAccountEmail(projectId)}";
// Fetch the IAM policy for the topic.
Iam.V1.Policy policy = publisherClient.GetIamPolicy(topicName.ToString());
var role = "roles/pubsub.publisher";
// Ensure the Storage Service Account is in the publisher role, setting the IAM policy for the topic
// on the server if necessary.
if (policy.AddRoleMember(role, storageServiceAccount))
{
publisherClient.SetIamPolicy(topicName.ToString(), policy);
}
// Now that the topic is ready, we can create a notification configuration for Storage
Notification notification = new Notification
{
Topic = $"//pubsub.googleapis.com/{topicName}",
PayloadFormat = "JSON_API_V1"
};
notification = storageClient.CreateNotification(bucket, notification);
Console.WriteLine($"Created notification ID: {notification.Id}");
// End sample
_fixture.RegisterTopicToDelete(topicName);
}
public void ClientPerMethod()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: ClientPerMethod
// Create a default PublisherSettings, with a custom header for calls
// to the CreateTopic RPC method.
PublisherSettings publisherSettings = new PublisherSettings();
publisherSettings.CreateTopicSettings = publisherSettings.CreateTopicSettings.WithHeader("ClientVersion", "1.0.0");
PublisherClient client = PublisherClient.Create(settings: publisherSettings);
// Create a topic name from the projectId and topicId.
TopicName topicName = new TopicName(projectId, topicId);
// The custom 'ClientVersion' header will be included in the RPC call, due to
// the client being configured with 'publishersettings' above.
Topic topic = client.CreateTopic(topicName);
// End sample
}
public async Task PullAsync()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
PublisherClient publisher = PublisherClient.Create();
string topicName = PublisherClient.FormatTopicName(projectId, topicId);
publisher.CreateTopic(topicName);
PubsubMessage newMessage = new PubsubMessage {
Data = ByteString.CopyFromUtf8("Simple text")
};
SubscriberClient.Create().CreateSubscription(SubscriberClient.FormatSubscriptionName(projectId, subscriptionId), topicName, null, 60);
publisher.Publish(topicName, new[] { newMessage });
// Snippet: PullAsync(string,*,*,CallSettings)
// Additional: PullAsync(string,*,*,CancellationToken)
SubscriberClient client = SubscriberClient.Create();
// Alternative: use an existing subscription resource name:
// "projects/{PROJECT_ID}/subscriptions/{SUBSCRIPTION_ID}"
string subscriptionName = SubscriberClient.FormatSubscriptionName(projectId, subscriptionId);
PullResponse pullResponse = await client.PullAsync(subscriptionName, returnImmediately : false, maxMessages : 100);
foreach (ReceivedMessage message in pullResponse.ReceivedMessages)
{
// Messages can contain any data. We'll assume that we know this
// topic publishes UTF-8-encoded text.
Console.WriteLine($"Message text: {message.Message.Data.ToStringUtf8()}");
}
// Acknowledge the messages after pulling them, so we don't pull them
// a second time later. The ackDeadlineSeconds parameter specified when
// the subscription is created determines how quickly you need to acknowledge
// successfully-pulled messages before they will be redelivered.
var ackIds = pullResponse.ReceivedMessages.Select(rm => rm.AckId);
await client.AcknowledgeAsync(subscriptionName, ackIds);
// End snippet
}
public static void Main_HelloWorldPubSub()
{
// Instantiates a client
PublisherClient publisher = PublisherClient.Create();
// Your Google Cloud Platform project ID
string projectId = "pushnotificationpoc-19baf";
// The name for the new topic
string topicName = "my-new-topic";
// The fully qualified name for the new topic
string formattedTopicName = PublisherClient.FormatTopicName(projectId, topicName);
// Creates the new topic
Topic topic = publisher.CreateTopic(formattedTopicName);
Console.WriteLine($"Topic {topic.Name} created.");
}
public static object CreateTopic(string projectId, string topicId)
{
// [START create_publisher_client]
PublisherClient publisher = PublisherClient.Create();
// [END create_publisher_client]
// [START create_topic]
TopicName topicName = new TopicName(projectId, topicId);
try
{
publisher.CreateTopic(topicName);
}
catch (RpcException e)
when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
// [END create_topic]
return(0);
}
public void Pull()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
PublisherClient publisher = PublisherClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
PubsubMessage newMessage = new PubsubMessage {
Data = ByteString.CopyFromUtf8("Simple text")
};
SubscriberClient.Create().CreateSubscription(new SubscriptionName(projectId, subscriptionId), topicName, null, 60);
publisher.Publish(topicName, new[] { newMessage });
// Snippet: Pull(*,*,*,*)
SubscriberClient client = SubscriberClient.Create();
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
PullResponse pullResponse = client.Pull(subscriptionName, returnImmediately: false, maxMessages: 100);
foreach (ReceivedMessage message in pullResponse.ReceivedMessages)
{
// Messages can contain any data. We'll assume that we know this
// topic publishes UTF-8-encoded text.
Console.WriteLine($"Message text: {message.Message.Data.ToStringUtf8()}");
}
// Acknowledge the messages after pulling them, so we don't pull them
// a second time later. The ackDeadlineSeconds parameter specified when
// the subscription is created determines how quickly you need to acknowledge
// successfully-pulled messages before they will be redelivered.
var ackIds = pullResponse.ReceivedMessages.Select(rm => rm.AckId);
client.Acknowledge(subscriptionName, ackIds);
// End snippet
}
public void CallSettings_PerRpc()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: CallSettings_PerRpc
// Create a PublisherClient with default settings.
PublisherClient client = PublisherClient.Create();
// Format topicName from the projectId and topicId.
string topicName = PublisherClient.FormatTopicName(projectId, topicId);
// Create a CallSettings with a custom header.
CallSettings callSettings = new CallSettings
{
Headers = new Metadata
{
{ "ClientVersion", "1.0.0" }
}
};
// This will cause the custom 'ClientVersion' header to be included in the RPC call.
Topic topic = client.CreateTopic(topicName, callSettings);
// End sample
}
// [START retry]
public void RpcRetry(string topicId, string subscriptionId,
PublisherClient publisher, SubscriberClient subscriber)
{
string topicName = PublisherClient.FormatTopicName(_projectId,
topicId);
string subscriptionName =
// Create Subscription.
SubscriberClient.FormatSubscriptionName(_projectId, subscriptionId);
// Create Topic
try
{
// This may fail if the Topic already exists.
// Don't retry in that case.
publisher.CreateTopic(topicName, newRetryCallSettings(3,
StatusCode.AlreadyExists));
}
catch (RpcException e)
when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
try
{
// Subscribe to Topic
// This may fail if the Subscription already exists or
// the Topic has not yet been created. In those cases, don't
// retry, because a retry would fail the same way.
subscriber.CreateSubscription(subscriptionName, topicName,
pushConfig: null, ackDeadlineSeconds: 60,
callSettings: newRetryCallSettings(3, StatusCode.AlreadyExists,
StatusCode.NotFound));
}
catch (RpcException e)
when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
}
public void CreateTopic(string topicId, PublisherClient publisher)
{
// [START create_topic]
string topicName = PublisherClient.FormatTopicName(_projectId,
topicId);
try
{
publisher.CreateTopic(topicName);
}
catch (RpcException e)
when (e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
// [END create_topic]
}
public async Task StreamingPull()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Snippet: StreamingPull(*, *)
PublisherClient publisher = PublisherClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
SubscriberClient subscriber = SubscriberClient.Create();
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriber.CreateSubscription(subscriptionName, topicName, null, 60);
// If we don't see all the messages we expect in 10 seconds, we'll cancel the call.
CancellationTokenSource cancellationTokenSource = new CancellationTokenSource(TimeSpan.FromSeconds(10));
CallSettings callSettings = CallSettings.FromCancellationToken(cancellationTokenSource.Token);
SubscriberClient.StreamingPullStream stream = subscriber.StreamingPull(callSettings);
// The first request must include the subscription name and the stream ack deadline
await stream.WriteAsync(new StreamingPullRequest { SubscriptionAsSubscriptionName = subscriptionName, StreamAckDeadlineSeconds = 20 });
Task pullingTask = Task.Run(async() =>
{
int messagesSeen = 0;
IAsyncEnumerator <StreamingPullResponse> responseStream = stream.ResponseStream;
// Handle responses as we see them.
while (await responseStream.MoveNext())
{
StreamingPullResponse response = responseStream.Current;
Console.WriteLine("Received streaming response");
foreach (ReceivedMessage message in response.ReceivedMessages)
{
// Messages can contain any data. We'll assume that we know this
// topic publishes UTF-8-encoded text.
Console.WriteLine($"Message text: {message.Message.Data.ToStringUtf8()}");
}
// Acknowledge the messages we've just seen
await stream.WriteAsync(new StreamingPullRequest {
AckIds = { response.ReceivedMessages.Select(rm => rm.AckId) }
});
// If we've seen all the messages we expect, we can complete the streaming call,
// and our next MoveNext call will return false.
messagesSeen += response.ReceivedMessages.Count;
if (messagesSeen == 3)
{
await stream.WriteCompleteAsync();
}
}
});
publisher.Publish(topicName, new[] { new PubsubMessage {
Data = ByteString.CopyFromUtf8("Message 1")
} });
publisher.Publish(topicName, new[] { new PubsubMessage {
Data = ByteString.CopyFromUtf8("Message 2")
} });
publisher.Publish(topicName, new[] { new PubsubMessage {
Data = ByteString.CopyFromUtf8("Message 3")
} });
await pullingTask;
// End snippet
}
// [START retry]
public void RpcRetry(string topicId, string subscriptionId,
PublisherClient publisher, SubscriberClient subscriber)
{
string topicName = PublisherClient.FormatTopicName(_projectId,
topicId);
string subscriptionName =
// Create Subscription.
SubscriberClient.FormatSubscriptionName(_projectId, subscriptionId);
// Create Topic
try
{
// This may fail if the Topic already exists.
// Don't retry in that case.
publisher.CreateTopic(topicName, newRetryCallSettings(3,
StatusCode.AlreadyExists));
}
catch (RpcException e)
when (e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
try
{
// Subscribe to Topic
// This may fail if the Subscription already exists or
// the Topic has not yet been created. In those cases, don't
// retry, because a retry would fail the same way.
subscriber.CreateSubscription(subscriptionName, topicName,
pushConfig: null, ackDeadlineSeconds: 60,
callSettings: newRetryCallSettings(3, StatusCode.AlreadyExists,
StatusCode.NotFound));
}
catch (RpcException e)
when (e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
}
