protected async Task <IActionResult> GetSystemInvoker(TResource resource, string detectorId, string invokerId, string dataSource, string timeRange)
{
Dictionary <string, dynamic> systemContext = PrepareSystemContext(resource, detectorId, dataSource, timeRange);
await this._sourceWatcherService.Watcher.WaitForFirstCompletion();
var dataProviders = new DataProviders.DataProviders((DataProviderContext)this.HttpContext.Items[HostConstants.DataProviderContextKey]);
var invoker = this._invokerCache.GetSystemInvoker(invokerId);
if (invoker == null)
{
return(null);
}
Response res = new Response
{
Metadata = invoker.EntryPointDefinitionAttribute
};
var response = (Response)await invoker.Invoke(new object[] { dataProviders, systemContext, res });
List <DataProviderMetadata> dataProvidersMetadata = GetDataProvidersMetadata(dataProviders);
return(response == null ? (IActionResult)NotFound() : Ok(DiagnosticApiResponse.FromCsxResponse(response, dataProvidersMetadata)));
}
public async void TestDetectorWithMDMConfigurationGists()
{
var references = new Dictionary <string, string>
{
{ "mdm", GetMDMConfigurationGist() },
};
var metadata = new EntityMetadata(GetMDMDetector(), EntityType.Detector);
var dataSourceConfiguration = new MockDataProviderConfigurationFactory();
var config = dataSourceConfiguration.LoadConfigurations();
ArmResource resource = new ArmResource("751A8C1D-EA9D-4FE7-8574-3096A81C2C08", "testResourceGroup", "Microsoft.AppPlatform", "Spring", "testResource", "FakeLocation");
OperationContext <ArmResource> context = new OperationContext <ArmResource>(resource, "2019-12-09T00:10", "2019-12-09T23:54", true, "A9854948-807B-4371-B834-3EC78BB6635C");
Response response = new Response();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config, incomingHeaders: new HeaderDictionary()
{
[HeaderConstants.LocationHeader] = resource.Location
}));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports(), references.ToImmutableDictionary()))
{
await invoker.InitializeEntryPointAsync().ConfigureAwait(false);
await invoker.Invoke(new object[] { dataProviders, context, response }).ConfigureAwait(false);
Assert.Equal("Diagnostics.DataProviders.MdmLogDecorator", response.Insights[0].Message);
}
}
private async Task <Tuple <Response, List <DataProviderMetadata> > > GetDetectorInternal(string detectorId, OperationContext <TResource> context)
{
await this._sourceWatcherService.Watcher.WaitForFirstCompletion();
var dataProviders = new DataProviders.DataProviders(_dataSourcesConfigService.Config);
var invoker = this._invokerCache.GetInvoker <TResource>(detectorId, context);
if (invoker == null)
{
return(null);
}
Response res = new Response
{
Metadata = RemovePIIFromDefinition(invoker.EntryPointDefinitionAttribute, context.IsInternalCall)
};
var response = (Response)await invoker.Invoke(new object[] { dataProviders, context, res });
List <DataProviderMetadata> dataProvidersMetadata = null;
response.UpdateDetectorStatusFromInsights();
if (context.IsInternalCall)
{
dataProvidersMetadata = GetDataProvidersMetadata(dataProviders);
}
return(new Tuple <Response, List <DataProviderMetadata> >(response, dataProvidersMetadata));
}
private async Task <IActionResult> GetResultAsync(string path)
{
ActionResult apiResponse;
HttpStatusCode observerStatusCode = default(HttpStatusCode);
var dataProviderContext = (DataProviderContext)HttpContext.Items[HostConstants.DataProviderContextKey];
var dataProviders = new DataProviders.DataProviders(dataProviderContext);
var uriBuilder = new UriBuilder(dataProviderContext.Configuration.SupportObserverConfiguration.Endpoint)
{
Path = path
};
object result = null;
try
{
result = await dataProviders.Observer.GetResource(uriBuilder.ToString());
observerStatusCode = HttpStatusCode.OK;
}
catch (HttpRequestException observerHttpException)
{
observerStatusCode = (HttpStatusCode)observerHttpException.Data["StatusCode"];
result = (string)observerHttpException.Data["ResponseContent"];
}
finally
{
apiResponse = StatusCode((int)observerStatusCode, result);
}
return(apiResponse);
}
public async Task <StackType> GetApplicationStack(string subscriptionId, string resourceGroup, string siteName, DataProviderContext dataProviderContext)
{
var dp = new DataProviders.DataProviders(dataProviderContext);
if (string.IsNullOrWhiteSpace(subscriptionId))
{
throw new ArgumentNullException("subscriptionId");
}
if (string.IsNullOrWhiteSpace(resourceGroup))
{
throw new ArgumentNullException("resourceGroup");
}
if (string.IsNullOrWhiteSpace(siteName))
{
throw new ArgumentNullException("siteName");
}
string queryTemplate =
$@"WawsAn_dailyentity
| where pdate >= ago(5d) and sitename =~ ""{siteName}"" and sitesubscription =~ ""{subscriptionId}"" and resourcegroup =~ ""{resourceGroup}""
| where sitestack !contains ""unknown"" and sitestack !contains ""no traffic"" and sitestack !contains ""undefined""
| top 1 by pdate desc
| project sitestack";
DataTable stackTable = await dp.Kusto.ExecuteQuery(queryTemplate, DataProviderConstants.FakeStampForAnalyticsCluster, operationName : "GetApplicationStack");
if (stackTable == null || stackTable.Rows == null || stackTable.Rows.Count == 0)
{
return(StackType.None);
}
return(GetAppStackType(stackTable.Rows[0][0].ToString().ToLower()));
}
public async void TestBadObserverUrl()
{
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config));
try
{
var data = await dataProviders.Observer.GetResource("https://not-wawsobserver.azurewebsites.windows.net/Sites/thor-api");
}catch (Exception ex)
{
Assert.Contains("Please use a URL that points to one of the hosts", ex.Message);
}
await Assert.ThrowsAsync <FormatException>(async() => await dataProviders.Observer.GetResource("/sites/hawfor-site"));
try
{
var data3 = await dataProviders.Observer.GetResource("/not-a-route/hawfor-site/not-resource");
}catch (FormatException ex)
{
Assert.Contains("Please use a URL that points to one of the hosts", ex.Message);
}
await Assert.ThrowsAsync <ArgumentNullException>(async() => await dataProviders.Observer.GetResource(null));
}
public async void E2E_Test_RuntimeSlotMapData()
{
EntityMetadata metadata = ScriptTestDataHelper.GetRandomMetadata();
//read a sample csx file from local directory
metadata.ScriptText = await File.ReadAllTextAsync("GetRuntimeSiteSlotMapData.csx");
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
await invoker.InitializeEntryPointAsync();
var appResource = new App(string.Empty, string.Empty, "my-api")
{
Stamp = new HostingEnvironment(string.Empty, string.Empty, "waws-prod-bn1-71717c45")
{
Name = "waws-prod-bn1-71717c45"
}
};
var operationContext = new OperationContext <App>(appResource, string.Empty, string.Empty, true, string.Empty);
var response = new Response();
Response result = (Response)await invoker.Invoke(new object[] { dataProviders, operationContext, response });
Assert.Equal("my-api__a88nf", result.Dataset.First().Table.Rows[1][1]);
}
}
public async void TestMdmGetDimensionValuesAsync()
{
var metadata = ScriptTestDataHelper.GetRandomMetadata();
metadata.ScriptText = @"
public async static Task<IEnumerable<string>> Run(DataProviders dataProviders) {
var filter = new List<Tuple<string, IEnumerable<string>>>
{
new Tuple<string, IEnumerable<string>>(""StampName"", new List<string>())
};
return await dataProviders.Mdm.GetDimensionValuesAsync(""Microsoft/Web/WebApps"", ""CpuTime"", filter, ""ServerName"", DateTime.UtcNow.AddMinutes(-30), DateTime.UtcNow);
}";
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config, Guid.NewGuid().ToString()));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
await invoker.InitializeEntryPointAsync();
var result = await invoker.Invoke(new object[] { dataProviders }) as IEnumerable <string>;
Assert.NotNull(result);
Assert.True(result.Count() == 3);
}
}
private async Task <DiagnosticStampData> GetHostingEnvironmentPostBody(string hostingEnvironmentName)
{
var dataProviders = new DataProviders.DataProviders((DataProviderContext)HttpContext.Items[HostConstants.DataProviderContextKey]);
dynamic postBody = await dataProviders.Observer.GetHostingEnvironmentPostBody(hostingEnvironmentName);
JObject bodyObject = (JObject)postBody;
return(bodyObject.ToObject <DiagnosticStampData>());
}
protected virtual async Task <List <string> > GetTenantIdsAsync(string stamp, DateTime startTime, DateTime endTime, DataProviderContext dataProviderContext, PlatformType platformType)
{
var dp = new DataProviders.DataProviders(dataProviderContext);
var tenantIds = new List <string>();
var kustoQuery = GetTenantIdQuery(stamp, startTime, endTime, platformType);
var kustoTask = dp.Kusto.ExecuteQuery(kustoQuery, stamp, operationName: platformType == PlatformType.Windows ? KustoOperations.GetTenantIdForWindows : KustoOperations.GetTenantIdForLinux);
tenantIds = GetTenantIdsFromTable(await kustoTask);
return(tenantIds);
}
private async Task <DiagnosticSiteData> GetSitePostBody(string subscriptionId, string resourceGroupName, string siteName)
{
var dataProviders = new DataProviders.DataProviders((DataProviderContext)HttpContext.Items[HostConstants.DataProviderContextKey]);
string stampName = await dataProviders.Observer.GetStampName(subscriptionId, resourceGroupName, siteName);
dynamic postBody = await dataProviders.Observer.GetSitePostBody(stampName, siteName);
JObject bodyObject = (JObject)postBody;
var sitePostBody = bodyObject.ToObject <DiagnosticSiteData>();
return(sitePostBody);
}
public async Task <Tuple <List <string>, PlatformType> > GetTenantIdForStamp(string stamp, bool isPublicStamp, DateTime startTime, DateTime endTime, DataProviderContext dataProviderContext)
{
var dp = new DataProviders.DataProviders(dataProviderContext);
if (string.IsNullOrWhiteSpace(stamp))
{
throw new ArgumentNullException("stamp");
}
if (_tenantCache.TryGetValue(stamp.ToLower(), out Tuple <List <string>, PlatformType> result))
{
return(result);
}
List <string> windowsTenantIds = new List <string>();
List <string> linuxTenantIds = new List <string>();
string windowsQuery = GetTenantIdQuery(stamp, startTime, endTime, PlatformType.Windows);
string linuxQuery = GetTenantIdQuery(stamp, startTime, endTime, PlatformType.Linux);
var windowsTask = dp.Kusto.ExecuteQuery(windowsQuery, stamp, operationName: KustoOperations.GetTenantIdForWindows);
var linuxTask = dp.Kusto.ExecuteQuery(linuxQuery, stamp, operationName: KustoOperations.GetTenantIdForLinux);
windowsTenantIds = GetTenantIdsFromTable(await windowsTask);
linuxTenantIds = GetTenantIdsFromTable(await linuxTask);
PlatformType type = PlatformType.Windows;
List <string> tenantIds = windowsTenantIds.Union(linuxTenantIds).ToList();
if (windowsTenantIds.Any() && linuxTenantIds.Any())
{
type = PlatformType.Windows | PlatformType.Linux;
}
else if (linuxTenantIds.Any())
{
type = PlatformType.Linux;
}
result = new Tuple <List <string>, PlatformType>(tenantIds, type);
// Only cache TenantIds if not empty
if (tenantIds != null && tenantIds.Any())
{
_tenantCache.TryAdd(stamp.ToLower(), result);
}
return(result);
}
public async Task <StackType> GetApplicationStack(string subscriptionId, string resourceGroup, string siteName, DataProviderContext dataProviderContext)
{
var dp = new DataProviders.DataProviders(dataProviderContext);
if (string.IsNullOrWhiteSpace(subscriptionId))
{
throw new ArgumentNullException("subscriptionId");
}
if (string.IsNullOrWhiteSpace(resourceGroup))
{
throw new ArgumentNullException("resourceGroup");
}
if (string.IsNullOrWhiteSpace(siteName))
{
throw new ArgumentNullException("siteName");
}
string queryTemplate =
$@"set query_results_cache_max_age = time(1d);
WawsAn_dailyentity
| where pdate >= ago(5d) and sitename =~ ""{siteName}"" and sitesubscription =~ ""{subscriptionId}"" and resourcegroup =~ ""{resourceGroup}""
| where sitestack !contains ""unknown"" and sitestack !contains ""no traffic"" and sitestack !contains ""undefined""
| top 1 by pdate desc
| project sitestack";
DataTable stackTable = null;
try
{
if (dataProviderContext.Configuration.KustoConfiguration.CloudDomain == DataProviderConstants.AzureCloud)
{
stackTable = await dp.Kusto.ExecuteQuery(queryTemplate, DataProviderConstants.FakeStampForAnalyticsCluster, operationName : "GetApplicationStack");
}
}
catch (Exception ex)
{
//swallow the exception. Since Mooncake does not have an analytics cluster
DiagnosticsETWProvider.Instance.LogRuntimeHostHandledException(dataProviderContext.RequestId, "GetApplicationStack", subscriptionId,
resourceGroup, siteName, ex.GetType().ToString(), ex.ToString());
}
if (stackTable == null || stackTable.Rows == null || stackTable.Rows.Count == 0)
{
return(StackType.None);
}
return(GetAppStackType(stackTable.Rows[0][0].ToString().ToLower()));
}
public async void TestChangeSetsRequest()
{
var dataSourceConfiguration = new MockDataProviderConfigurationFactory();
var config = dataSourceConfiguration.LoadConfigurations();
config.ChangeAnalysisDataProviderConfiguration = new ChangeAnalysisDataProviderConfiguration
{
AppKey = string.Empty,
ClientId = string.Empty,
};
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config));
// Throws exception when querying for changes beyond last 14 days.
await Assert.ThrowsAsync <ArgumentException>(async() =>
await dataProviders.ChangeAnalysis.GetChangeSetsForResource("/sites/test-site", DateTime.Now.AddDays(-15), DateTime.Now));
}
private List <DataProviderMetadata> GetDataProvidersMetadata(DataProviders.DataProviders dataProviders)
{
var dataprovidersMetadata = new List <DataProviderMetadata>();
foreach (var dataProvider in dataProviders.GetType().GetFields())
{
if (dataProvider.FieldType.IsInterface)
{
var metadataProvider = dataProvider.GetValue(dataProviders) as IMetadataProvider;
var metadata = metadataProvider.GetMetadata();
if (metadata != null)
{
dataprovidersMetadata.Add(metadata);
}
}
}
return(dataprovidersMetadata);
}
public async Task E2E_Test_WAWSObserverAsync()
{
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
EntityMetadata metadata = ScriptTestDataHelper.GetRandomMetadata();
//read a sample csx file from local directory
metadata.ScriptText = await File.ReadAllTextAsync("BackupCheckDetector.csx");
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
await invoker.InitializeEntryPointAsync();
var appResource = new App(string.Empty, string.Empty, "my-api")
{
Stamp = new HostingEnvironment(string.Empty, string.Empty, "waws-prod-bn1-71717c45")
};
appResource.Stamp.TenantIdList = new List <string>()
{
Guid.NewGuid().ToString()
};
var operationContext = new OperationContext <App>(appResource, null, null, true, null);
var response = new Response();
try
{
Response result = (Response)await invoker.Invoke(new object[] { dataProviders, operationContext, response });
}
catch (ScriptCompilationException ex)
{
foreach (var output in ex.CompilationOutput)
{
Trace.WriteLine(output);
}
}
}
}
public void TestGenericSystemMdmAccount()
{
var dataSourceConfiguration = new MockDataProviderConfigurationFactory();
var config = dataSourceConfiguration.LoadConfigurations();
var mdmConfig = new GenericMdmDataProviderConfiguration
{
CertificateName = "mock.azurewebsites.windows.net",
Endpoint = "http://0.0.0.0",
MonitoringAccount = "Mock"
};
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config));
var mdmDataProvider = dataProviders.MdmGeneric(mdmConfig);
Assert.NotNull(mdmDataProvider);
}
public async void DataProvders_TestKusto()
{
EntityMetadata metadata = ScriptTestDataHelper.GetRandomMetadata();
metadata.ScriptText = GetDataProviderScript("TestA");
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config, Guid.NewGuid().ToString()));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
await invoker.InitializeEntryPointAsync();
DataTable result = (DataTable)await invoker.Invoke(new object[] { dataProviders });
Assert.NotNull(result);
}
}
internal async void TestObserver()
{
var dataSourceConfiguration = new MockDataProviderConfigurationFactory();
var config = dataSourceConfiguration.LoadConfigurations();
config.SupportObserverConfiguration = new SupportObserverDataProviderConfiguration()
{
AppKey = "",
ClientId = "",
IsMockConfigured = false
};
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config));
var wawsObserverData = await dataProviders.Observer.GetResource("https://wawsobserver.azurewebsites.windows.net/sites/highcpuscenario");
var supportBayData = await dataProviders.Observer.GetResource("https://support-bay-api.azurewebsites.net/observer/stamps/waws-prod-bay-073/sites/highcpuscenario/postbody");
Assert.True(wawsObserverData != null);
Assert.True(supportBayData != null);
}
public async Task <Tuple <List <string>, PlatformType> > GetTenantIdForStamp(string stamp, bool isPublicStamp, DateTime startTime, DateTime endTime, DataProviderContext dataProviderContext)
{
if (string.IsNullOrWhiteSpace(stamp))
{
throw new ArgumentNullException(nameof(stamp));
}
var dp = new DataProviders.DataProviders(dataProviderContext);
if (_tenantCache.TryGetValue(stamp.ToLower(), out Tuple <List <string>, PlatformType> result))
{
return(result);
}
var windowsTenantIdsTask = GetTenantIdsAsync(stamp, startTime, endTime, dataProviderContext, PlatformType.Windows);
var linuxTenantIdsTask = GetTenantIdsAsync(stamp, startTime, endTime, dataProviderContext, PlatformType.Linux);
var windowsTenantIds = await windowsTenantIdsTask;
var linuxTenantIds = await linuxTenantIdsTask;
PlatformType type = PlatformType.Windows;
List <string> tenantIds = windowsTenantIds.Union(linuxTenantIds).ToList();
if (windowsTenantIds.Any() && linuxTenantIds.Any())
{
type = PlatformType.Windows | PlatformType.Linux;
}
else if (linuxTenantIds.Any())
{
type = PlatformType.Linux;
}
result = new Tuple <List <string>, PlatformType>(tenantIds, type);
// Only cache TenantIds if not empty and for Public Stamps
if (tenantIds != null && tenantIds.Any() && isPublicStamp)
{
_tenantCache.TryAdd(stamp.ToLower(), result);
}
return(result);
}
public async void TestRouteMatchLogic()
{
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config));
//basic test
var site123Data = await dataProviders.Observer.GetResource("https://wawsobserver.azurewebsites.windows.net/stamps/stamp123/sites/site123");
//basic test with different resource
var certData = await dataProviders.Observer.GetResource("https://wawsobserver.azurewebsites.windows.net/certificates/123456789");
//test where parameter value is middle of url and not end of url
var domainData = await dataProviders.Observer.GetResource("https://wawsobserver.azurewebsites.windows.net/subscriptions/1111-2222-3333-4444-5555/domains");
//test with multiple parameter values
var storageVolumeData = await dataProviders.Observer.GetResource("https://wawsobserver.azurewebsites.windows.net/stamps/waws-prod-mock1-001/storagevolumes/volume-19");
Assert.Equal("site123", (string)site123Data.siteName);
Assert.Equal("IPSSL", (string)certData.type);
Assert.Equal("foo_bar.com", (string)domainData[0].name);
Assert.Equal("volume-19", (string)storageVolumeData.name);
}
public async void DataProvders_TestKusto()
{
var metadata = ScriptTestDataHelper.GetRandomMetadata();
metadata.ScriptText = @"
public async static Task<DataTable> Run(DataProviders dataProviders) {
return await dataProviders.Kusto.ExecuteQuery(""TestA"", ""waws-prod-mockstamp"");
}";
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config, Guid.NewGuid().ToString()));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
await invoker.InitializeEntryPointAsync();
var result = (DataTable)await invoker.Invoke(new object[] { dataProviders });
Assert.NotNull(result);
}
}
public async void TestMdmGetTimeSeriesValuesAsync()
{
var metadata = ScriptTestDataHelper.GetRandomMetadata();
metadata.ScriptText = @"
public async static Task<IEnumerable<DataTable>> Run(DataProviders dataProviders) {
var dimensions = new Dictionary<string, string> { { ""StampName"", ""kudu1"" } };
return await dataProviders.Mdm.GetTimeSeriesAsync(DateTime.UtcNow.AddMinutes(-10), DateTime.UtcNow, Sampling.Average | Sampling.Max | Sampling.Count, ""Microsoft/Web/WebApps"", ""CpuTime"", dimensions);
}";
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config, Guid.NewGuid().ToString()));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
await invoker.InitializeEntryPointAsync();
var result = await invoker.Invoke(new object[] { dataProviders }) as IEnumerable <DataTable>;
Assert.NotNull(result);
}
}
public async void TestMdmGetMetricNamesAsync()
{
var metadata = ScriptTestDataHelper.GetRandomMetadata();
metadata.ScriptText = @"
public async static Task<IEnumerable<string>> Run(DataProviders dataProviders) {
return await dataProviders.Mdm.GetMetricNamesAsync(""Microsoft/Web/WebApps"");
}";
var configFactory = new MockDataProviderConfigurationFactory();
var config = configFactory.LoadConfigurations();
var dataProviders = new DataProviders.DataProviders(new DataProviderContext(config, Guid.NewGuid().ToString()));
using (EntityInvoker invoker = new EntityInvoker(metadata, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
await invoker.InitializeEntryPointAsync();
var result = await invoker.Invoke(new object[] { dataProviders }) as IEnumerable <string>;
Assert.NotNull(result);
Assert.True(result.Count() == 3);
}
}
public StampService(IDataSourcesConfigurationService dataSourcesConfigService)
{
_dataSourcesConfigService = dataSourcesConfigService;
_tenantCache = new ConcurrentDictionary <string, Tuple <List <string>, PlatformType> >();
_dataProviders = new DataProviders.DataProviders(_dataSourcesConfigService.Config);
}
protected async Task <IActionResult> ExecuteQuery <TPostBodyResource>(TResource resource, CompilationBostBody <TPostBodyResource> jsonBody, string startTime, string endTime, string timeGrain)
{
if (jsonBody == null)
{
return(BadRequest("Missing body"));
}
if (string.IsNullOrWhiteSpace(jsonBody.Script))
{
return(BadRequest("Missing script in body"));
}
if (!DateTimeHelper.PrepareStartEndTimeWithTimeGrain(startTime, endTime, timeGrain, out DateTime startTimeUtc, out DateTime endTimeUtc, out TimeSpan timeGrainTimeSpan, out string errorMessage))
{
return(BadRequest(errorMessage));
}
await this._sourceWatcherService.Watcher.WaitForFirstCompletion();
EntityMetadata metaData = new EntityMetadata(jsonBody.Script);
var dataProviders = new DataProviders.DataProviders(_dataSourcesConfigService.Config);
QueryResponse <DiagnosticApiResponse> queryRes = new QueryResponse <DiagnosticApiResponse>
{
InvocationOutput = new DiagnosticApiResponse()
};
Assembly tempAsm = null;
this.Request.Headers.TryGetValue(HeaderConstants.RequestIdHeaderName, out StringValues requestIds);
var compilerResponse = await _compilerHostClient.GetCompilationResponse(jsonBody.Script, requestIds.FirstOrDefault() ?? string.Empty);
queryRes.CompilationOutput = compilerResponse;
if (queryRes.CompilationOutput.CompilationSucceeded)
{
byte[] asmData = Convert.FromBase64String(compilerResponse.AssemblyBytes);
byte[] pdbData = Convert.FromBase64String(compilerResponse.PdbBytes);
tempAsm = Assembly.Load(asmData, pdbData);
using (var invoker = new EntityInvoker(metaData, ScriptHelper.GetFrameworkReferences(), ScriptHelper.GetFrameworkImports()))
{
invoker.InitializeEntryPoint(tempAsm);
// Verify Detector with other detectors in the system in case of conflicts
if (!VerifyEntity(invoker, ref queryRes))
{
return(Ok(queryRes));
}
OperationContext <TResource> cxt = PrepareContext(resource, startTimeUtc, endTimeUtc);
List <DataProviderMetadata> dataProvidersMetadata = null;
try
{
var responseInput = new Response()
{
Metadata = RemovePIIFromDefinition(invoker.EntryPointDefinitionAttribute, cxt.IsInternalCall)
};
var invocationResponse = (Response)await invoker.Invoke(new object[] { dataProviders, cxt, responseInput });
invocationResponse.UpdateDetectorStatusFromInsights();
if (cxt.IsInternalCall)
{
dataProvidersMetadata = GetDataProvidersMetadata(dataProviders);
}
queryRes.RuntimeSucceeded = true;
queryRes.InvocationOutput = DiagnosticApiResponse.FromCsxResponse(invocationResponse, dataProvidersMetadata);
}
catch (Exception ex)
{
if (cxt.IsInternalCall)
{
queryRes.RuntimeSucceeded = false;
queryRes.InvocationOutput = CreateQueryExceptionResponse(ex, invoker.EntryPointDefinitionAttribute, cxt.IsInternalCall, GetDataProvidersMetadata(dataProviders));
}
else
{
throw;
}
}
}
}
return(Ok(queryRes));
}
public SiteService(IDataSourcesConfigurationService dataSourcesConfigService)
{
_dataSourcesConfigService = dataSourcesConfigService;
_dataProviders = new DataProviders.DataProviders(_dataSourcesConfigService.Config);
}
