private async Task <Application> CreateTopics(Application app)
        {
            string queueName = $"queue-{app.Name.Replace(" ", "")}-{app.Id}-subs";

            AmazonSimpleNotificationServiceClient clientSNS = AwsFactory.CreateClient <AmazonSimpleNotificationServiceClient>();



            //create topics and subscribe them
            await app.Events.ToList().ForEachAsync(e =>
            {
                string topic_name = $"topic-{app.Name.Replace(" ", "")}-event-{e.EventName}";

                CreateTopicResponse topicResponse = clientSNS.CreateTopicAsync(new CreateTopicRequest(topic_name)).Result;

                if (topicResponse.HttpStatusCode != System.Net.HttpStatusCode.OK)
                {
                    throw new Exception($"Error creating topic {topic_name}");
                }


                e.TopicArn = topicResponse.TopicArn;
            });

            return(app);
        }
예제 #2
0
        async Task ConfigureLambdaWithQueueAsync(string queueName)
        {
            string queueArn = null;

            AmazonSQSClient sqsClient = AwsFactory.CreateClient <AmazonSQSClient>();

            GetQueueUrlRequest queueUrlReq = new GetQueueUrlRequest();

            queueUrlReq.QueueName = queueName;

            GetQueueUrlResponse getQueueUrlResp = await sqsClient.GetQueueUrlAsync(queueUrlReq);

            GetQueueAttributesRequest queueAttribReq = new GetQueueAttributesRequest();

            queueAttribReq.AttributeNames.Add(QueueAttributeName.QueueArn);
            queueAttribReq.QueueUrl = getQueueUrlResp.QueueUrl;

            var queueAttribResp = await sqsClient.GetQueueAttributesAsync(queueAttribReq);

            queueArn = queueAttribResp.QueueARN;

            AmazonLambdaClient lambdaClient = AwsFactory.CreateClient <AmazonLambdaClient>();

            CreateEventSourceMappingRequest eventMappingReq = new CreateEventSourceMappingRequest();

            eventMappingReq.FunctionName   = "WebhookDispatcher";
            eventMappingReq.BatchSize      = 10;
            eventMappingReq.Enabled        = true;
            eventMappingReq.EventSourceArn = queueArn;

            await lambdaClient.CreateEventSourceMappingAsync(eventMappingReq);
        }
        public async Task <string> NotifyAsync(string appId, string eventName, string message)
        {
            ValidateNotification(appId, eventName, message);

            string notifyRequestId = Guid.NewGuid().ToString();
            AmazonSimpleNotificationServiceClient clientSNS = AwsFactory.CreateClient <AmazonSimpleNotificationServiceClient>();

            var app = await Repository.GetByIdAsync(appId);

            Event targetEvent = app.Events.ToList().Where(e => e.EventName == eventName).FirstOrDefault();


            var response = await clientSNS.PublishAsync(new PublishRequest
            {
                Message = JsonSerializer.Serialize <NotifyMessage>(new NotifyMessage
                {
                    EventName       = eventName,
                    ApplicationId   = appId,
                    Payload         = message,
                    NotifyRequestId = notifyRequestId
                }),

                TargetArn = targetEvent.TopicArn
            });

            await NotificationRequestRepository.CreateAsync(new NotificationRequest
            {
                ApplicationId = appId,
                EventName     = eventName,
                Id            = notifyRequestId,
                Payload       = message,
                TopicArn      = targetEvent.TopicArn,
                Timestamp     = DateTime.Now.ToUniversalTime()
            });



            return(response.MessageId);
        }
예제 #4
0
        async Task <CreateQueueResponse> CreateQueueAsync(string queueName, string SubscriptionId)
        {
            CreateQueueRequest deadLetterRequest = new CreateQueueRequest(string.Concat(queueName, "-deadletter"));

            deadLetterRequest.Attributes = new Dictionary <string, string>();
            deadLetterRequest.Attributes.Add(QueueAttributeName.ReceiveMessageWaitTimeSeconds, "20");
            deadLetterRequest.Attributes.Add(QueueAttributeName.MessageRetentionPeriod, "864000");

            string deadLetterArn = null;

            AmazonSQSClient sqsClient = AwsFactory.CreateClient <AmazonSQSClient>();

            var createResponse = await sqsClient.CreateQueueAsync(deadLetterRequest);

            GetQueueAttributesRequest queueReq = new GetQueueAttributesRequest();

            queueReq.QueueUrl = createResponse.QueueUrl;
            queueReq.AttributeNames.Add(QueueAttributeName.All);
            var queueAttribs = await sqsClient.GetQueueAttributesAsync(queueReq);

            deadLetterArn = queueAttribs.QueueARN;



            string redrivePolicy = $"{{\"deadLetterTargetArn\":\"{deadLetterArn}\",\"maxReceiveCount\":5}}";

            CreateQueueRequest createQueueRequest = new CreateQueueRequest();

            createQueueRequest.QueueName  = queueName;
            createQueueRequest.Attributes = new Dictionary <string, string>();
            createQueueRequest.Attributes.Add(QueueAttributeName.RedrivePolicy, redrivePolicy);
            createQueueRequest.Attributes.Add(QueueAttributeName.ReceiveMessageWaitTimeSeconds, "20");

            //createQueueRequest.Attributes.Add("trigger-id", SubscriptionId);
            CreateQueueResponse queueResponse = await sqsClient.CreateQueueAsync(createQueueRequest);

            return(queueResponse);
        }
        public void DeleteAllTopics()
        {
            AmazonSimpleNotificationServiceClient clientSNS = AwsFactory.CreateClient <AmazonSimpleNotificationServiceClient>();
            AmazonSQSClient    clientSQS    = AwsFactory.CreateClient <AmazonSQSClient>();
            AmazonLambdaClient lambdaClient = AwsFactory.CreateClient <AmazonLambdaClient>();


            var topics = clientSNS.ListTopicsAsync();
            // var subs = clientSNS.ListSubscriptionsAsync(new ListSubscriptionsRequest());
            var filas = clientSQS.ListQueuesAsync("subs");

            filas.Result.QueueUrls.ForEach(i =>
            {
                var deleted = clientSQS.DeleteQueueAsync(i);
                if (deleted.Result.HttpStatusCode != HttpStatusCode.OK)
                {
                    int x = 0;
                }
            });

            string nextToken = "";

            do
            {
                var subs = clientSNS.ListSubscriptionsAsync(new ListSubscriptionsRequest(nextToken));

                subs.Result.Subscriptions.ForEach(i =>
                {
                    var deleted = clientSNS.UnsubscribeAsync(i.SubscriptionArn);
                });

                nextToken = subs.Result.NextToken;
            } while (!String.IsNullOrEmpty(nextToken));



            var mapper = lambdaClient.ListEventSourceMappingsAsync(new Amazon.Lambda.Model.ListEventSourceMappingsRequest
            {
                FunctionName = "WebhookDispatcher"
            });

            mapper.Result.EventSourceMappings.ToList().ForEach(i =>
            {
                var result = lambdaClient.DeleteEventSourceMappingAsync(new Amazon.Lambda.Model.DeleteEventSourceMappingRequest()
                {
                    UUID = i.UUID
                });
                if (result.Result.HttpStatusCode != HttpStatusCode.OK)
                {
                    int x = 0;
                }
            });


            topics.Result.Topics.ForEach(i =>
            {
                var deleted = clientSNS.DeleteTopicAsync(new DeleteTopicRequest()
                {
                    TopicArn = i.TopicArn
                });
            });
        }
예제 #6
0
        public async Task <string> Create(Model.Subscription subscription)
        {
            subscription.Id = Guid.NewGuid().ToString();
            string queueName = $"subs-{subscription.Id}";

            //create queue
            var queueResponse = await CreateQueueAsync(queueName, subscription.Id);

            subscription.QueueUrl = queueResponse.QueueUrl;

            //set lambda subs
            await ConfigureLambdaWithQueueAsync(queueName);

            //Get topicsARN
            var app = await ApplicationRepository.GetByIdAsync(subscription.ApplicationId);


            if (app != null)
            {
                //getting ARN
                var events = from subEvent in subscription.Events
                             join appEvent in app.Events
                             on subEvent.EventName equals appEvent.EventName
                             select new Event
                {
                    EventName = appEvent.EventName,
                    TopicArn  = appEvent.TopicArn
                };



                await events.ToList().ForEachAsync(e =>
                {
                    subscription.Events.RemoveAll(y => y.EventName == e.EventName);
                    subscription.Events.Add(e);


                    var sub = AwsFactory.CreateClient <AmazonSimpleNotificationServiceClient>()
                              .SubscribeQueueToTopicsAsync(
                        new List <string>()
                    {
                        e.TopicArn
                    },
                        AwsFactory.CreateClient <AmazonSQSClient>(),
                        queueResponse.QueueUrl);

                    sub.Result.ToList().ForEach(s =>

                    {
                        try
                        {
                            var setting = AwsFactory.CreateClient <AmazonSimpleNotificationServiceClient>().SetSubscriptionAttributesAsync(new SetSubscriptionAttributesRequest
                            {
                                AttributeName   = "RawMessageDelivery",
                                AttributeValue  = "true",
                                SubscriptionArn = sub.Result.FirstOrDefault().Value
                            });
                        }
                        catch (Exception)
                        {
                            throw new WebhookManagerException("Error setting Subscription Attribute");
                        }
                    }
                                                );
                });

                await Repository.CreateAsync(subscription);
            }
            return(subscription.Id);
        }