public void PublishMessage(string projectId, string topicId, string message, Dictionary <string, string> attributes = null)
{
var publisherService = PublisherServiceApiClient.Create();
var topicName = new TopicName(projectId, topicId);
var pubsubMessage = BuildPubsubMessage(message, attributes);
publisherService.Publish(topicName, new[] { pubsubMessage });
}
public PublisherServiceApiClient CreatePublisherClient()
{
// [START create_publisher_client]
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
// [END create_publisher_client]
return(publisher);
}
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 static object GetTopic(string projectId, string topicId)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
Topic topic = publisher.GetTopic(topicName);
Console.WriteLine($"Topic found: {topic.TopicName.ToString()}");
return(0);
}
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 IEnumerable <Topic> Get()
{
var publisher = PublisherServiceApiClient.Create();
var projectName = ProjectName.FromProject(ProjectId);
var topics = publisher.ListTopics(projectName);
return(topics.ToList());
}
protected BasePublisher(IGCPConfiguration configuration)
{
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
ProjectId = configuration.ProjectId;
Publisher = PublisherServiceApiClient.Create();
}
public Topic Get(string id)
{
var publisher = PublisherServiceApiClient.Create();
var topicName = TopicName.FromProjectTopic(ProjectId, id);
var topic = publisher.GetTopic(topicName);
return(topic);
}
public static PublisherClient GetPublisher(string projectId,
string topicId)
{
// [START pubsub_publish]
PublisherServiceApiClient publisherClient = PublisherServiceApiClient.Create();
PublisherClient publisher = PublisherClient.Create(
new TopicName(projectId, topicId), new[] { publisherClient });
// [END pubsub_publish]
return(publisher);
}
/// <summary>Snippet for CreateTopic</summary>
public void CreateTopic()
{
// Snippet: CreateTopic(string, CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
string name = "projects/[PROJECT]/topics/[TOPIC]";
// Make the request
Topic response = publisherServiceApiClient.CreateTopic(name);
// End snippet
}
/// <summary>Snippet for GetIamPolicy</summary>
public void GetIamPolicy()
{
// Snippet: GetIamPolicy(string,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
string formattedResource = new TopicName("[PROJECT]", "[TOPIC]").ToString();
// Make the request
Policy response = publisherServiceApiClient.GetIamPolicy(formattedResource);
// End snippet
}
/// <summary>Snippet for CreateTopic</summary>
public void CreateTopic()
{
// Snippet: CreateTopic(TopicName,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
TopicName name = new TopicName("[PROJECT]", "[TOPIC]");
// Make the request
Topic response = publisherServiceApiClient.CreateTopic(name);
// End snippet
}
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);
}
private static void CreateTopic()
{
// The fully qualified name for the new topic
var topicName = new TopicName(ProjectId, TopicId);
// Creates the new CreateTopic
var publisher = PublisherServiceApiClient.Create();
Topic topic = publisher.CreateTopic(topicName);
Console.WriteLine($"Topic {topic.Name} created.");
}
/// <summary>Snippet for GetTopic</summary>
public void GetTopicResourceNames()
{
// Snippet: GetTopic(TopicName, CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
TopicName topic = TopicName.FromProjectTopic("[PROJECT]", "[TOPIC]");
// Make the request
Topic response = publisherServiceApiClient.GetTopic(topic);
// End snippet
}
private void InitializeQueue()
{
// https://github.com/GoogleCloudPlatform/google-cloud-dotnet/issues/1576
if (_pub == null)
{
var googleCredential = GoogleCredential.FromFile(_gcpSettings.PubSub.JsonAuthPath).CreateScoped(PublisherServiceApiClient.DefaultScopes);
var channel = new Channel(PublisherServiceApiClient.DefaultEndpoint.ToString(), googleCredential.ToChannelCredentials());
_pub = PublisherServiceApiClient.Create(channel);
}
}
/// <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 TestIamPermissions</summary>
public void TestIamPermissions()
{
// Snippet: TestIamPermissions(string,IEnumerable<string>,CallSettings)
// Create client
PublisherServiceApiClient publisherServiceApiClient = PublisherServiceApiClient.Create();
// Initialize request argument(s)
string formattedResource = new TopicName("[PROJECT]", "[TOPIC]").ToString();
IEnumerable <string> permissions = new List <string>();
// Make the request
TestIamPermissionsResponse response = publisherServiceApiClient.TestIamPermissions(formattedResource, permissions);
// End snippet
}
/// <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
}
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 TestIamPermissionsResponse TestTopicIamPermissions(string projectId, string topicId)
{
TestIamPermissionsRequest request = new TestIamPermissionsRequest
{
ResourceAsResourceName = TopicName.FromProjectTopic(projectId, topicId),
Permissions = { "pubsub.topics.get", "pubsub.topics.update" }
};
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TestIamPermissionsResponse response = publisher.TestIamPermissions(request);
return(response);
}
public static object GetTopicIamPolicy(string projectId, string topicId)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
// [START pubsub_get_topic_policy]
TopicName topicName = new TopicName(projectId, topicId);
Policy policy = publisher.GetIamPolicy(topicName.ToString());
Console.WriteLine($"Topic IAM Policy found for {topicId}:");
Console.WriteLine(policy.Bindings);
// [END pubsub_get_topic_policy]
return(0);
}
public TestIamPermissionsResponse TestSubscriptionIamPermissionsResponse(string projectId, string subscriptionId)
{
TestIamPermissionsRequest request = new TestIamPermissionsRequest
{
ResourceAsResourceName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId),
Permissions = { "pubsub.subscriptions.get", "pubsub.subscriptions.update" }
};
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TestIamPermissionsResponse response = publisher.TestIamPermissions(request);
return(response);
}
// Not a test - the hard-coded project doesn't actually exist.
public void ListTopics()
{
// Sample: ListTopics
var client = PublisherServiceApiClient.Create();
var topics = client.ListTopics(new ProjectName("petstore"));
foreach (Topic topic in topics)
{
// Output would include projects/petstore/topics/offers
Console.WriteLine(topic.Name);
}
// End sample
}
public PubsubTest()
{
// By default, the Google.Pubsub.V1 library client will authenticate
// using the service account file (created in the Google Developers
// Console) specified by the GOOGLE_APPLICATION_CREDENTIALS
// environment variable and it will use the project specified by
// the GOOGLE_PROJECT_ID environment variable. If you are running on
// a Google Compute Engine VM, authentication is completely
// automatic.
_projectId = Environment.GetEnvironmentVariable("GOOGLE_PROJECT_ID");
_publisher = CreatePublisherClient();
_subscriber = CreateSubscriberClient();
}
public static object ListProjectTopics(PublisherServiceApiClient publisher, string projectId)
{
// [START pubsub_list_topics]
ProjectName projectName = new ProjectName(projectId);
IEnumerable <Topic> topics = publisher.ListTopics(projectName);
foreach (Topic topic in topics)
{
Console.WriteLine($"{topic.Name}");
}
// [END pubsub_list_topics]
return(0);
}
public static object GetSubscriptionIamPolicy(string projectId,
string subscriptionId)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
// [START pubsub_get_subscription_policy]
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
Policy policy = publisher.GetIamPolicy(subscriptionName.ToString());
Console.WriteLine($"Subscription IAM Policy found for {subscriptionId}:");
Console.WriteLine(policy.Bindings);
// [END pubsub_get_subscription_policy]
return(0);
}
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 DetachSubscription(string projectId, string subscriptionId)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
DetachSubscriptionRequest detachSubscriptionRequest = new DetachSubscriptionRequest
{
SubscriptionAsSubscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId),
};
publisher.DetachSubscription(detachSubscriptionRequest);
Console.WriteLine($"Subscription {subscriptionId} is detached.");
}
public void CreateTopic()
{
var publisherService = PublisherServiceApiClient.Create();
try
{
publisherService.CreateTopic(TopicName);
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.AlreadyExists)
{
// This is not a problem, it just means the topic already exists.
}
}
