static ValidationResult CanConnectServer(ElasticsearchSource source)
{
try
{
var uri = new Uri(source.HostName + ":" + source.Port);
var isValid = false;
var errorMessage = "";
var settings = new ConnectionSettings(uri).RequestTimeout(TimeSpan.FromMinutes(2));
if (source.AuthenticationType == AuthenticationType.Password)
{
settings.BasicAuthentication(source.Username, source.Password);
}
var client = new ElasticClient(settings);
var result = client.Ping();
isValid = result.IsValid;
if (!isValid)
{
errorMessage = "could not connect to elasticsearch Instance";
}
return(new ValidationResult
{
IsValid = isValid,
ErrorMessage = errorMessage
});
}
catch (Exception e)
{
return(new ValidationResult
{
IsValid = false,
ErrorMessage = e.InnerException != null?string.Join(Environment.NewLine, e.Message, e.InnerException.Message) : e.Message
});
}
}
public void ElasticsearchSource_Validate_ToXml_AuthenticationType_Password()
{
const string xmlString = @"<Source ID=""1a82a341-b678-4992-a25a-39cdd57198d4"" Name=""Example Elasticsearch Source"" ResourceType=""ElasticsearchSource"" IsValid=""false""
ConnectionString=""HostName=localhost;Port=9200;UserName=test;Password=test;AuthenticationType=Password"" Type=""ElasticsearchSource"" ServerVersion=""1.4.1.27"" ServerID=""693ca20d-fb17-4044-985a-df3051d6bac7"">
<DisplayName>Example Elasticsearch Source</DisplayName>
<AuthorRoles>
</AuthorRoles>
<ErrorMessages />
<TypeOf>ElasticsearchSource</TypeOf>
<VersionInfo DateTimeStamp=""2017-05-26T14:21:24.3247847+02:00"" Reason="""" User=""NT AUTHORITY\SYSTEM"" VersionNumber=""3"" ResourceId=""1a82a341-b678-4992-a25a-39cdd57198d4"" VersionId=""b1a6de00-3cac-41cd-b0ed-9fac9bb61266"" />
</Source>";
var xElement = XElement.Parse(xmlString);
var elasticsearchSource = new ElasticsearchSource(xElement);
var result = elasticsearchSource.ToXml();
var elasticsearchSourceWithXml = new ElasticsearchSource(result);
Assert.AreEqual(nameof(ElasticsearchSource), elasticsearchSourceWithXml.ResourceType);
Assert.AreEqual("9200", elasticsearchSourceWithXml.Port);
Assert.AreEqual("localhost", elasticsearchSourceWithXml.HostName);
Assert.AreEqual("test", elasticsearchSourceWithXml.Password);
Assert.AreEqual("test", elasticsearchSourceWithXml.Username);
Assert.AreEqual(AuthenticationType.Password, elasticsearchSourceWithXml.AuthenticationType);
}
public void ElasticsearchSources_Test_With_ValidHost_AuthenticationType_Anonymous_Expected_ValidValidationResult()
{
try
{
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
var source = new ElasticsearchSource
{
HostName = hostName,
Port = dependency.Container.Port,
AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Anonymous
}.ToString();
var handler = new ElasticsearchSources();
var result = handler.Test(source);
Assert.IsTrue(result.IsValid, result.ErrorMessage);
}
catch (Exception e)
{
if (e.Message.Contains("could not connect to elasticsearch Instance"))
{
Assert.Inconclusive(e.Message);
}
else
{
throw;
}
}
}
public void ElasticsearchSources_Test_With_InvalidHost_AuthenticationType_Anonymous_Expected_InvalidValidationResult()
{
var source = new ElasticsearchSource
{
HostName = "http://ddd",
AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Anonymous,
Port = "9200"
}.ToString();
try
{
var handler = new ElasticsearchSources();
var result = handler.Test(source);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("could not connect to elasticsearch Instance", result.ErrorMessage);
}
catch (Exception e)
{
if (e.Message.Contains("could not connect to elasticsearch Instance"))
{
Assert.Inconclusive(e.Message);
}
else
{
throw;
}
}
}
public void AuditingSettingsData_Set_Get_LoggingDataSource()
{
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
var source = new ElasticsearchSource
{
AuthenticationType = AuthenticationType.Anonymous,
Port = dependency.Container.Port,
HostName = hostName,
SearchIndex = "warewolflogstests"
};
var serializer = new Dev2JsonSerializer();
var jsonSource = serializer.Serialize(source);
var expectedAuditingSettingsData = new AuditingSettingsData
{
Endpoint = "ws://127.0.0.1:5000/ws",
EncryptDataSource = true,
LoggingDataSource = new NamedGuidWithEncryptedPayload
{
Name = "Data Source",
Value = Guid.Empty,
Payload = jsonSource
},
};
IDeserializer deserializer = new JsonSerializer();
var bytes = UTF8Encoding.UTF8.GetBytes(expectedAuditingSettingsData.LoggingDataSource.Payload);
var result = deserializer.Deserialize <ElasticsearchSource>(bytes);
Assert.AreEqual(expectedAuditingSettingsData.LoggingDataSource.Value, Guid.Empty);
Assert.AreEqual(expectedAuditingSettingsData.LoggingDataSource.Name, "Data Source");
Assert.AreEqual(source, result);
}
public IElasticsearchSourceDefinition FetchSource(Guid id)
{
var xaml = _queryManager.FetchResourceXaml(id);
var source = new ElasticsearchSource(xaml.ToXElement());
var def = new ElasticsearchSourceDefinition(source);
return(def);
}
static LogSettingsViewModel CreateLogSettingViewModel()
{
XmlConfigurator.ConfigureAndWatch(new FileInfo("Settings.config"));
var loggingSettingsTo = new LoggingSettingsTo {
FileLoggerLogSize = 50, FileLoggerLogLevel = "TRACE"
};
var _resourceRepo = new Mock <IResourceRepository>();
var env = new Mock <IServer>();
var expectedServerSettingsData = new ServerSettingsData
{
ExecutionLogLevel = LogLevel.DEBUG.ToString(),
Sink = "AuditingSettingsData"
};
_resourceRepo.Setup(res => res.GetServerSettings(env.Object)).Returns(expectedServerSettingsData);
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
var elasticsearchSource = new ElasticsearchSource
{
AuthenticationType = AuthenticationType.Anonymous,
Port = dependency.Container.Port,
HostName = hostName,
SearchIndex = "warewolflogstests"
};
var jsonSource = JsonConvert.SerializeObject(elasticsearchSource);
var auditingSettingsData = new AuditingSettingsData
{
Endpoint = "ws://127.0.0.1:5000/ws",
EncryptDataSource = true,
LoggingDataSource = new NamedGuidWithEncryptedPayload
{
Name = "Auditing Data Source",
Value = Guid.Empty,
Payload = jsonSource
},
};
_resourceRepo.Setup(res => res.GetAuditingSettings <AuditingSettingsData>(env.Object)).Returns(auditingSettingsData);
var selectedAuditingSourceId = Guid.NewGuid();
var mockAuditingSource = new Mock <IResource>();
mockAuditingSource.Setup(source => source.ResourceID).Returns(selectedAuditingSourceId);
var auditingSources = new Mock <IResource>();
var expectedList = new List <IResource>
{
mockAuditingSource.Object, auditingSources.Object
};
_resourceRepo.Setup(resourceRepository => resourceRepository.FindResourcesByType <IAuditingSource>(env.Object)).Returns(expectedList);
env.Setup(a => a.ResourceRepository).Returns(_resourceRepo.Object);
var logSettingsViewModel = new LogSettingsViewModel(loggingSettingsTo, env.Object);
return(logSettingsViewModel);
}
public void ElasticsearchSource_Constructor_Validate_DefaultValues()
{
var elasticsearchSource = new ElasticsearchSource();
Assert.IsNotNull(elasticsearchSource.ResourceID);
Assert.AreEqual(Guid.Empty, elasticsearchSource.ResourceID);
Assert.AreEqual(nameof(ElasticsearchSource), elasticsearchSource.ResourceType);
Assert.AreEqual("9200", elasticsearchSource.Port);
Assert.AreEqual(AuthenticationType.Anonymous, elasticsearchSource.AuthenticationType);
}
public void ElasticsearchSource_Validate_DefaultValues()
{
var elasticsearchSource = new ElasticsearchSource();
Assert.IsTrue(elasticsearchSource.IsSource);
Assert.IsFalse(elasticsearchSource.IsService);
Assert.IsFalse(elasticsearchSource.IsFolder);
Assert.IsFalse(elasticsearchSource.IsReservedService);
Assert.IsFalse(elasticsearchSource.IsServer);
Assert.IsFalse(elasticsearchSource.IsResourceVersion);
}
public void ElasticsearchSources_TestWithValidArgs_Expected_Valid_ValidationResult()
{
var handler = new ElasticsearchSources();
var elasticsearchSource = new ElasticsearchSource();
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
elasticsearchSource.HostName = hostName;
var result = handler.Test(elasticsearchSource);
Assert.IsTrue(result.IsValid);
}
public ValidationResult Test(ElasticsearchSource source)
{
try
{
return(CanConnectServer(source));
}
catch (Exception ex)
{
RaiseError(ex);
return(new ValidationResult {
IsValid = false, ErrorMessage = ex.Message
});
}
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Save Elasticsearch Resource Service", GlobalConstants.WarewolfInfo);
values.TryGetValue(Warewolf.Service.SaveElasticsearchSource.ElasticsearchSource, out StringBuilder resourceDefinition);
IElasticsearchSourceDefinition elasticsearchSourceDef = serializer.Deserialize <ElasticsearchSourceDefinition>(resourceDefinition);
if (elasticsearchSourceDef.Path == null)
{
elasticsearchSourceDef.Path = string.Empty;
}
if (elasticsearchSourceDef.Path.EndsWith("\\"))
{
elasticsearchSourceDef.Path = elasticsearchSourceDef.Path.Substring(0, elasticsearchSourceDef.Path.LastIndexOf("\\", StringComparison.Ordinal));
}
var elasticsearchSource = new ElasticsearchSource
{
ResourceID = elasticsearchSourceDef.Id,
HostName = elasticsearchSourceDef.HostName,
Port = elasticsearchSourceDef.Port,
SearchIndex = elasticsearchSourceDef.SearchIndex,
AuthenticationType = elasticsearchSourceDef.AuthenticationType,
Password = elasticsearchSourceDef.Password,
Username = elasticsearchSourceDef.Username,
ResourceName = elasticsearchSourceDef.Name
};
ResourceCat.SaveResource(GlobalConstants.ServerWorkspaceID, elasticsearchSource, elasticsearchSourceDef.Path);
msg.HasError = false;
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public void ElasticsearchSources_Test_With_InvalidHost_AuthenticationType_Password_Expected_InvalidValidationResult()
{
var source = new ElasticsearchSource
{
HostName = "http://ddd",
Port = "9300",
AuthenticationType = Dev2.Runtime.ServiceModel.Data.AuthenticationType.Password,
Password = "******",
Username = "******"
}.ToString();
var handler = new ElasticsearchSources();
var result = handler.Test(source);
Assert.IsFalse(result.IsValid);
Assert.AreEqual("could not connect to elasticsearch Instance", result.ErrorMessage);
}
public ElasticsearchSource Get(string resourceId, Guid workspaceId)
{
var result = new ElasticsearchSource();
try
{
var xmlStr = ResourceCatalog.Instance.GetResourceContents(workspaceId, Guid.Parse(resourceId)).ToString();
if (!string.IsNullOrEmpty(xmlStr))
{
var xml = XElement.Parse(xmlStr);
result = new ElasticsearchSource(xml);
}
}
catch (Exception ex)
{
RaiseError(ex);
}
return(result);
}
private static ILoggerContext ConstructLoggerContext(IArgs args, out ElasticsearchSource elasticsearchSource)
{
var mockArgs = new Mock <IArgs>();
mockArgs.Setup(o => o.ServerEndpoint).Returns(args.ServerEndpoint);
mockArgs.Setup(o => o.Verbose).Returns(args.Verbose);
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
elasticsearchSource = new ElasticsearchSource
{
ResourceID = Guid.Empty,
ResourceType = "ElasticsearchSource",
AuthenticationType = AuthenticationType.Anonymous,
Port = dependency.Container.Port,
HostName = hostName,
SearchIndex = "warewolflogstests"
};
var serializer = new Dev2JsonSerializer();
var payload = serializer.Serialize(elasticsearchSource);
var encryptedPayload = DpapiWrapper.Encrypt(payload);
var data = new AuditingSettingsData
{
EncryptDataSource = true,
LoggingDataSource = new NamedGuidWithEncryptedPayload
{
Name = "Testing Elastic Data Source",
Value = Guid.Empty,
Payload = encryptedPayload
}
};
Config.Auditing.LoggingDataSource = data.LoggingDataSource;
Config.Auditing.EncryptDataSource = data.EncryptDataSource;
Config.Server.Sink = nameof(AuditingSettingsData);
return(new LoggerContext(mockArgs.Object));
}
public StringBuilder Execute(Dictionary <string, StringBuilder> values, IWorkspace theWorkspace)
{
var msg = new ExecuteMessage();
var serializer = new Dev2JsonSerializer();
try
{
Dev2Logger.Info("Test Elasticsearch Source", GlobalConstants.WarewolfInfo);
msg.HasError = false;
values.TryGetValue(Warewolf.Service.TestElasticsearchSource.ElasticsearchSource, out StringBuilder resourceDefinition);
var elasticsearchServiceSourceDefinition = serializer.Deserialize <ElasticsearchSourceDefinition>(resourceDefinition);
var con = new ElasticsearchSources();
using (var elasticsearchSource = new ElasticsearchSource
{
HostName = elasticsearchServiceSourceDefinition.HostName,
Port = elasticsearchServiceSourceDefinition.Port,
Password = elasticsearchServiceSourceDefinition.Password,
Username = elasticsearchServiceSourceDefinition.Username,
AuthenticationType = elasticsearchServiceSourceDefinition.AuthenticationType,
SearchIndex = elasticsearchServiceSourceDefinition.SearchIndex
})
{
var result = con.Test(elasticsearchSource);
msg.HasError = false;
msg.Message = new StringBuilder(result.IsValid ? serializer.Serialize(result.Result) : result.ErrorMessage);
msg.HasError = !result.IsValid;
}
}
catch (Exception err)
{
msg.HasError = true;
msg.Message = new StringBuilder(err.Message);
Dev2Logger.Error(err, GlobalConstants.WarewolfError);
}
return(serializer.SerializeToBuilder(msg));
}
public void SaveElasticsearchSource_Execute_GivenResourceDefination_GivenExising_ShouldReturnResourceDefinationMsg()
{
//---------------Set up test pack-------------------
var serializer = new Dev2JsonSerializer();
var source = new ElasticsearchSourceDefinition()
{
Id = Guid.Empty,
Name = "Name",
HostName = "HostName",
Port = "3679",
AuthenticationType = AuthenticationType.Anonymous,
SearchIndex = "warewolflogs"
};
var compressedExecuteMessage = new CompressedExecuteMessage();
var serializeToJsonString = source.SerializeToJsonString(new DefaultSerializationBinder());
compressedExecuteMessage.SetMessage(serializeToJsonString);
var values = new Dictionary <string, StringBuilder>
{
{ "ElasticsearchSource", source.SerializeToJsonStringBuilder() }
};
var catalog = new Mock <IResourceCatalog>();
var elasticsearchSource = new ElasticsearchSource();
catalog.Setup(resourceCatalog => resourceCatalog.GetResource(It.IsAny <Guid>(), source.Name)).Returns(elasticsearchSource);
catalog.Setup(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), elasticsearchSource, It.IsAny <string>()));
var saveElasticsearchSource = new SaveElasticsearchSource(catalog.Object);
//---------------Assert Precondition----------------
//---------------Execute Test ----------------------
var jsonResult = saveElasticsearchSource.Execute(values, null);
var result = serializer.Deserialize <ExecuteMessage>(jsonResult);
//---------------Test Result -----------------------
Assert.IsFalse(result.HasError);
catalog.Verify(resourceCatalog => resourceCatalog.SaveResource(It.IsAny <Guid>(), elasticsearchSource, It.IsAny <string>()));
}
static LogSettingsViewModel CreateLogSettingViewModel(string sink, Mock <IResourceRepository> _resourceRepo = null)
{
XmlConfigurator.ConfigureAndWatch(new FileInfo("Settings.config"));
var loggingSettingsTo = new LoggingSettingsTo {
FileLoggerLogSize = 50, FileLoggerLogLevel = "TRACE", EventLogLoggerLogLevel = "DEBUG"
};
var env = new Mock <IServer>();
if (_resourceRepo is null)
{
_resourceRepo = new Mock <IResourceRepository>();
}
var expectedServerSettingsData = new ServerSettingsData
{
Sink = sink,
ExecutionLogLevel = LogLevel.DEBUG.ToString()
};
_resourceRepo.Setup(res => res.GetServerSettings(env.Object)).Returns(expectedServerSettingsData);
var selectedAuditingSourceId = Guid.NewGuid();
if (sink == "LegacySettingsData")
{
var legacySettingsData = new LegacySettingsData()
{
AuditFilePath = "somePath"
};
_resourceRepo.Setup(res => res.GetAuditingSettings <LegacySettingsData>(env.Object)).Returns(legacySettingsData);
_resourceRepo.Setup(res => res.SaveAuditingSettings(env.Object, legacySettingsData)).Verifiable();
}
else
{
var dependency = new Depends(Depends.ContainerType.AnonymousElasticsearch);
var hostName = "http://" + dependency.Container.IP;
var elasticsearchSource = new ElasticsearchSource
{
AuthenticationType = AuthenticationType.Anonymous,
Port = dependency.Container.Port,
HostName = hostName,
SearchIndex = "warewolflogstests"
};
var serializer = new Dev2JsonSerializer();
var payload = serializer.Serialize(elasticsearchSource);
var encryptedPayload = DpapiWrapper.Encrypt(payload);
var auditingSettingsData = new AuditingSettingsData
{
Endpoint = "ws://127.0.0.1:5000/ws",
EncryptDataSource = true,
LoggingDataSource = new NamedGuidWithEncryptedPayload
{
Name = "Auditing Data Source",
Value = selectedAuditingSourceId,
Payload = encryptedPayload
},
};
_resourceRepo.Setup(res => res.GetAuditingSettings <AuditingSettingsData>(env.Object)).Returns(auditingSettingsData);
_resourceRepo.Setup(res => res.SaveAuditingSettings(env.Object, auditingSettingsData)).Verifiable();
}
IResource mockAuditingSource = new ElasticsearchSource
{
ResourceID = selectedAuditingSourceId,
ResourceName = "Auditing Data Source"
};
var expectedList = new List <IResource>();
expectedList.Add(mockAuditingSource);
_resourceRepo.Setup(resourceRepository => resourceRepository.FindResourcesByType <IAuditingSource>(env.Object)).Returns(expectedList);
env.Setup(a => a.ResourceRepository).Returns(_resourceRepo.Object);
var logSettingsViewModel = new LogSettingsViewModel(loggingSettingsTo, env.Object);
return(logSettingsViewModel);
}
