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());
}
}
/// <summary>
/// Initializes the pull worker.
/// </summary>
/// <returns></returns>
public bool InitializePullWorker()
{
bool bStatus = false;
_redis = ConnectionMultiplexer.Connect(DefaultRedisServerAddress);
_redisDB = _redis.GetDatabase();
CurrentTopicName = new TopicName(DefaultProjectId, DefaultTopicName);
_subscriber = SubscriberClient.Create();
//String subscriptionId = "projects/pushnotificationpoc-19baf/subscriptions/myTestReader";
_publisher = PublisherClient.Create();
_subscriptionName = new SubscriptionName(DefaultProjectId, DefaultSubscriptionId);
String t = _subscriptionName.ToString();
try
{
_subscriber.CreateSubscription(_subscriptionName, CurrentTopicName, pushConfig: null, ackDeadlineSeconds: 60);
}
catch (RpcException e)
{
if (e.Status.StatusCode == StatusCode.AlreadyExists)
{
// Already exists. That's fine.
_bSubscriptionAllreadyExists = true;
}
}
return(bStatus);
}
public Policy GetSubscriptionIamPolicy(string subscriptionId, PublisherClient publisher)
{
// [START pubsub_get_subscription_policy]
SubscriptionName subscriptionName = new SubscriptionName(_projectId, subscriptionId);
Policy policy = _publisher.GetIamPolicy(subscriptionName.ToString());
return(policy);
// [END pubsub_get_subscription_policy]
}
private async Task CreateSubscriptionAsync()
{
_subscriptionName = SubscriptionName.FromProjectSubscription(_projectId, _inputQueueName);
_subscriberClient = await GetSubscriberServiceApiClientAsync();
try
{
await _subscriberClient.GetSubscriptionAsync(_subscriptionName);
}
catch (RpcException ex) when(ex.StatusCode == StatusCode.NotFound)
{
int retries = 0;
var maxRetries = 10;
while (retries < maxRetries)
{
try
{
await _subscriberClient.CreateSubscriptionAsync(_subscriptionName.ToString(), _inputTopic.ToString(), null, 30, null);
//wait after subscription is created - because some delay on google's side
await Task.Delay(5000);
Log.Info("Created subscription {sub} for topic {topic}", _subscriptionName.ToString(), _inputTopic.ToString());
break;
}
catch (RpcException ex1) when(ex1.StatusCode == StatusCode.NotFound)
{
Log.Warn("Failed creating subscription {sub} for topic {topic} {times}", _subscriptionName.ToString(), _inputTopic.ToString(), retries + 1);
retries++;
if (retries == maxRetries)
{
throw new RebusApplicationException($"Could not create subscription topic {_inputTopic}");
}
await Task.Delay(1000 *retries);
}
}
}
}
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 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 TestCreateSubscription()
{
string topicId = "testTopicForSubscriptionCreation";
string subscriptionId = "testSubscriptionForSubscriptionCreation";
SubscriptionName subscriptionName = new SubscriptionName(_projectId,
subscriptionId);
CreateTopic(topicId, _publisher);
CreateSubscription(topicId, subscriptionId, _subscriber);
Subscription subscription = GetSubscription(subscriptionId,
_subscriber);
Assert.Equal(subscriptionName.ToString(), subscription.Name);
DeleteSubscription(subscriptionId, _subscriber);
DeleteTopic(topicId, _publisher);
}
public static async Task CreateSubscription(
SubscriptionName subscriptionName,
TopicName topicName,
Action <Subscription>?configureSubscription,
EmulatorDetection emulatorDetection,
CancellationToken cancellationToken
)
{
var subName = subscriptionName.ToString();
var subscriberServiceApiClient =
await new SubscriberServiceApiClientBuilder {
EmulatorDetection = emulatorDetection
}
.BuildAsync(cancellationToken)
.NoContext();
Log.Info("Checking subscription for topic", subName, topicName.ToString());
try {
await subscriberServiceApiClient.GetSubscriptionAsync(subscriptionName);
Log.Info("Subscription exists", subName);
}
catch
(RpcException e) when(e.Status.StatusCode == StatusCode.NotFound)
{
Log.Info("Subscription doesn't exist", subName);
var subscriptionRequest = new Subscription {
AckDeadlineSeconds = 60
};
configureSubscription?.Invoke(subscriptionRequest);
subscriptionRequest.SubscriptionName = subscriptionName;
subscriptionRequest.TopicAsTopicName = topicName;
await subscriberServiceApiClient.CreateSubscriptionAsync(
subscriptionRequest
)
.NoContext();
Log.Info("Created subscription", subName);
}
}
private static TableQuery <SubscriptionEntity> GetPartitionKeyQuery(SubscriptionName subscriptionName)
{
TableQuery <SubscriptionEntity> query = new TableQuery <SubscriptionEntity>()
.Where(TableQuery.GenerateFilterCondition("PartitionKey", QueryComparisons.Equal,
subscriptionName.ToString()));
return(query);
}
