Esempio n. 1
0
        public async Task DeleteQueues(DataCleanupParameters parameters)
        {
            _log.LogDebug("Queue deletion starting.");

            try
            {
                QueueServiceClient queueServiceClient = _queueManager.CreateQueueServiceClient(parameters.StorageConnectionString);
                List <string>      queues             = await _queueManager.GetQueues(queueServiceClient);

                var queueDeleteTasks = new List <Task>();
                if (queues != null)
                {
                    foreach (var queue in queues)
                    {
                        queueDeleteTasks.Add(_queueManager.DeleteQueue(queueServiceClient, queue));
                    }
                    await Task.WhenAll(queueDeleteTasks);
                }

                _log.LogDebug($"Queue deletion completed! Removed {queueDeleteTasks.Count} queues.");
            }
            catch (Exception ex)
            {
                _log.LogError(ex, "Exception encountered in DeleteQueues method.");
                throw;
            }

            return;
        }
Esempio n. 2
0
        public virtual void DeleteSelectedQueue()
        {
            if (SelectedQueue == null)
            {
                return;
            }

            var selectedItem = SelectedNode;
            var confirmation = string.Format("The queue named {0} with all its messages will be removed. Continue?", SelectedQueue.Address);
            var result       = _windowManager.ShowMessageBox(confirmation, "Warning", MessageBoxButton.OKCancel, MessageBoxImage.Question);

            if (result != MessageBoxResult.OK)
            {
                return;
            }

            _queueManager.DeleteQueue(SelectedQueue);
            MachineRoot.Children.Remove(selectedItem);
        }
Esempio n. 3
0
        static void Main(string[] _)
        {
            const string newsHeadlinesEndpoint = "https://api.refinitiv.com/message-services/v1/news-headlines/subscriptions";

            try
            {
                // Create the platform session.
                using (ISession session = Sessions.GetSession())
                {
                    // Open the session
                    session.Open();

                    // Create a queue definition
                    var definition = Queue.Definition(newsHeadlinesEndpoint);

                    // Create a QueueManager to actively manage our queues
                    IQueueManager manager = definition.CreateQueueManager().OnError((err, qm) => Console.WriteLine(err));

                    // First, check to see if we have any news headline queues active in the cloud...
                    List <IQueueNode> queues = manager.GetAllQueues();

                    // Determine if we retrieved an active headline queue...create one if not.
                    IQueueNode queue;
                    if (queues.Count > 0)
                    {
                        queue = queues[0];
                    }
                    else
                    {
                        queue = CreateQueue(manager, "AA");      // Create a Queue with the new query expression ("AA" - alerts only)
                    }
                    // Ensure our queue is created
                    if (queue != null)
                    {
                        Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue.");
                        Console.WriteLine("Waiting for headline alerts...");

                        // Subscribe to the queue.
                        // Note: The subscriber interface has 2 mechanisms to retrieve data from the queue.  The first mechanism is to selectively
                        //       poll the queue for new messages.  The second mechanism is to define a callback/lambda expression and notify the
                        //       the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
                        //
                        // The following example demonstrates the first mechanism.
                        var subscriber = definition.CreateAWSSubscriber(queue);

                        // Poll the queue until we hit any key on the keyboard.
                        // Each poll will timeout after 2 seconds if no messages arrive.
                        while (!Console.KeyAvailable)
                        {
                            subscriber.GetNextMessage(2, (headline, s) => DisplayHeadline(headline));
                        }
                        Console.ReadKey();

                        // Prompt the user to delete the queue
                        Console.Write("\nDelete the queue (Y/N) [N]: ");
                        var delete = Console.ReadLine();
                        if (delete?.ToUpper() == "Y")
                        {
                            if (manager.DeleteQueue(queue))
                            {
                                Console.WriteLine("Successfully deleted queue.");
                            }
                            else
                            {
                                Console.WriteLine($"Issues deleting queue.");
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
            }
        }
        static void Main(string[] _)
        {
            const string researchEndpoint = "https://api.refinitiv.com/message-services/v1/research/subscriptions";

            try
            {
                using (ISession session = Configuration.Sessions.GetSession())
                {
                    if (session.Open() == Session.State.Opened)
                    {
                        // Create our Research definition
                        var definition = Queue.Definition(researchEndpoint);

                        // Create a QueueManager to actively manage our queues
                        IQueueManager manager = definition.CreateQueueManager().OnError((err, qm) => Console.WriteLine(err));

                        // First, check to see if we have any research queues active in the cloud...
                        var queues = manager.GetAllQueues();

                        // Prepare Research criteria if we plan to create a new AWS queue - we must supply a research ID.
                        JObject criteria = new JObject()
                        {
                            ["transport"] = new JObject()
                            {
                                ["transportType"] = "AWS-SQS"
                            },
                            ["payloadVersion"] = "2.0",
                            ["userID"]         = Configuration.Credentials.ResearchID
                        };

                        // If no existing queue exists, create one.
                        IQueueNode queue = (queues.Count > 0 ? queues[0] : manager.CreateQueue(criteria));

                        if (queue != null)
                        {
                            Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue...");

                            // Subscribe to the queue.
                            // Note: The subscriber interface has 2 mechanisms to retrieve data from the queue.  The first mechanism is to selectively
                            //       poll the queue for new messages.  The second mechanism is to define a callback/lambda expression and notify the
                            //       the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
                            //
                            // The following example demonstrates the first mechanism.
                            var subscriber = definition.CreateAWSSubscriber(queue);

                            // Poll the queue until we hit any key on the keyboard.
                            // Each poll will timeout after 2 seconds if not messages arrive.
                            Console.WriteLine("Attempt to retrieve research messages.  Hit any key to interrupt fetching...");
                            while (!Console.KeyAvailable)
                            {
                                subscriber.GetNextMessage(2, (research, s) => DisplayResearch(research));
                            }
                            Console.ReadKey();

                            // Prompt the user to delete the queue
                            Console.Write("\nDelete the queue (Y/N) [N]: ");
                            var delete = Console.ReadLine();
                            if (delete?.ToUpper() == "Y")
                            {
                                if (manager.DeleteQueue(queue))
                                {
                                    Console.WriteLine("Successfully deleted queue.");
                                }
                                else
                                {
                                    Console.WriteLine($"Issues deleting queue.");
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
            }
        }
Esempio n. 5
0
        static void Main(string[] args)
        {
            try
            {
                // Create the platform session.
                ISession session = GlobalSettings.Sessions.GetSession();

                // Open the session
                session.Open();

                // ********************************************************************************************
                // Headline Alert Endpoint URL.
                // ********************************************************************************************
                const string alertHeadlinesEndpoint = "https://api.refinitiv.com/alerts/v1/news-headlines-subscriptions";

                // Determine if we are using an existing queue or creating one.  The QueueManager will assist us here.
                IQueueManager manager = DeliveryFactory.CreateQueueManager(new QueueManager.Params().Session(session)
                                                                           .Endpoint(alertHeadlinesEndpoint)
                                                                           .OnError((qm, err) => Console.WriteLine(err)));

                // First, check to see if we have any news headline queues active in the cloud, if not, create one.
                List <IQueue> queues = manager.GetAllQueues();

                // Determine if we retrieved anything...create one if not.
                IQueue queue = (queues?.Count > 0 ? queues[0] : manager.CreateQueue());

                // Ensure our queue is created
                if (queue != null)
                {
                    Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue...");

                    // Start polling for news headline messages from the queue
                    // A QueueSubscriber provides the mechanisms to poll the queue and capture each headline alert via lambda expressions
                    IQueueSubscriber subscriber = DeliveryFactory.CreateQueueSubscriber(
                        new AWSQueueSubscriber.Params().Queue(queue)
                        .WithMessagePollingInterval(1)
                        .OnResponse((s, response) =>
                    {
                        if (response.IsSuccess)
                        {
                            DisplayHeadline(response.Data.Raw);
                        }
                        else
                        {
                            Console.WriteLine(response.Status);
                        }
                    }));

                    // Open the subscriber to begin polling for messages
                    subscriber.StartPolling();
                    Console.WriteLine("Polling for messages from the queue...hit any key to stop polling");

                    // Hit any key to stop...
                    Console.ReadKey();

                    // Close the subscription - stops polling for messages
                    subscriber.StopPolling();
                    Console.WriteLine($"{Environment.NewLine}Stopped polling for messages from the queue.");

                    // Prompt the user to delete the queue
                    Console.Write("Delete the queue (Y/N) [N]: ");
                    var delete = Console.ReadLine();
                    if (delete?.ToUpper() == "Y")
                    {
                        if (manager.DeleteQueue(queue))
                        {
                            Console.WriteLine("Successfully deleted queue.");
                        }
                        else
                        {
                            Console.WriteLine($"Issues deleting queue {manager.Error}");
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n***************");
            }
        }
        static void Main(string[] _)
        {
            const string newsStoriesEndpoint = "https://api.refinitiv.com/message-services/v1/news-stories/subscriptions";

            try
            {
                using (ISession session = Configuration.Sessions.GetSession())
                {
                    // Open the session
                    session.Open();

                    // Create our stories definition
                    var definition = Queue.Definition(newsStoriesEndpoint);

                    // Create a QueueManager to actively manage our queues
                    IQueueManager manager = definition.CreateQueueManager().OnError((err, qm) => Console.WriteLine(err));

                    // First, check to see if we have any news headline queues active in the cloud...
                    var queues = manager.GetAllQueues();

                    // If no existing queue exists, create one.
                    IQueueNode queue = (queues.Count > 0 ? queues[0] : manager.CreateQueue());

                    // Ensure our queue is created
                    if (queue != null)
                    {
                        Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue.  Waiting for stories...");

                        // Subscribe to the queue.
                        // Note: The subscriber interface has 2 mechanisms to retrieve data from the queue.  The first mechanism is to selectively
                        //       poll the queue for new messages.  The second mechanism is to define a callback/lambda expression and notify the
                        //       the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
                        //
                        // The following example demonstrates the second mechanism.
                        IQueueSubscriber subscriber = definition.CreateAWSSubscriber(queue);

                        // Open the subscriber to begin polling for messages. Use Async() as this method is a long running task.
                        var task = subscriber.StartPollingAsync((story, s) => DisplayStory(story));
                        Console.ReadKey();

                        // Close the subscription - stops polling for messages
                        subscriber.StopPolling();
                        task.GetAwaiter().GetResult();
                        Console.WriteLine("Stopped polling for messages from the queue.");

                        // Prompt the user to delete the queue
                        Console.Write("Delete the queue (Y/N) [N]: ");
                        var delete = Console.ReadLine();
                        if (delete?.ToUpper() == "Y")
                        {
                            if (manager.DeleteQueue(queue))
                            {
                                Console.WriteLine("Successfully deleted queue.");
                            }
                            else
                            {
                                Console.WriteLine($"Issues deleting queue.");
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
            }
        }
Esempio n. 7
0
        static void Main(string[] _)
        {
            const string researchEndpoint = "https://api.refinitiv.com/message-services/v1/research/subscriptions";

            try
            {
                using (ISession session = Configuration.Sessions.GetSession())
                {
                    if (session.Open() == Session.State.Opened)
                    {
                        // Create a QueueManager to actively manage our queues
                        IQueueManager manager = DeliveryFactory.CreateQueueManager(new QueueManager.Params().Session(session)
                                                                                   .Endpoint(researchEndpoint)
                                                                                   .OnError((qm, err) => Console.WriteLine(err)));

                        // First, check to see if we have any news headline queues active in the cloud...
                        List <IQueue> queues = manager.GetAllQueues();

                        // Check the error property to determine the result of the last request
                        if (manager.Error == null)
                        {
                            // Prepare Research criteria if we plan to create a new AWS queue - we must supply a research ID.
                            JObject criteria = new JObject()
                            {
                                ["transport"] = new JObject()
                                {
                                    ["transportType"] = "AWS-SQS"
                                },
                                ["payloadVersion"] = "2.0",
                                ["userID"]         = Configuration.Credentials.ResearchID
                            };

                            // If no existing queue exists, create one.
                            IQueue queue = (queues.Count > 0 ? queues[0] : manager.CreateQueue(criteria));

                            if (queue != null)
                            {
                                Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue...");

                                // Subscribe to the queue.
                                // Note: The subscriber interface has 2 mechanisms to retrieve data from the queue.  The first mechanism is to selectively
                                //       poll the queue for new messages.  The second mechanism is to define a callback/lambda expression and notify the
                                //       the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
                                //
                                // The following example demonstrates the first mechanism.
                                IQueueSubscriber subscriber = DeliveryFactory.CreateQueueSubscriber(new AWSQueueSubscriber.Params().Queue(queue));

                                Console.WriteLine("Attempt to retrieve research messages.  Hit any key to interrupt fetching...");

                                // Instead of defining a lambda callback, we manually poll the queue until we hit any key on the keyboard.
                                // Each poll will timeout after 5 seconds.
                                bool noMsgAvailable = false;
                                while (!Console.KeyAvailable)
                                {
                                    IQueueResponse result = subscriber.GetNextMessage(5);
                                    if (result.IsSuccess)
                                    {
                                        if (result.IsMessageAvailable)
                                        {
                                            DisplayResearch(result);
                                        }
                                        else
                                        {
                                            Console.Write(noMsgAvailable ? "." : "No Message available from GetNextMessage");
                                        }
                                        noMsgAvailable = !result.IsMessageAvailable;
                                    }
                                    else
                                    {
                                        Console.WriteLine(result.Status);
                                    }
                                }
                                Console.ReadKey();

                                // Prompt the user to delete the queue
                                Console.Write("\nDelete the queue (Y/N) [N]: ");
                                var delete = Console.ReadLine();
                                if (delete?.ToUpper() == "Y")
                                {
                                    if (manager.DeleteQueue(queue))
                                    {
                                        Console.WriteLine("Successfully deleted queue.");
                                    }
                                    else
                                    {
                                        Console.WriteLine($"Issues deleting queue {manager.Error}");
                                    }
                                }
                            }
                        }
                    }
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
            }
        }
Esempio n. 8
0
        static void Main(string[] _)
        {
            const string newsHeadlinesEndpoint = "https://api.refinitiv.com/message-services/v1/news-headlines/subscriptions";

            IQueueManager manager = null;
            IQueueNode    queue   = null;

            try
            {
                // Create the platform session.
                ISession session = Configuration.Sessions.GetSession();

                // Open the session
                session.Open();

                // Create a queue definition
                var definition = Queue.Definition(newsHeadlinesEndpoint);

                // Create a QueueManager to actively manage our queues
                manager = definition.CreateQueueManager().OnError((err, qm) => Console.WriteLine(err));

                // First, check to see if we have any news headline queues active in the cloud...
                List <IQueueNode> queues = manager.GetAllQueues();

                // Determine if we retrieved an active headline queue...create one if not.
                if (queues.Count > 0)
                {
                    queue = queues[0];
                }
                else
                {
                    // News Expression defining "Alerts only"
                    var alerts = new JObject()
                    {
                        ["repositories"] = new JArray("NewsWire"),
                        ["filter"]       = new JObject()
                        {
                            ["type"]  = "urgency",
                            ["value"] = "Alert"
                        },
                        ["maxcount"]       = 10,
                        ["relevanceGroup"] = "all"
                    };
                    queue = manager.CreateQueue(alerts);
                }

                // Ensure our queue is created
                if (queue != null)
                {
                    Console.WriteLine($"{Environment.NewLine}{(queues.Count > 0 ? "Using existing" : "Created a new")} queue.  Waiting for headlines...");

                    // Subscribe to the queue.
                    // Note: The subscriber interface has 2 mechanisms to retrieve data from the queue.  The first mechanism is to selectively
                    //       poll the queue for new messages.  The second mechanism is to define a callback/lambda expression and notify the
                    //       the subscriber to poll for messages as they come in - this mechansim provides a near realtime result.
                    //
                    // The following example demonstrates the first mechanism.
                    var subscriber = definition.CreateAWSSubscriber(queue);

                    // Poll the queue until we hit any key on the keyboard.
                    // Each poll will timeout after 2 seconds if no messages arrive.
                    var task = new CancellationTokenSource();
                    var run  = Task.Run(() =>
                    {
                        try
                        {
                            while (!task.IsCancellationRequested)
                            {
                                subscriber.GetNextMessage(20, (headline, s) => DisplayHeadline(headline), task.Token);
                            }
                        }
                        catch (TaskCanceledException)
                        {
                            Console.WriteLine("News polling cancelled by user");
                        }
                    });

                    Console.ReadKey();
                    task.Cancel();
                    run.GetAwaiter().GetResult();
                }
            }
            catch (Exception e)
            {
                Console.WriteLine($"\n**************\nFailed to execute: {e.Message}\n{e.InnerException}\n***************");
            }
            finally
            {
                if (manager is IQueueManager && queue is IQueueNode)
                {
                    // Prompt the user to delete the queue
                    Console.Write("\nDelete the queue (Y/N) [N]: ");
                    var delete = Console.ReadLine();
                    if (delete?.ToUpper() == "Y")
                    {
                        if (manager.DeleteQueue(queue))
                        {
                            Console.WriteLine("Successfully deleted queue.");
                        }
                        else
                        {
                            Console.WriteLine($"Issues deleting queue.");
                        }
                    }
                }
            }
        }