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)); } }