public void Emulator()
{
// Sample: Emulator
// [START pubsub_use_emulator]
// For example, "localhost:8615"
string emulatorHostAndPort = Environment.GetEnvironmentVariable("PUBSUB_EMULATOR_HOST");
Channel channel = new Channel(emulatorHostAndPort, ChannelCredentials.Insecure);
PublisherServiceApiClient client = PublisherServiceApiClient.Create(channel);
client.CreateTopic(new TopicName("project", "topic"));
foreach (var topic in client.ListTopics(new ProjectName("project")))
{
Console.WriteLine(topic.Name);
}
// [END pubsub_use_emulator]
// End sample
}
public TopicName CreateTopic()
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
Topic topic;
try
{
var topicName = new TopicName(_projectId, "topicId");
topic = publisher.CreateTopic(topicName.ToString());
return(topicName);
}
catch (RpcException e)
when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
return(null);
}
}
public static object CreateTopic(string projectId, string topicId)
{
// [START pubsub_create_topic]
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
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 pubsub_create_topic]
return(0);
}
public void ClientPerMethod()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: ClientPerMethod
// Create a default PublisherServiceApiSettings, with a custom header for calls
// to the CreateTopic RPC method.
PublisherServiceApiSettings publisherSettings = new PublisherServiceApiSettings();
publisherSettings.CreateTopicSettings = publisherSettings.CreateTopicSettings.WithHeader("ClientVersion", "1.0.0");
PublisherServiceApiClient client = PublisherServiceApiClient.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 void Client()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
// Sample: ClientWide
// Create a default PublisherServiceApiSettings, with a custom header for calls to all RPC methods.
PublisherServiceApiSettings publisherSettings = new PublisherServiceApiSettings
{
CallSettings = new CallSettings(null, null, null, metadata => metadata.Add("ClientVersion", "1.0.0"), null, null)
};
PublisherServiceApiClient client = PublisherServiceApiClient.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 PubsubGameBoardQueue(
IOptions <PubsubGameBoardQueueOptions> options,
ILogger <PubsubGameBoardQueue> logger)
{
_options = options;
_logger = logger;
_publisherApi = PublisherServiceApiClient.Create();
var subscriberApi = SubscriberServiceApiClient.Create();
_publisherClient = PublisherClient.Create(MyTopic,
new[] { _publisherApi });
_subscriberClient = SubscriberClient.Create(MySubscription,
new[] { subscriberApi }, new SubscriberClient.Settings()
{
StreamAckDeadline = TimeSpan.FromMinutes(1)
});
// Create the Topic and Subscription.
try
{
_publisherApi.CreateTopic(MyTopic);
_logger.LogInformation("Created {0}.", MyTopic.ToString());
}
catch (RpcException e)
when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
try
{
subscriberApi.CreateSubscription(MySubscription, MyTopic,
pushConfig: null, ackDeadlineSeconds: 10);
_logger.LogInformation("Created {0}.",
MySubscription.ToString());
}
catch (RpcException e)
when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
}
public async Task InitTopic(string topicID)
{
await Task.Run(() =>
{
_topicID = topicID;
_topicName = new TopicName(_projectID, _topicID);
_publisherService = PublisherServiceApiClient.Create();
try
{
_publisherService.CreateTopic(_topicName);
}
catch (Grpc.Core.RpcException e) when(e.Status.StatusCode == Grpc.Core.StatusCode.AlreadyExists)
{
//Console.WriteLine("Topic existed.");
_logger.Debug($"[GCPFanout.InitTopic()] Topic: {_topicID} existed");
}
_publisher = PublisherClient.CreateAsync(_topicName).Result;
});
}
public async Task PullAsync()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
PubsubMessage newMessage = new PubsubMessage {
Data = ByteString.CopyFromUtf8("Simple text")
};
SubscriberServiceApiClient.Create().CreateSubscription(new SubscriptionName(projectId, subscriptionId), topicName, null, 60);
publisher.Publish(topicName, new[] { newMessage });
// Snippet: PullAsync(SubscriptionName,*,*,CallSettings)
// Additional: PullAsync(SubscriptionName,*,*,CancellationToken)
SubscriberServiceApiClient client = SubscriberServiceApiClient.Create();
SubscriptionName subscriptionName = new SubscriptionName(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 void Overrides()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
DateTime deadline = DateTime.MaxValue;
CancellationToken cancellationToken = new CancellationTokenSource().Token;
// Sample: Overrides
// Create a default PublisherServiceApiSettings, with customizations for CreateTopic RPCs:
// * A custom "ClientVersion" header.
// * A custom 5-second timeout Timing.
// * No cancellation token.
PublisherServiceApiSettings publisherSettings = new PublisherServiceApiSettings();
publisherSettings.CreateTopicSettings = publisherSettings.CreateTopicSettings
.WithCancellationToken(CancellationToken.None)
.WithCallTiming(CallTiming.FromTimeout(TimeSpan.FromSeconds(5)))
.WithHeader("ClientVersion", "1.0.0");
// Override the above Timing and CancellationToken in the client-wide CallSettings;
// the Headers are not overridden.
publisherSettings.CallSettings = CallSettings
.FromCallTiming(CallTiming.FromDeadline(deadline))
.WithCancellationToken(CancellationToken.None);
// Create the client with the configured publisherSettings
PublisherServiceApiClient client = PublisherServiceApiClient.Create(settings: publisherSettings);
// Create a topic name from the projectId and topicId.
TopicName topicName = new TopicName(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, CallSettings.FromCancellationToken(cancellationToken));
// End sample
}
// [START retry]
internal void RpcRetry(string topicId, string subscriptionId,
PublisherServiceApiClient publisher, SubscriberServiceApiClient subscriber)
{
TopicName topicName = new TopicName(_projectId, topicId);
// Create Subscription.
SubscriptionName subscriptionName = new SubscriptionName(_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.
}
}
private bool EnsureTopicExistence(TopicName _TopicInstance, PublisherServiceApiClient _PublisherAPIClient = null, Action <string> _ErrorMessageAction = null)
{
try
{
if (_PublisherAPIClient == null)
{
_PublisherAPIClient = PublisherServiceApiClient.Create(PublishChannel);
}
_PublisherAPIClient.CreateTopic(_TopicInstance);
}
catch (Exception e)
{
if (e is RpcException && (e as RpcException).Status.StatusCode == StatusCode.AlreadyExists)
{
//That is fine.
}
else
{
_ErrorMessageAction?.Invoke("BPubSubServiceGC->EnsureTopicExistence: " + e.Message + ", Trace: " + e.StackTrace);
return(false);
}
}
return(true);
}
public async Task StreamingPull()
{
string projectId = _fixture.ProjectId;
string topicId = _fixture.CreateTopicId();
string subscriptionId = _fixture.CreateSubscriptionId();
// Snippet: StreamingPull(*, *)
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName(projectId, topicId);
publisher.CreateTopic(topicName);
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.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);
SubscriberServiceApiClient.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
}
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 async Task WithEmulatorAsync(string projectId, string topicId, string subscriptionId)
{
// Use EmulatorDetection.EmulatorOrProduction to create service clients that will
// that will connect to the PubSub emulator if the PUBSUB_EMULATOR_HOST environment
// variable is set, but will otherwise connect to the production environment.
// Create the PublisherServiceApiClient using the PublisherServiceApiClientBuilder
// and setting the EmulatorDection property.
PublisherServiceApiClient publisherService = await new PublisherServiceApiClientBuilder
{
EmulatorDetection = EmulatorDetection.EmulatorOrProduction
}.BuildAsync();
// Use the client as you'd normally do, to create a topic in this example.
TopicName topicName = new TopicName(projectId, topicId);
publisherService.CreateTopic(topicName);
// Create the SubscriberServiceApiClient using the SubscriberServiceApiClientBuilder
// and setting the EmulatorDection property.
SubscriberServiceApiClient subscriberService = await new SubscriberServiceApiClientBuilder
{
EmulatorDetection = EmulatorDetection.EmulatorOrProduction
}.BuildAsync();
// Use the client as you'd normally do, to create a subscription in this example.
SubscriptionName subscriptionName = new SubscriptionName(projectId, subscriptionId);
subscriberService.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
// Create the PublisherClient using PublisherClient.ClientCreationSettings
// and call the WithEmulatorDection method.
PublisherClient publisher = await PublisherClient.CreateAsync(
topicName,
new PublisherClient.ClientCreationSettings()
.WithEmulatorDetection(EmulatorDetection.EmulatorOrProduction));
// Use the client as you'd normally do, to send a message in this example.
await publisher.PublishAsync("Hello, Pubsub");
await publisher.ShutdownAsync(TimeSpan.FromSeconds(15));
// Create the SubscriberClient using SubscriberClient.ClientCreationSettings
// and call the WithEmulatorDection method.
SubscriberClient subscriber = await SubscriberClient.CreateAsync(
subscriptionName,
new SubscriberClient.ClientCreationSettings()
.WithEmulatorDetection(EmulatorDetection.EmulatorOrProduction));
List <PubsubMessage> receivedMessages = new List <PubsubMessage>();
// Use the client as you'd normally do, to listen for messages in this example.
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()}'");
// In this example we stop the subscriber when the message is received.
// You may leave the subscriber running, and it will continue to received published messages
// if any.
// 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));
});
}
static void Main(string[] args)
{
GCPublisherService gcPublisherService = new GCPublisherService();
GCSubscriberService gcSubscriberService = new GCSubscriberService();
gcPublisherService.StartPeriodicallyPublish(2000);
gcSubscriberService.StreamingPull();
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
TopicName topicName = new TopicName("k8s-brewery", "sdk-example-test-topic-2");
try
{
publisher.CreateTopic(topicName);
}
catch (Exception)
{
Console.WriteLine("Failed to create topic");
}
// Publish a message to the topic.
PubsubMessage message = new PubsubMessage
{
Data = ByteString.CopyFromUtf8("Message "),
Attributes =
{
{ "Description", "Simple text message " }
}
};
publisher.Publish(topicName, new[] { message });
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
SubscriptionName subscriptionName = new SubscriptionName("k8s-brewery", "sdk-example-test-subscription-2");
try
{
subscriber.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
}
catch (Exception)
{
Console.WriteLine("Failed to create subscription");
}
PullResponse response = subscriber.Pull(subscriptionName, returnImmediately: true, maxMessages: 100);
foreach (ReceivedMessage received in response.ReceivedMessages)
{
using (var span = CustomSpan.Create()
.AsGCPubSubReceive(subscriptionName.SubscriptionId, subscriptionName.ProjectId)
.AsChildOf(() => GCSubscriberService.GetDisInfo(received.Message)))
{
span.WrapAction(() =>
{
PubsubMessage msg = received.Message;
Console.WriteLine($"Received message {msg.MessageId} published at {msg.PublishTime.ToDateTime()}");
Console.WriteLine($"Text: '{msg.Data.ToStringUtf8()}'");
Console.WriteLine($"Attributes: '{string.Join(",", msg.Attributes.Select(x => $"{x.Key}-{x.Value}"))}'");
}, true);
}
}
if (response.ReceivedMessages.Count > 0)
{
subscriber.Acknowledge(subscriptionName, response.ReceivedMessages.Select(m => m.AckId));
}
Console.WriteLine("Press any key to close ...");
Console.ReadKey();
}
