void rdpClient_FatalErrorOccurred(object sender, FatalErrorEventArgs e)
 {
     if (FatalErrorOccurred != null)
     {
         FatalErrorOccurred(this, e);
     }
 }
Exemple #2
0
 private static void OnFatalError(object o, FatalErrorEventArgs args)
 {
     try {
         ValuesStorage.Remove("MainWindow_link");
         ValuesStorage.Remove("MainWindow__drive");
     } catch {
         // ignored
     }
 }
Exemple #3
0
        public static void NotifyOnError(string errorMessage)
        {
            var args = new FatalErrorEventArgs()
            {
                ErrorMessage = errorMessage
            };

            OnFatalError?.Invoke(null, args);
        }
Exemple #4
0
        private void KcvdbClient_FatalError(object sender, FatalErrorEventArgs e)
        {
            try {
                shouldStopSending_ = true;

                TelemetryClient.TrackException("KCVDB Fatal error catched", e.Exception, new {
                    ErrorMessage = e.Message,
                });
            }
            catch (Exception ex) {
                if (ex.IsCritical())
                {
                    throw;
                }
            }
        }
Exemple #5
0
        /// <summary>
        /// Checks that ExtractionRequestQueueConsumer publishes messages correctly according to the input message isIdentifiableExtraction value
        /// </summary>
        /// <param name="globals"></param>
        /// <param name="isIdentifiableExtraction"></param>
        /// <param name="expectedRoutingKey"></param>
        private static void AssertMessagePublishedWithSpecifiedKey(GlobalOptions globals, bool isIdentifiableExtraction, string expectedRoutingKey)
        {
            var fakeFulfiller = new FakeFulfiller();

            var    mockFileMessageProducerModel = new Mock <IProducerModel>(MockBehavior.Strict);
            string fileMessageRoutingKey        = null;

            mockFileMessageProducerModel
            .Setup(x => x.SendMessage(It.IsAny <IMessage>(), It.IsAny <IMessageHeader>(), It.IsNotNull <string>()))
            .Callback((IMessage _, IMessageHeader __, string routingKey) => { fileMessageRoutingKey = routingKey; })
            .Returns(new MessageHeader());
            mockFileMessageProducerModel.Setup(x => x.WaitForConfirms());

            var mockFileInfoMessageProducerModel = new Mock <IProducerModel>(MockBehavior.Strict);

            mockFileInfoMessageProducerModel
            .Setup(x => x.SendMessage(It.IsAny <IMessage>(), It.IsAny <IMessageHeader>(), It.IsNotNull <string>()))
            .Returns(new MessageHeader());
            mockFileInfoMessageProducerModel.Setup(x => x.WaitForConfirms());

            var msg = new ExtractionRequestMessage
            {
                JobSubmittedAt           = DateTime.UtcNow,
                ExtractionJobIdentifier  = Guid.NewGuid(),
                ProjectNumber            = "1234",
                ExtractionDirectory      = "1234/foo",
                IsIdentifiableExtraction = isIdentifiableExtraction,
                KeyTag = "foo",
                ExtractionIdentifiers = new List <string> {
                    "foo"
                },
                Modality = null,
            };
            var mockDeliverArgs = Mock.Of <BasicDeliverEventArgs>(MockBehavior.Strict);

            mockDeliverArgs.DeliveryTag     = 1;
            mockDeliverArgs.Body            = Encoding.UTF8.GetBytes(JsonConvert.SerializeObject(msg));
            mockDeliverArgs.BasicProperties = new BasicProperties {
                Headers = new Dictionary <string, object>()
            };
            var header = new MessageHeader();

            header.Populate(mockDeliverArgs.BasicProperties.Headers);
            // Have to convert these to bytes since RabbitMQ normally does that when sending
            mockDeliverArgs.BasicProperties.Headers["MessageGuid"]            = Encoding.UTF8.GetBytes(header.MessageGuid.ToString());
            mockDeliverArgs.BasicProperties.Headers["ProducerExecutableName"] = Encoding.UTF8.GetBytes(header.ProducerExecutableName);
            mockDeliverArgs.BasicProperties.Headers["Parents"] = Encoding.UTF8.GetBytes(string.Join("->", header.Parents));

            var consumer = new ExtractionRequestQueueConsumer(
                globals.CohortExtractorOptions,
                fakeFulfiller,
                new NullAuditExtractions(), new DefaultProjectPathResolver(),
                mockFileMessageProducerModel.Object,
                mockFileInfoMessageProducerModel.Object);

            var fatalCalled = false;
            FatalErrorEventArgs fatalErrorEventArgs = null;

            consumer.OnFatal += (sender, args) =>
            {
                fatalCalled         = true;
                fatalErrorEventArgs = args;
            };

            var mockModel = new Mock <IModel>(MockBehavior.Strict);

            mockModel.Setup(x => x.IsClosed).Returns(false);
            mockModel.Setup(x => x.BasicAck(It.IsAny <ulong>(), It.IsAny <bool>())).Verifiable();

            consumer.SetModel(mockModel.Object);
            consumer.ProcessMessage(mockDeliverArgs);

            Thread.Sleep(500); // Fatal call is race-y
            Assert.False(fatalCalled, $"Fatal was called with {fatalErrorEventArgs}");
            mockModel.Verify(x => x.BasicAck(It.IsAny <ulong>(), It.IsAny <bool>()), Times.Once);
            Assert.AreEqual(expectedRoutingKey, fileMessageRoutingKey);
        }
        public static IEnumerable<KCVDBApiItem> CreateInstance(FatalErrorEventArgs fatalArgs)
        {
            var item = new KCVDBApiItem();
            item.Date = DateTime.Now;
            item.SendStatus = KCVDBSendStatus.FatalError;
            item.ErrorMessage = fatalArgs.Message;

            yield return item;
        }