public int PullMessagesSync(string projectId, string subscriptionId, bool acknowledge)
{
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
SubscriberServiceApiClient subscriberClient = SubscriberServiceApiClient.Create();
int messageCount = 0;
try
{
// Pull messages from server,
// allowing an immediate response if there are no messages.
PullResponse response = subscriberClient.Pull(subscriptionName, returnImmediately: false, maxMessages: 20);
// Print out each received message.
foreach (ReceivedMessage msg in response.ReceivedMessages)
{
string text = System.Text.Encoding.UTF8.GetString(msg.Message.Data.ToArray());
Console.WriteLine($"Message {msg.Message.MessageId}: {text}");
Interlocked.Increment(ref messageCount);
}
// If acknowledgement required, send to server.
if (acknowledge && messageCount > 0)
{
subscriberClient.Acknowledge(subscriptionName, response.ReceivedMessages.Select(msg => msg.AckId));
}
}
catch (RpcException ex) when(ex.Status.StatusCode == StatusCode.Unavailable)
{
// UNAVAILABLE due to too many concurrent pull requests pending for the given subscription.
}
return(messageCount);
}
public void DeleteSubscription(string projectId, string subscriptionId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
subscriber.DeleteSubscription(subscriptionName);
}
public static Task Subscribe(string subscriptionId, IServiceScopeFactory scopeFactory)
{
var subscriptionName = SubscriptionName.FromProjectSubscription("kwetter-308618", subscriptionId);
var subscription = SubscriberClient.CreateAsync(subscriptionName).Result;
return(subscription.StartAsync((message, _) =>
{
var mediator = scopeFactory.CreateScope().ServiceProvider.GetRequiredService <IMediator>();
var json = Encoding.UTF8.GetString(message.Data.ToArray());
switch (subscriptionId)
{
case "profileservice--user-created":
mediator.Send(JsonConvert.DeserializeObject <UserCreatedEvent>(json), _);
break;
case "profileservice--user-deleted":
mediator.Send(JsonConvert.DeserializeObject <UserDeletedEvent>(json), _);
break;
}
return Task.FromResult(SubscriberClient.Reply.Ack);
}));
}
public static async Task DeleteSubscription(string subscriptionId)
{
var subscriber = await SubscriberServiceApiClient.CreateAsync();
var subscriptionName = SubscriptionName.FromProjectSubscription(ProjectId, subscriptionId);
await subscriber.DeleteSubscriptionAsync(subscriptionName);
}
public async Task PurgeQueueAsync()
{
var topic = new TopicName(_projectId, _inputQueueName);
try
{
var service = await GetPublisherServiceApiClientAsync();
await service.DeleteTopicAsync(topic);
Log.Info("Purged topic {topic} by deleting it", topic.ToString());
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.NotFound)
{
Log.Warn("Tried purging topic {topic} by deleting it, but it could not be found", topic.ToString());
}
_subscriptionName = SubscriptionName.FromProjectSubscription(_projectId, _inputQueueName);
try
{
_subscriberClient = await GetSubscriberServiceApiClientAsync();
await _subscriberClient.DeleteSubscriptionAsync(_subscriptionName);
Log.Info("Purged subscription {subscriptionname} by deleting it", _subscriptionName.ToString());
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.NotFound)
{
Log.Info("Tried purging subscription {subscriptionname} by deleting it, but it could not be found", _subscriptionName.ToString());
}
}
public Subscription GetSubscription(string subscriptionId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(ProjectId, subscriptionId);
return(subscriber.GetSubscription(subscriptionName));
}
public async Task <int> PullMessagesAsyncWithDeliveryAttempts(string projectId, string subscriptionId, bool acknowledge)
{
// This is an existing subscription with a dead letter policy.
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName);
int deliveryAttempt = 0;
Task startTask = subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
{
string text = Encoding.UTF8.GetString(message.Data.ToArray());
System.Console.WriteLine($"Delivery Attempt: {message.GetDeliveryAttempt()}");
if (message.GetDeliveryAttempt() != null)
{
deliveryAttempt = message.GetDeliveryAttempt().Value;
}
return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack));
});
// Run for 7 seconds.
await Task.Delay(7000);
await subscriber.StopAsync(CancellationToken.None);
// Lets make sure that the start task finished successfully after the call to stop.
await startTask;
return(deliveryAttempt);
}
public async Task <int> PullMessagesAsync(string projectId, string subscriptionId, bool acknowledge)
{
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName);
// SubscriberClient runs your message handle function on multiple
// threads to maximize throughput.
int messageCount = 0;
Task startTask = subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
{
string text = System.Text.Encoding.UTF8.GetString(message.Data.ToArray());
Console.WriteLine($"Message {message.MessageId}: {text}");
Interlocked.Increment(ref messageCount);
return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack));
});
// Run for 5 seconds.
await Task.Delay(5000);
await subscriber.StopAsync(CancellationToken.None);
// Lets make sure that the start task finished successfully after the call to stop.
await startTask;
return(messageCount);
}
public Subscription CreateSubscriptionWithDeadLetterPolicy(string projectId, string subscriptionId, string topicId, string deadLetterTopicId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
// This is the subscription you want to create with a dead letter policy.
var subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
// This is an existing topic that you want to attach the subscription with dead letter policy to.
var topicName = TopicName.FromProjectTopic(projectId, topicId);
// This is an existing topic that the subscription with dead letter policy forwards dead letter messages to.
var deadLetterTopic = TopicName.FromProjectTopic(projectId, deadLetterTopicId).ToString();
var subscriptionRequest = new Subscription
{
SubscriptionName = subscriptionName,
TopicAsTopicName = topicName,
DeadLetterPolicy = new DeadLetterPolicy
{
DeadLetterTopic = deadLetterTopic,
// The maximum number of times that the service attempts to deliver a
// message before forwarding it to the dead letter topic. Must be [5-100].
MaxDeliveryAttempts = 10
},
AckDeadlineSeconds = 30
};
var subscription = subscriber.CreateSubscription(subscriptionRequest);
Console.WriteLine("Created subscription: " + subscription.SubscriptionName.SubscriptionId);
Console.WriteLine($"It will forward dead letter messages to: {subscription.DeadLetterPolicy.DeadLetterTopic}");
Console.WriteLine($"After {subscription.DeadLetterPolicy.MaxDeliveryAttempts} delivery attempts.");
// Remember to attach a subscription to the dead letter topic because
// messages published to a topic with no subscriptions are lost.
return(subscription);
}
public Policy SetSubscriptionIamPolicy(string projectId, string subscriptionId, string role, string member)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
string roleToBeAddedToPolicy = $"roles/{role}";
Policy policy = new Policy
{
Bindings =
{
new Binding
{
Role = roleToBeAddedToPolicy,
Members ={ member }
}
}
};
SetIamPolicyRequest request = new SetIamPolicyRequest
{
ResourceAsResourceName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId),
Policy = policy
};
Policy response = publisher.SetIamPolicy(request);
return(response);
}
public Subscription UpdateDeadLetterPolicy(string projectId, string topicId, string subscriptionId, string deadLetterTopicId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
// This is an existing topic that the subscription with dead letter policy is attached to.
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
// This is an existing subscription with a dead letter policy.
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
// This is an existing dead letter topic that the subscription with dead letter policy forwards
// dead letter messages to.
var deadLetterTopic = TopicName.FromProjectTopic(projectId, deadLetterTopicId).ToString();
// Construct the subscription with the dead letter policy you expect to have after the update.
// Here, values in the required fields (name, topic) help identify the subscription.
var subscription = new Subscription
{
SubscriptionName = subscriptionName,
TopicAsTopicName = topicName,
DeadLetterPolicy = new DeadLetterPolicy
{
DeadLetterTopic = deadLetterTopic,
MaxDeliveryAttempts = 20,
}
};
var request = new UpdateSubscriptionRequest
{
Subscription = subscription,
// Construct a field mask to indicate which field to update in the subscription.
UpdateMask = new FieldMask { Paths = { "dead_letter_policy" } }
};
var updatedSubscription = subscriber.UpdateSubscription(request);
return updatedSubscription;
}
public Subscription RemoveDeadLetterPolicy(string projectId, string topicId, string subscriptionId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
// This is an existing topic that the subscription with dead letter policy is attached to.
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
// This is an existing subscription with dead letter policy.
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
var subscription = new Subscription()
{
SubscriptionName = subscriptionName,
TopicAsTopicName = topicName,
DeadLetterPolicy = null
};
var request = new UpdateSubscriptionRequest
{
Subscription = subscription,
UpdateMask = new FieldMask {
Paths = { "dead_letter_policy" }
}
};
var updatedSubscription = subscriber.UpdateSubscription(request);
return(updatedSubscription);
}
public async Task <List <PubsubMessage> > PullMessagesWithCustomAttributesAsync(string projectId, string subscriptionId, bool acknowledge)
{
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName);
var messages = new List <PubsubMessage>();
Task startTask = subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
{
messages.Add(message);
string text = System.Text.Encoding.UTF8.GetString(message.Data.ToArray());
Console.WriteLine($"Message {message.MessageId}: {text}");
if (message.Attributes != null)
{
foreach (var attribute in message.Attributes)
{
Console.WriteLine($"{attribute.Key} = {attribute.Value}");
}
}
return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack));
});
// Run for 7 seconds.
await Task.Delay(7000);
await subscriber.StopAsync(CancellationToken.None);
// Lets make sure that the start task finished successfully after the call to stop.
await startTask;
return(messages);
}
public async Task <int> PullMessagesWithFlowControlAsync(string projectId, string subscriptionId, bool acknowledge)
{
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
int messageCount = 0;
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName,
settings : new SubscriberClient.Settings()
{
AckExtensionWindow = TimeSpan.FromSeconds(4),
AckDeadline = TimeSpan.FromSeconds(10),
FlowControlSettings = new FlowControlSettings(maxOutstandingElementCount: 100, maxOutstandingByteCount: 10240)
});
// SubscriberClient runs your message handle function on multiple
// threads to maximize throughput.
Task startTask = subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
{
string text = System.Text.Encoding.UTF8.GetString(message.Data.ToArray());
Console.WriteLine($"Message {message.MessageId}: {text}");
Interlocked.Increment(ref messageCount);
return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack));
});
// Run for 5 seconds.
await Task.Delay(5000);
await subscriber.StopAsync(CancellationToken.None);
// Lets make sure that the start task finished successfully after the call to stop.
await startTask;
return(messageCount);
}
public Subscription CreateSubscriptionWithOrdering(string projectId, string subscriptionId, string topicId)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
var topicName = TopicName.FromProjectTopic(projectId, topicId);
var subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
var subscriptionRequest = new Subscription
{
SubscriptionName = subscriptionName,
TopicAsTopicName = topicName,
EnableMessageOrdering = true
};
Subscription subscription = null;
try
{
subscription = subscriber.CreateSubscription(subscriptionRequest);
}
catch (RpcException e) when(e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
}
return(subscription);
}
public void Delete(string id)
{
var subscriber = SubscriberServiceApiClient.Create();
var subscriptionName = SubscriptionName.FromProjectSubscription(ProjectId, id);
subscriber.DeleteSubscription(subscriptionName);
}
public IActionResult Get(string id)
{
var subscriber = SubscriberServiceApiClient.Create();
var subscriptionName = SubscriptionName.FromProjectSubscription(ProjectId, id);
var subscription = subscriber.GetSubscription(subscriptionName);
return(Ok(subscription));
}
public Policy GetSubscriptionIamPolicy(string projectId, string subscriptionId)
{
PublisherServiceApiClient publisher = PublisherServiceApiClient.Create();
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
Policy policy = publisher.GetIamPolicy(subscriptionName);
return(policy);
}
public void Post([FromBody] CreateTopicRequest request)
{
var subscriber = SubscriberServiceApiClient.Create();
var topicName = TopicName.FromProjectTopic(ProjectId, request.TopicId);
var subscriptionName = SubscriptionName.FromProjectSubscription(ProjectId, request.SubscriptionId);
subscriber.CreateSubscription(subscriptionName, topicName, pushConfig: null, ackDeadlineSeconds: 60);
}
public void SubscriberClientSupport()
{
// Sample: SubscriberClient
SubscriptionName subscription = SubscriptionName.FromProjectSubscription("projectId", "subscriptionId");
SubscriberClient.ClientCreationSettings clientCreationSettings = new SubscriberClient.ClientCreationSettings()
.WithEmulatorDetection(EmulatorDetection.EmulatorOrProduction);
SubscriberClient client = SubscriberClient.Create(subscription, clientCreationSettings);
// End sample
}
public void UpdatePushConfiguration(string projectId, string subscriptionId, string pushEndpoint)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
PushConfig pushConfig = new PushConfig {
PushEndpoint = pushEndpoint
};
subscriber.ModifyPushConfig(subscriptionName, pushConfig);
}
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);
}
public static Task Subscribe(string subscriptionId)
{
var subscriptionName = SubscriptionName.FromProjectSubscription("kwetter-308618", subscriptionId);
var subscription = SubscriberClient.CreateAsync(subscriptionName).Result;
return(subscription.StartAsync((message, _) =>
{
var json = Encoding.UTF8.GetString(message.Data.ToArray());
Console.WriteLine($"Message {message.MessageId}: {json}");
return Task.FromResult(SubscriberClient.Reply.Ack);
}));
}
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 async Task <int> PullAvroMessagesAsync(string projectId, string subscriptionId, bool acknowledge)
{
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
int messageCount = 0;
SubscriberClient subscriber = await SubscriberClient.CreateAsync(subscriptionName,
settings : new SubscriberClient.Settings()
{
AckExtensionWindow = TimeSpan.FromSeconds(4),
AckDeadline = TimeSpan.FromSeconds(10),
FlowControlSettings = new FlowControlSettings(maxOutstandingElementCount: 100, maxOutstandingByteCount: 10240)
});
// SubscriberClient runs your message handle function on multiple
// threads to maximize throughput.
Task startTask = subscriber.StartAsync((PubsubMessage message, CancellationToken cancel) =>
{
string encoding = message.Attributes["googclient_schemaencoding"];
AvroUtilities.State state = new AvroUtilities.State();
switch (encoding)
{
case "BINARY":
using (var ms = new MemoryStream(message.Data.ToByteArray()))
{
var decoder = new BinaryDecoder(ms);
var reader = new SpecificDefaultReader(state.Schema, state.Schema);
reader.Read <AvroUtilities.State>(state, decoder);
}
break;
case "JSON":
state = JsonConvert.DeserializeObject <AvroUtilities.State>(message.Data.ToStringUtf8());
break;
default:
Console.WriteLine($"Encoding not provided in message.");
break;
}
Console.WriteLine($"Message {message.MessageId}: {state}");
Interlocked.Increment(ref messageCount);
return(Task.FromResult(acknowledge ? SubscriberClient.Reply.Ack : SubscriberClient.Reply.Nack));
});
// Run for 5 seconds.
await Task.Delay(5000);
await subscriber.StopAsync(CancellationToken.None);
// Lets make sure that the start task finished successfully after the call to stop.
await startTask;
return(messageCount);
}
public void Emulator()
{
string projectId = "projectId";
string subscriptionId = "subscriptionId";
// Sample: Emulator
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
SubscriberClient.ClientCreationSettings clientSettings = new SubscriberClient.ClientCreationSettings()
.WithEmulatorDetection(EmulatorDetection.EmulatorOrProduction);
SubscriberClient subscriber = SubscriberClient.Create(subscriptionName, clientSettings);
// Use subscriber.StartAsync etc as normal
// End sample
}
public void TestListSubscriptionsInTopic()
{
string randomName = _pubsubFixture.RandomName();
string topicId = $"testTopicForListSubscriptionsInTopic{randomName}";
string subscriptionId = $"testSubscriptionForListSubscriptionsInTopic{randomName}";
_pubsubFixture.CreateTopic(topicId);
_pubsubFixture.CreateSubscription(topicId, subscriptionId);
var subscriptions = _listSubscriptionsInTopicSample.ListSubscriptionsInTopic(_pubsubFixture.ProjectId, topicId).ToList();
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(_pubsubFixture.ProjectId, subscriptionId);
Assert.Contains(subscriptions, s => s == subscriptionName.ToString());
}
public void DetachSubscriptionRequestObject()
{
moq::Mock <Publisher.PublisherClient> mockGrpcClient = new moq::Mock <Publisher.PublisherClient>(moq::MockBehavior.Strict);
DetachSubscriptionRequest request = new DetachSubscriptionRequest
{
SubscriptionAsSubscriptionName = SubscriptionName.FromProjectSubscription("[PROJECT]", "[SUBSCRIPTION]"),
};
DetachSubscriptionResponse expectedResponse = new DetachSubscriptionResponse {
};
mockGrpcClient.Setup(x => x.DetachSubscription(request, moq::It.IsAny <grpccore::CallOptions>())).Returns(expectedResponse);
PublisherServiceApiClient client = new PublisherServiceApiClientImpl(mockGrpcClient.Object, null);
DetachSubscriptionResponse response = client.DetachSubscription(request);
xunit::Assert.Same(expectedResponse, response);
mockGrpcClient.VerifyAll();
}
public Subscription CreatePushSubscription(string projectId, string topicId, string subscriptionId, string pushEndpoint)
{
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
TopicName topicName = TopicName.FromProjectTopic(projectId, topicId);
SubscriptionName subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
PushConfig pushConfig = new PushConfig {
PushEndpoint = pushEndpoint
};
// The approximate amount of time in seconds (on a best-effort basis) Pub/Sub waits for the
// subscriber to acknowledge receipt before resending the message.
var ackDeadlineSeconds = 60;
var subscription = subscriber.CreateSubscription(subscriptionName, topicName, pushConfig, ackDeadlineSeconds);
return(subscription);
}
public void PullMessages(string subscriptionId, Action <string> action)
{
var projectId = "imposing-elixir-249711";
var subscriptionName = SubscriptionName.FromProjectSubscription(projectId, subscriptionId);
SubscriberServiceApiClient subscriber = SubscriberServiceApiClient.Create();
var response = subscriber.Pull(subscriptionName, returnImmediately: true, maxMessages: 10);
foreach (ReceivedMessage received in response.ReceivedMessages)
{
PubsubMessage msg = received.Message;
action.Invoke(msg.Data.ToStringUtf8());
}
if (response.ReceivedMessages?.Count > 0)
{
subscriber.Acknowledge(subscriptionName, response.ReceivedMessages.Select(m => m.AckId));
}
}
