private async Task CreateTopicAndSubscription(TopicName topicName, SubscriptionName subscriptionName)
{
// Create topic
var publisherApi = await PublisherServiceApiClient.CreateAsync().ConfigureAwait(false);
await publisherApi.CreateTopicAsync(topicName).ConfigureAwait(false);
// Subscribe to the topic
var subscriberApi = await SubscriberServiceApiClient.CreateAsync().ConfigureAwait(false);
await subscriberApi.CreateSubscriptionAsync(subscriptionName, topicName, null, 60).ConfigureAwait(false);
}
public static async Task CreateTopic(string topicId)
{
var publisher = await PublisherServiceApiClient.CreateAsync();
var topicName = TopicName.FromProjectTopic(ProjectId, topicId);
try {
await publisher.CreateTopicAsync(topicName);
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
}
}
public void CreateTopic()
{
try
{
var publisherService = PublisherServiceApiClient.CreateAsync().Result;
var topicName = new TopicName(EnvResources.ProjectId, EnvResources.TopicId);
publisherService.CreateTopic(topicName);
}
catch (Exception e)
{
Console.WriteLine(e);
}
}
/// <summary>Snippet for DeleteTopicAsync</summary>
public async Task DeleteTopicAsync()
{
// Snippet: DeleteTopicAsync(TopicName,CallSettings)
// Additional: DeleteTopicAsync(TopicName,CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
TopicName topic = new TopicName("[PROJECT]", "[TOPIC]");
// Make the request
await publisherServiceApiClient.DeleteTopicAsync(topic);
// End snippet
}
/// <summary>Snippet for GetTopicAsync</summary>
public async Task GetTopicResourceNamesAsync()
{
// Snippet: GetTopicAsync(TopicName, CallSettings)
// Additional: GetTopicAsync(TopicName, CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
TopicName topic = TopicName.FromProjectTopic("[PROJECT]", "[TOPIC]");
// Make the request
Topic response = await publisherServiceApiClient.GetTopicAsync(topic);
// End snippet
}
/// <summary>Snippet for GetIamPolicyAsync</summary>
public async Task GetIamPolicyAsync()
{
// Snippet: GetIamPolicyAsync(string,CallSettings)
// Additional: GetIamPolicyAsync(string,CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
string formattedResource = new TopicName("[PROJECT]", "[TOPIC]").ToString();
// Make the request
Policy response = await publisherServiceApiClient.GetIamPolicyAsync(formattedResource);
// End snippet
}
/// <summary>Snippet for CreateTopicAsync</summary>
public async Task CreateTopicAsync()
{
// Snippet: CreateTopicAsync(string, CallSettings)
// Additional: CreateTopicAsync(string, CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
string name = "projects/[PROJECT]/topics/[TOPIC]";
// Make the request
Topic response = await publisherServiceApiClient.CreateTopicAsync(name);
// End snippet
}
private async Task <PublisherServiceApiClient> GetPublisherAsync()
{
PublisherServiceApiClient publisher;
if (!string.IsNullOrEmpty(_host) && _port != 0)
{
publisher = await PublisherServiceApiClient.CreateAsync(new ServiceEndpoint(_host, _port));
}
else
{
publisher = await PublisherServiceApiClient.CreateAsync();
}
return(publisher);
}
/// <summary>Snippet for TestIamPermissionsAsync</summary>
public async Task TestIamPermissionsAsync()
{
// Snippet: TestIamPermissionsAsync(string,IEnumerable<string>,CallSettings)
// Additional: TestIamPermissionsAsync(string,IEnumerable<string>,CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
string formattedResource = new TopicName("[PROJECT]", "[TOPIC]").ToString();
IEnumerable <string> permissions = new List <string>();
// Make the request
TestIamPermissionsResponse response = await publisherServiceApiClient.TestIamPermissionsAsync(formattedResource, permissions);
// End snippet
}
/// <summary>Snippet for ListTopicSubscriptions</summary>
public async Task ListTopicSubscriptionsRequestObjectAsync()
{
// Snippet: ListTopicSubscriptionsAsync(ListTopicSubscriptionsRequest, CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
ListTopicSubscriptionsRequest request = new ListTopicSubscriptionsRequest
{
TopicAsTopicName = TopicName.FromProjectTopic("[PROJECT]", "[TOPIC]"),
};
// Make the request
PagedAsyncEnumerable <ListTopicSubscriptionsResponse, string> response = publisherServiceApiClient.ListTopicSubscriptionsAsync(request);
// Iterate over all response items, lazily performing RPCs as required
await response.ForEachAsync((string item) =>
{
// Do something with each item
Console.WriteLine(item);
});
// Or iterate over pages (of server-defined size), performing one RPC per page
await response.AsRawResponses().ForEachAsync((ListTopicSubscriptionsResponse page) =>
{
// Do something with each page of items
Console.WriteLine("A page of results:");
foreach (string item in page)
{
// Do something with each item
Console.WriteLine(item);
}
});
// Or retrieve a single page of known size (unless it's the final page), performing as many RPCs as required
int pageSize = 10;
Page <string> singlePage = await response.ReadPageAsync(pageSize);
// Do something with the page of items
Console.WriteLine($"A page of {pageSize} results (unless it's the final page):");
foreach (string item in singlePage)
{
// Do something with each item
Console.WriteLine(item);
}
// Store the pageToken, for when the next page is required.
string nextPageToken = singlePage.NextPageToken;
// End snippet
}
/// <summary>Snippet for CreateTopicAsync</summary>
public async Task CreateTopicAsync_RequestObject()
{
// Snippet: CreateTopicAsync(Topic,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
Topic request = new Topic
{
TopicName = new TopicName("[PROJECT]", "[TOPIC]"),
};
// Make the request
Topic response = await publisherServiceApiClient.CreateTopicAsync(request);
// End snippet
}
/// <summary>Snippet for GetIamPolicyAsync</summary>
public async Task GetIamPolicyAsync_RequestObject()
{
// Snippet: GetIamPolicyAsync(GetIamPolicyRequest,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
GetIamPolicyRequest request = new GetIamPolicyRequest
{
Resource = new TopicName("[PROJECT]", "[TOPIC]").ToString(),
};
// Make the request
Policy response = await publisherServiceApiClient.GetIamPolicyAsync(request);
// End snippet
}
/// <summary>Snippet for DeleteTopicAsync</summary>
public async Task DeleteTopicAsync_RequestObject()
{
// Snippet: DeleteTopicAsync(DeleteTopicRequest,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
DeleteTopicRequest request = new DeleteTopicRequest
{
TopicAsTopicName = new TopicName("[PROJECT]", "[TOPIC]"),
};
// Make the request
await publisherServiceApiClient.DeleteTopicAsync(request);
// End snippet
}
public void StreamingPull()
{
// First create a topic.
PublisherServiceApiClient publisherService = PublisherServiceApiClient.CreateAsync().Result;
TopicName topicName = new TopicName("k8s-brewery", "sdk-example-test-topic");
try
{
publisherService.CreateTopic(topicName);
}
catch
{
}
// Subscribe to the topic.
SubscriberServiceApiClient subscriberService = SubscriberServiceApiClient.CreateAsync().Result;
SubscriptionName subscriptionName = new SubscriptionName("k8s-brewery", "sdk-example-test-subscription");
try
{
subscriberService.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
}
catch
{
}
// Pull messages from the subscription using SubscriberClient.
SubscriberClient subscriber = SubscriberClient.CreateAsync(subscriptionName).Result;
List <PubsubMessage> receivedMessages = new List <PubsubMessage>();
// Start the subscriber listening for messages.
subscriber.StartAsync((msg, cancellationToken) =>
{
using (var span = CustomSpan.Create()
.AsGCPubSubReceive(subscriptionName.SubscriptionId, subscriptionName.ProjectId)
.AsChildOf(() => GetDisInfo(msg)))
{
span.WrapAction(() =>
{
receivedMessages.Add(msg);
Console.WriteLine($"[Test] Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}");
Console.WriteLine($"[Test] Text: '{msg.Data.ToStringUtf8()}'");
}, true);
return(Task.FromResult(SubscriberClient.Reply.Ack));
}
});
}
internal async Task ClientAsync()
{
// First create a topic :
PublisherServiceApiClient publisherService = await PublisherServiceApiClient.CreateAsync().ConfigureAwait(false);
TopicName topicName = new TopicName(ProjectId, TopicId);
// publisherService.CreateTopic(topicName);
// Subscribe to the topic :
SubscriberServiceApiClient subscriberService = await SubscriberServiceApiClient.CreateAsync().ConfigureAwait(false);
SubscriptionName subscriptionName = new SubscriptionName(ProjectId, SubscriptionId);
// subscriberService.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
// Publish a message to the topic :
PublisherClient publisher = await PublisherClient.CreateAsync(topicName).ConfigureAwait(false);
// PublishAsync() has various overloads. Here we're using the string overload.
string messageId = await publisher.PublishAsync("Hello, Pubsub").ConfigureAwait(false);
// 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)).ConfigureAwait(false);
// Pull messages from the subscription :
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName).ConfigureAwait(false);
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));
})
.ConfigureAwait(false);
// Tidy up by deleting the subscription and the topic :
// subscriberService.DeleteSubscription(subscriptionName);
// publisherService.DeleteTopic(topicName);
}
public static async Task <bool> DeleteTopic(TopicName topicName)
{
PublisherServiceApiClient publisherService = await PublisherServiceApiClient.CreateAsync();
try
{
await publisherService.DeleteTopicAsync(topicName);
Console.WriteLine($" => Topic deleted: {topicName}");
return(true);
}
catch (Exception e)
{
Console.WriteLine($" => Failed to delete {topicName}. (Error: {e.Message}");
return(false);
}
}
/// <summary>Snippet for DeleteTopicAsync</summary>
public async Task DeleteTopicRequestObjectAsync()
{
// Snippet: DeleteTopicAsync(DeleteTopicRequest, CallSettings)
// Additional: DeleteTopicAsync(DeleteTopicRequest, CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
DeleteTopicRequest request = new DeleteTopicRequest
{
TopicAsTopicName = TopicName.FromProjectTopic("[PROJECT]", "[TOPIC]"),
};
// Make the request
await publisherServiceApiClient.DeleteTopicAsync(request);
// End snippet
}
/// <summary>Snippet for UpdateTopicAsync</summary>
public async Task UpdateTopicAsync_RequestObject()
{
// Snippet: UpdateTopicAsync(UpdateTopicRequest,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
UpdateTopicRequest request = new UpdateTopicRequest
{
Topic = new Topic(),
UpdateMask = new FieldMask(),
};
// Make the request
Topic response = await publisherServiceApiClient.UpdateTopicAsync(request);
// End snippet
}
/// <summary>Snippet for GetTopicAsync</summary>
public async Task GetTopicAsync_RequestObject()
{
// Snippet: GetTopicAsync(GetTopicRequest,CallSettings)
// Additional: GetTopicAsync(GetTopicRequest,CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
GetTopicRequest request = new GetTopicRequest
{
TopicAsTopicName = new TopicName("[PROJECT]", "[TOPIC]"),
};
// Make the request
Topic response = await publisherServiceApiClient.GetTopicAsync(request);
// End snippet
}
/// <summary>Snippet for TestIamPermissionsAsync</summary>
public async Task TestIamPermissionsAsync_RequestObject()
{
// Snippet: TestIamPermissionsAsync(TestIamPermissionsRequest,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
TestIamPermissionsRequest request = new TestIamPermissionsRequest
{
Resource = new TopicName("[PROJECT]", "[TOPIC]").ToString(),
Permissions = { },
};
// Make the request
TestIamPermissionsResponse response = await publisherServiceApiClient.TestIamPermissionsAsync(request);
// End snippet
}
/// <summary>Snippet for PublishAsync</summary>
public async Task PublishResourceNamesAsync()
{
// Snippet: PublishAsync(TopicName, IEnumerable<PubsubMessage>, CallSettings)
// Additional: PublishAsync(TopicName, IEnumerable<PubsubMessage>, CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
TopicName topic = TopicName.FromProjectTopic("[PROJECT]", "[TOPIC]");
IEnumerable <PubsubMessage> messages = new PubsubMessage[]
{
new PubsubMessage(),
};
// Make the request
PublishResponse response = await publisherServiceApiClient.PublishAsync(topic, messages);
// End snippet
}
private static async Task <Topic> EnsureTopicExists(string projectId, string topicId)
{
PublisherServiceApiClient publisher = await PublisherServiceApiClient.CreateAsync();
var topicName = TopicName.FromProjectTopic(projectId, topicId);
Topic topic;
try
{
topic = await publisher.CreateTopicAsync(topicName);
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
topic = await publisher.GetTopicAsync(topicName);
}
return(topic);
}
/// <summary>Snippet for PublishAsync</summary>
public async Task PublishAsync()
{
// Snippet: PublishAsync(string, IEnumerable<PubsubMessage>, CallSettings)
// Additional: PublishAsync(string, IEnumerable<PubsubMessage>, CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
string topic = "projects/[PROJECT]/topics/[TOPIC]";
IEnumerable <PubsubMessage> messages = new PubsubMessage[]
{
new PubsubMessage(),
};
// Make the request
PublishResponse response = await publisherServiceApiClient.PublishAsync(topic, messages);
// End snippet
}
/// <summary>Snippet for CreateTopicAsync</summary>
public async Task CreateTopicRequestObjectAsync()
{
// Snippet: CreateTopicAsync(Topic, CallSettings)
// Additional: CreateTopicAsync(Topic, CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
Topic request = new Topic
{
TopicName = TopicName.FromProjectTopic("[PROJECT]", "[TOPIC]"),
Labels = { { "", "" }, },
MessageStoragePolicy = new MessageStoragePolicy(),
KmsKeyName = "",
};
// Make the request
Topic response = await publisherServiceApiClient.CreateTopicAsync(request);
// End snippet
}
public static async Task <Topic> CreateTopic(string projectId, string topicId)
{
var publisher = await PublisherServiceApiClient.CreateAsync();
var topicName = TopicName.FromProjectTopic(projectId, topicId);
Topic topic = null;
try
{
topic = await publisher.CreateTopicAsync(topicName);
Console.WriteLine($" => Topic {topic.Name} created.");
return(topic);
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
Console.WriteLine($" => Topic {topic.Name} already exists.");
}
return(null);
}
/// <summary>Snippet for PublishAsync</summary>
public async Task PublishRequestObjectAsync()
{
// Snippet: PublishAsync(PublishRequest, CallSettings)
// Additional: PublishAsync(PublishRequest, CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
PublishRequest request = new PublishRequest
{
TopicAsTopicName = TopicName.FromProjectTopic("[PROJECT]", "[TOPIC]"),
Messages =
{
new PubsubMessage(),
},
};
// Make the request
PublishResponse response = await publisherServiceApiClient.PublishAsync(request);
// End snippet
}
/// <summary>Snippet for PublishAsync</summary>
public async Task PublishAsync()
{
// Snippet: PublishAsync(TopicName,IEnumerable<PubsubMessage>,CallSettings)
// Additional: PublishAsync(TopicName,IEnumerable<PubsubMessage>,CancellationToken)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
TopicName topic = new TopicName("[PROJECT]", "[TOPIC]");
IEnumerable <PubsubMessage> messages = new[]
{
new PubsubMessage
{
Data = Google.Protobuf.ByteString.CopyFromUtf8(""),
},
};
// Make the request
PublishResponse response = await publisherServiceApiClient.PublishAsync(topic, messages);
// End snippet
}
public async Task CreateSubscription(
SubscriptionName subscriptionName,
TopicName topicName,
PushConfig?pushConfig,
int ackDeadline
)
{
var subscriberServiceApiClient = await SubscriberServiceApiClient.CreateAsync().Ignore();
var publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync().Ignore();
try {
Log?.LogInformation("Checking topic {Topic}", topicName);
await publisherServiceApiClient.CreateTopicAsync(topicName).Ignore();
Log?.LogInformation("Created topic {Topic}", topicName);
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
Log?.LogInformation("Topic {Topic} exists", topicName);
}
try {
Log?.LogInformation("Checking subscription {Subscription} for {Topic}", subscriptionName, topicName);
await subscriberServiceApiClient.CreateSubscriptionAsync(
subscriptionName,
topicName,
pushConfig,
ackDeadline
).Ignore();
Log?.LogInformation("Created subscription {Subscription} for {Topic}", subscriptionName, topicName);
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
Log?.LogInformation("Subscription {Subscription} for {Topic} exists", subscriptionName, topicName);
}
}
/// <summary>Snippet for PublishAsync</summary>
public async Task PublishAsync_RequestObject()
{
// Snippet: PublishAsync(PublishRequest,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = await PublisherServiceApiClient.CreateAsync();
// Initialize request argument(s)
PublishRequest request = new PublishRequest
{
TopicAsTopicName = new TopicName("[PROJECT]", "[TOPIC]"),
Messages =
{
new PubsubMessage
{
Data = ByteString.CopyFromUtf8(""),
},
},
};
// Make the request
PublishResponse response = await publisherServiceApiClient.PublishAsync(request);
// End snippet
}
public async Task InitalizeAsync(CancellationToken cancellationToken)
{
PublisherServiceApiClient publisherService = await PublisherServiceApiClient.CreateAsync(cancellationToken);
SubscriberServiceApiClient subscriberService = await SubscriberServiceApiClient.CreateAsync(cancellationToken);
// ensure each topic exists
foreach (string topicId in Topics.AllTopics)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
TopicName topicName = new TopicName(m_projectId, topicId);
try
{
await publisherService.GetTopicAsync(topicName, cancellationToken);
}
catch (RpcException)
{
Topic topic = await publisherService.CreateTopicAsync(topicName, cancellationToken);
m_logger.Info($"Created topic {topic.Name}");
}
m_publisherClients.Add(topicName, await PublisherClient.CreateAsync(topicName));
}
// ensure each subscription exists
foreach (var(topicId, subscriptionId) in Subscriptions.AllSubscriptions)
{
if (cancellationToken.IsCancellationRequested)
{
return;
}
SubscriptionName subscriptionName = new SubscriptionName(m_projectId, subscriptionId);
try
{
await subscriberService.GetSubscriptionAsync(subscriptionName, cancellationToken);
}
catch (RpcException)
{
Subscription subscription = await subscriberService.CreateSubscriptionAsync(
new Subscription
{
TopicAsTopicName = new TopicName(m_projectId, topicId),
SubscriptionName = subscriptionName,
AckDeadlineSeconds = 30,
ExpirationPolicy = new ExpirationPolicy
{
Ttl = Duration.FromTimeSpan(TimeSpan.FromDays(365)),
},
},
cancellationToken);
m_logger.Info($"Created subscription {subscription.Name}");
}
m_subscriberClients.Add(subscriptionName, await SubscriberClient.CreateAsync(subscriptionName));
}
}
