public static void DeleteTopic(string projectId, string topicId)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
publisher.DeleteTopic(topicName);
}
public void Overview()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Sample: Overview
// First create a topic.
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
// Subscribe to the topic.
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.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.
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());
}
public static object DeleteTopic(string projectId, string topicId)
{
// [START pubsub_delete_topic]
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.DeleteTopic(topicName);
Console.WriteLine("Topic deleted.");
// [END pubsub_delete_topic]
return(0);
}
/// <summary>Snippet for DeleteTopic</summary>
public void DeleteTopic()
{
// Snippet: DeleteTopic(TopicName,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
TopicName topic = new TopicName("[PROJECT]", "[TOPIC]");
// Make the request
publisherServiceApiClient.DeleteTopic(topic);
// End snippet
}
/// <summary>Snippet for DeleteTopic</summary>
public void DeleteTopic()
{
// Snippet: DeleteTopic(string, CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
string topic = "projects/[PROJECT]/topics/[TOPIC]";
// Make the request
publisherServiceApiClient.DeleteTopic(topic);
// End snippet
}
/// <summary>Snippet for DeleteTopic</summary>
public void DeleteTopic_RequestObject()
{
// Snippet: DeleteTopic(DeleteTopicRequest,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
DeleteTopicRequest request = new DeleteTopicRequest
{
TopicAsTopicName = new TopicName("[PROJECT]", "[TOPIC]"),
};
// Make the request
publisherServiceApiClient.DeleteTopic(request);
// End snippet
}
public void DeleteTopic()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
PublisherServiceApiClient.Create().CreateTopic(new TopicName(projectId, topicId));
// Snippet: DeleteTopic(TopicName,*)
PublisherServiceApiClient client = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
client.DeleteTopic(topicName);
Console.WriteLine($"Deleted {topicName}");
// End snippet
}
public void DeletePubSubTopic(TopicName topicName)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
publisher.DeleteTopic(topicName);
}
private static void Start()
{
SubscriberClient _subscriber;
PublisherClient _publisher;
// Instantiates a client
PublisherServiceApiClient publisherApi = PublisherServiceApiClient.Create();
// Subscribe to the topic.
TopicName pubsubTopicName = new TopicName(projectId, topicName);
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
SubscriberServiceApiClient subscriberApi = SubscriberServiceApiClient.Create();
// Creates the new topic
try
{
Topic topic = publisherApi.CreateTopic(pubsubTopicName);
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 the new subscription
try
{
subscriberApi.CreateSubscription(subscriptionName, pubsubTopicName, null, 120);
Console.WriteLine($"Subscription {subscriptionName.Kind} created.");
}
catch (Grpc.Core.RpcException e) when(e.Status.StatusCode == Grpc.Core.StatusCode.AlreadyExists)
{
// OK
Console.WriteLine($"Subscription {subscriptionName.Kind} already exists");
}
catch (Exception ex)
{
Console.WriteLine(ex);
}
_subscriber = SubscriberClient.Create(subscriptionName, new[] { subscriberApi });
_publisher = PublisherClient.Create(pubsubTopicName, new[] { publisherApi });
_publisher.PublishAsync("Bla-Bla-Bla-Message.");
_subscriber.StartAsync((message, token) =>
{
string data = message.Data.ToStringUtf8();
try
{
Console.WriteLine($"Pubsub message id={message.MessageId}, " +
$"created at {message.PublishTime}, data{message.Data.ToStringUtf8()}");
// TODO: Replace with ACK
return(System.Threading.Tasks.Task.FromResult(SubscriberClient.Reply.Nack));
}
catch (Exception ex)
{
Console.WriteLine(ex.Message);
return(System.Threading.Tasks.Task.FromResult(SubscriberClient.Reply.Nack));
}
});
// VARIAN II :
// 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 = subscriberApi.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.
subscriberApi.Acknowledge(subscriptionName, response.ReceivedMessages.Select(m => m.AckId));
// Tidy up by deleting the subscription and the topic.
subscriberApi.DeleteSubscription(subscriptionName);
publisherApi.DeleteTopic(pubsubTopicName);
}
public void Dispose()
{
_logger.Debug("[GCPFanout.Dispose()] Delete topic: {_topicID}.", _topicID);
_publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
_publisherService.DeleteTopic(_topicName);
}
