public void AuditCommandConsumer_Consume_ResumeExecution() { var workflowId = Guid.NewGuid().ToString(); var audit = new Audit { WorkflowID = workflowId, }; object parameters = new object(); var auditCommand = new AuditCommand { Type = "LogResumeExecutionState", Audit = audit, }; var mockLoggerConsumer = new Mock <ILoggerConsumer <IAuditEntry> >(); mockLoggerConsumer.Setup(o => o.Consume(auditCommand.Audit, parameters)).Verifiable(); var mockSocket = new Mock <IWebSocketConnection>(); var mockWriter = new Mock <IWriter>(); mockWriter.Setup(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type)).Verifiable(); mockWriter.Setup(o => o.WriteLine("Resuming workflow: " + auditCommand.Audit.WorkflowID)).Verifiable(); var auditCommandConsumer = new AuditCommandConsumer(mockLoggerConsumer.Object, mockSocket.Object, mockWriter.Object); auditCommandConsumer.Consume(auditCommand, parameters); mockLoggerConsumer.Verify(o => o.Consume(auditCommand.Audit, parameters), Times.Once); mockWriter.Verify(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type), Times.Once); mockWriter.Verify(o => o.WriteLine("Resuming workflow: " + auditCommand.Audit.WorkflowID), Times.Once); }
private void SendMessage(LogEntry logEntry) { if (IsValidLogLevel(logEntry.LogLevel.ToString())) { IWebSocketWrapper _ws = null; try { _ws = _webSocketPool.Acquire(Dev2.Common.Config.Auditing.Endpoint); if (!_ws.IsOpen()) { _ws.Connect(); } var logCommand = new AuditCommand { Type = "LogEntryCommand", LogEntry = logEntry }; var msg = _serializer.Serialize(logCommand); _ws.SendMessage(msg); } finally { _webSocketPool.Release(_ws); } } }
public void AuditCommandConsumer_Consume_ExecutionAuditCommand() { var resourceId = Guid.NewGuid(); var executionHistory = new ExecutionHistory { ResourceId = resourceId, }; object parameters = new object(); var auditCommand = new AuditCommand { Type = "ExecutionAuditCommand", ExecutionHistory = executionHistory, }; var mockLoggerConsumer = new Mock <ILoggerConsumer <IAuditEntry> >(); mockLoggerConsumer.Setup(o => o.Consume(auditCommand.ExecutionHistory, parameters)).Verifiable(); var mockSocket = new Mock <IWebSocketConnection>(); var mockWriter = new Mock <IWriter>(); mockWriter.Setup(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type)).Verifiable(); mockWriter.Setup(o => o.WriteLine(auditCommand.ExecutionHistory.ResourceId.ToString())).Verifiable(); var auditCommandConsumer = new AuditCommandConsumer(mockLoggerConsumer.Object, mockSocket.Object, mockWriter.Object); auditCommandConsumer.Consume(auditCommand, parameters); mockLoggerConsumer.Verify(o => o.Consume(auditCommand.ExecutionHistory, parameters), Times.Once); mockWriter.Verify(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type), Times.Once); mockWriter.Verify(o => o.WriteLine(auditCommand.ExecutionHistory.ResourceId.ToString()), Times.Once); }
public override StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace) { IWebSocketWrapper client = null; try { var serializer = new Dev2JsonSerializer(); var result = new List <IExecutionHistory>(); if (values == null) { throw new InvalidDataContractException(ErrorResource.NoParameter); } values.TryGetValue("ResourceId", out StringBuilder triggerID); if (triggerID != null) { client = _webSocketPool.Acquire(Config.Auditing.Endpoint).Connect(); Dev2Logger.Info("Get Execution History Data from Logger Service. " + triggerID, GlobalConstants.WarewolfInfo); var response = ""; var message = new AuditCommand { Type = "TriggerQuery", Query = values }; try { var ewh = new EventWaitHandle(false, EventResetMode.ManualReset); client.OnMessage((msgResponse, socket) => { response = msgResponse; result.AddRange(serializer.Deserialize <List <ExecutionHistory> >(response)); ewh.Set(); }); client.SendMessage(serializer.Serialize(message)); ewh.WaitOne(_waitTimeOut); return(serializer.SerializeToBuilder(result)); } catch (Exception e) { Dev2Logger.Info("Get Execution History Data ServiceError", e, GlobalConstants.WarewolfInfo); } return(serializer.SerializeToBuilder(result)); } Dev2Logger.Debug("No QueueName Provided", GlobalConstants.WarewolfDebug); return(serializer.SerializeToBuilder(new List <IExecutionHistory>())); } catch (Exception err) { Dev2Logger.Error(err, GlobalConstants.WarewolfError); throw; } finally { if (client != null) { _webSocketPool.Release(client); } } }
public void AuditCommandConsumer_Consume_LogEntryCommand() { const string outputTemplate = ""; var logEntry = new LogEntry(LogLevel.Info, outputTemplate, null); object parameters = new object(); var auditCommand = new AuditCommand { Type = "LogEntryCommand", LogEntry = logEntry, }; var mockLoggerConsumer = new Mock <ILoggerConsumer <IAuditEntry> >(); mockLoggerConsumer.Setup(o => o.Consume(auditCommand.LogEntry, parameters)).Verifiable(); var mockSocket = new Mock <IWebSocketConnection>(); var mockWriter = new Mock <IWriter>(); mockWriter.Setup(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type)).Verifiable(); mockWriter.Setup(o => o.WriteLine(auditCommand.LogEntry.OutputTemplate)).Verifiable(); var auditCommandConsumer = new AuditCommandConsumer(mockLoggerConsumer.Object, mockSocket.Object, mockWriter.Object); auditCommandConsumer.Consume(auditCommand, parameters); mockLoggerConsumer.Verify(o => o.Consume(auditCommand.LogEntry, parameters), Times.Once); mockWriter.Verify(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type), Times.Once); mockWriter.Verify(o => o.WriteLine(auditCommand.LogEntry.OutputTemplate), Times.Once); }
public async Task <Unit> Handle(CreateAuditCommand command, CancellationToken cancellationToken) { var auditCommand = AuditCommand.Create(command, _authentificationContext, _auditSerializer); _dbContext.AuditCommands.Add(auditCommand); await _dbContext.SaveChangesAsync(); return(Unit.Value); }
private void LogExecutionCompleted(ExecutionHistory executionHistory) { var command = new AuditCommand { Type = "ExecutionAuditCommand", ExecutionHistory = executionHistory }; Publish(Serializer.Serialize(command)); }
public void LogResumedExecution(IAudit values) { var command = new AuditCommand { Type = values.AuditType, Audit = values as Audit }; Publish(Serializer.Serialize(command)); }
public void AuditCommandConsumer_Consume_LogQuery() { object parameters = new object(); var auditCommand = new AuditCommand { Type = "LogQuery", Query = new Dictionary <string, StringBuilder>(), }; byte[] expected = new byte[] {}; var mockLoggerConsumer = new Mock <ILoggerConsumer <IAuditEntry> >(); var mockSocket = new Mock <IWebSocketConnection>(); mockSocket.Setup(o => o.Send(expected)).Verifiable(); IEnumerable <IAudit> audits = new List <IAudit>(); var mockWriter = new Mock <IWriter>(); mockWriter.Setup(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type)).Verifiable(); mockWriter.Setup(o => o.WriteLine("Executing query: " + auditCommand.Query)).Verifiable(); mockWriter.Setup(o => o.WriteLine("sending QueryLog to server: " + audits + "...")).Verifiable(); var mockSerializer = new Mock <ISerializer>(); mockSerializer.Setup(o => o.Serialize(audits)).Returns(expected); mockSerializer.Setup(o => o.Serialize(audits)).Verifiable(); var mockAuditQueryable = new Mock <IAuditQueryable>(); mockAuditQueryable.Setup(o => o.QueryLogData(auditCommand.Query)).Returns(audits); var auditCommandConsumer = new AuditCommandConsumer(mockLoggerConsumer.Object, mockSocket.Object, mockWriter.Object, mockSerializer.Object, mockAuditQueryable.Object); auditCommandConsumer.Consume(auditCommand, parameters); mockWriter.Verify(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type), Times.Once); mockWriter.Verify(o => o.WriteLine("Executing query: " + auditCommand.Query), Times.Once); mockWriter.Verify(o => o.WriteLine("sending QueryLog to server: " + audits + "..."), Times.Once); mockSocket.Verify(o => o.Send(expected), Times.Once); mockSerializer.Verify(o => o.Serialize(audits), Times.Once); }
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace) { IWebSocketWrapper client = null; Dev2Logger.Info("Get Log Data Service", GlobalConstants.WarewolfInfo); var serializer = new Dev2JsonSerializer(); var result = new List <Audit>(); var response = ""; var message = new AuditCommand() { Type = "LogQuery", Query = values }; try { client = _webSocketPool.Acquire(Config.Auditing.Endpoint).Connect(); var ewh = new EventWaitHandle(false, EventResetMode.ManualReset); client.OnMessage((msgResponse, socket) => { response = msgResponse; result.AddRange(serializer.Deserialize <List <Audit> >(response)); ewh.Set(); }); client.SendMessage(serializer.Serialize(message)); ewh.WaitOne(_waitTimeOut); LogDataCache.CurrentResults = result; return(serializer.SerializeToBuilder(result)); } catch (Exception e) { Dev2Logger.Info("Get Log Data ServiceError", e, GlobalConstants.WarewolfInfo); } finally { _webSocketPool.Release(client); } return(serializer.SerializeToBuilder("")); }
public void AuditCommandConsumer_Consume_Default() { object parameters = new object(); var auditCommand = new AuditCommand { Type = "", }; var mockLoggerConsumer = new Mock <ILoggerConsumer <IAuditEntry> >(); var mockSocket = new Mock <IWebSocketConnection>(); var mockWriter = new Mock <IWriter>(); mockWriter.Setup(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type)).Verifiable(); mockWriter.Setup(o => o.WriteLine("Logging Server Invalid Message Type")).Verifiable(); var auditCommandConsumer = new AuditCommandConsumer(mockLoggerConsumer.Object, mockSocket.Object, mockWriter.Object); auditCommandConsumer.Consume(auditCommand, parameters); mockWriter.Verify(o => o.WriteLine("Logging Server OnMessage: Type:" + auditCommand.Type), Times.Once); mockWriter.Verify(o => o.WriteLine("Logging Server Invalid Message Type"), Times.Once); }
public void SeriLogPublisher_NewPublisher_Reading_LogData_From_Elasticsearch_Success() { //-------------------------Arrange------------------------------ var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch); var hostName = "http://" + dependency.Container.IP; var loggerSource = new SerilogElasticsearchSource { Port = DefaultPort, HostName = hostName, SearchIndex = "warewolftestlogs" }; var uri = new Uri(hostName + ":" + DefaultPort); var logger = new LoggerConfiguration() .MinimumLevel.Verbose() .WriteTo.Sink(new ElasticsearchSink(new ElasticsearchSinkOptions(uri) { AutoRegisterTemplate = true, IndexDecider = (e, o) => loggerSource.SearchIndex, })) .CreateLogger(); var mockSeriLogConfig = new Mock <ISeriLogConfig>(); mockSeriLogConfig.SetupGet(o => o.Logger).Returns(logger); var executionID = Guid.NewGuid(); using (var loggerConnection = loggerSource.NewConnection(mockSeriLogConfig.Object)) { var loggerPublisher = loggerConnection.NewPublisher(); var mockDataObject = SetupDataObjectWithAssignedInputs(executionID); var auditLog = new Audit(mockDataObject.Object, "LogAdditionalDetail", "Test", null, null); var logEntryCommand = new AuditCommand { Audit = auditLog, Type = "LogEntry" }; //-------------------------Act---------------------------------- loggerPublisher.Info(GlobalConstants.WarewolfLogsTemplate, logEntryCommand); } Task.Delay(500).Wait(); //-------------------------Assert------------------------------------ var dataFromDb = new TestElasticsearchDatabase(); var dataList = dataFromDb.GetPublishedData(loggerSource, executionID.ToString()).ToList(); Assert.AreEqual(1, dataList.Count); foreach (Dictionary <string, object> fields in dataList) { var level = fields.Where(pair => pair.Key.Contains("level")).Select(pair => pair.Value).FirstOrDefault(); Assert.AreEqual("Information", level.ToString()); var messageTemplate = fields.Where(pair => pair.Key.Contains("messageTemplate")).Select(pair => pair.Value).FirstOrDefault(); Assert.AreEqual("{@Data}", messageTemplate.ToString()); var message = fields.Where(pair => pair.Key.Contains("message")); Assert.IsNotNull(message); } }