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);
}
}
