public PipelineTestRunPublisher(IClientFactory clientFactory, IPipelineConfig pipelineConfig, ITraceLogger logger, ITelemetryDataCollector telemetry)
{
_logger = logger;
_telemetry = telemetry;
_pipelineConfig = pipelineConfig;
_httpClient = clientFactory.GetClient <TestResultsHttpClient>();
}
/// <summary>
/// Creates a timer with threshold. A perf message is logged only if
/// the time elapsed is more than the threshold.
/// </summary>
public SimpleTimer(string telemetryArea, string telemetryEventName, ITelemetryDataCollector telemetryDataCollector)
{
_telemetryEventName = telemetryEventName;
_telemetryArea = telemetryArea;
_telemetry = telemetryDataCollector;
_timer = Stopwatch.StartNew();
}
/// <summary>
/// Constructor for a node parser state
/// </summary>
/// <param name="parserResetAndAttempPublish">Delegate sent by the parser to reset the parser and attempt publication of test results</param>
/// <param name="logger"></param>
/// <param name="telemetryDataCollector"></param>
protected NodeParserStateBase(ParserResetAndAttemptPublish parserResetAndAttempPublish, ITraceLogger logger, ITelemetryDataCollector telemetryDataCollector, string parserName)
{
Logger = logger;
ParserName = parserName;
StateName = GetType().Name;
Telemetry = telemetryDataCollector;
AttemptPublishAndResetParser = parserResetAndAttempPublish;
}
public HWUsageCollectorTask()
: base("HWUsageCollector", true, new ScheduledTaskInterval(0, 0, 0, 1), false)
{
IServiceManager manager = ServiceManager.GetInstance();
telemetry = manager.GetService <ITelemetryDataCollector>();
coreServer = manager.GetService <ICoreServerService>();
}
public void SetTelemetryDataCollector(ITelemetryDataCollector telemetry)
{
// only keep the first set value
if (TelemetryDataCollector == null)
{
TelemetryDataCollector = telemetry;
}
}
public TelemetryProcessorTask()
: base("TelemetryProcessor", false, new ScheduledTaskInterval(0, 0, 0, 30), false)
{
IServiceManager manager = ServiceManager.GetInstance();
telemetry = manager.GetService <ITelemetryServicesProvider>();
collector = manager.GetService <ITelemetryDataCollector>();
logging = manager.GetService <ILoggingService>();
}
public TestFilePublisher(VssConnection vssConnection, PipelineConfig pipelineConfig, TraceListener traceListener,
ITraceLogger logger, ITelemetryDataCollector telemetry, ITestFileFinder testFileFinder,
ITestResultParser testResultParser, ITestRunPublisher testRunPublisher)
: this(vssConnection, pipelineConfig, traceListener, logger, telemetry)
{
_testFileFinder = testFileFinder;
_testResultParser = testResultParser;
_testRunPublisher = testRunPublisher;
}
public TestFilePublisher(VssConnection vssConnection, PipelineConfig pipelineConfig, TraceListener traceListener,
ITraceLogger logger, ITelemetryDataCollector telemetry)
{
_traceListener = traceListener;
_vssConnection = vssConnection;
_pipelineConfig = pipelineConfig;
_logger = logger;
_telemetry = telemetry;
}
/// <inheritdoc />
public JasmineParserStateExpectingTestRunStart(ParserResetAndAttemptPublish parserResetAndAttemptPublish, ITraceLogger logger,
ITelemetryDataCollector telemetryDataCollector, string parseName)
: base(parserResetAndAttemptPublish, logger, telemetryDataCollector, parseName)
{
RegexesToMatch = new List <RegexActionPair>
{
new RegexActionPair(JasmineRegexes.TestRunStart, TestRunStartMatched),
};
}
public Parser(PublisherConfiguration config, ITelemetryDataCollector telemetry)
{
_configuration = config;
_telemetry = telemetry;
using (new SimpleTimer("Parser", "Parsing", _telemetry))
{
_coverageParserTool = new Lazy <ICoverageParserTool>(() => this.GetCoverageParserTool(_configuration));
}
}
/// <inheritdoc />
public JestParserStateExpectingTestRunSummary(ParserResetAndAttemptPublish parserResetAndAttemptPublish, ITraceLogger logger,
ITelemetryDataCollector telemetryDataCollector, string parseName)
: base(parserResetAndAttemptPublish, logger, telemetryDataCollector, parseName)
{
RegexesToMatch = new List <RegexActionPair>
{
new RegexActionPair(JestRegexs.TestsSummary, TestsSummaryMatched),
new RegexActionPair(JestRegexs.TestRunTime, TestRunTimeMatched),
new RegexActionPair(JestRegexs.TestRunStart, TestRunStartMatched)
};
}
/// <inheritdoc />
public JestParserStateExpectingStackTraces(ParserResetAndAttemptPublish parserResetAndAttemptPublish, ITraceLogger logger,
ITelemetryDataCollector telemetryDataCollector, string parseName)
: base(parserResetAndAttemptPublish, logger, telemetryDataCollector, parseName)
{
RegexesToMatch = new List <RegexActionPair>
{
new RegexActionPair(JestRegexs.StackTraceStart, StackTraceStartMatched),
new RegexActionPair(JestRegexs.SummaryStart, SummaryStartMatched),
new RegexActionPair(JestRegexs.TestRunStart, TestRunStartMatched),
new RegexActionPair(JestRegexs.FailedTestsSummaryIndicator, FailedTestsSummaryIndicatorMatched)
};
}
/// <inheritdoc />
public MochaParserStateExpectingTestResults(ParserResetAndAttemptPublish parserResetAndAttemptPublish, ITraceLogger logger,
ITelemetryDataCollector telemetryDataCollector, string parserName)
: base(parserResetAndAttemptPublish, logger, telemetryDataCollector, parserName)
{
RegexesToMatch = new List <RegexActionPair>
{
new RegexActionPair(MochaRegexes.PassedTestCase, PassedTestCaseMatched),
new RegexActionPair(MochaRegexes.FailedTestCase, FailedTestCaseMatched),
new RegexActionPair(MochaRegexes.PendingTestCase, PendingTestCaseMatched),
new RegexActionPair(MochaRegexes.PassedTestsSummary, PassedTestsSummaryMatched)
};
}
/// <summary>
/// Creates a timer with threshold. A perf message is logged only if
/// the time elapsed is more than the threshold.
/// </summary>
public SimpleTimer(string timerName, string telemetryArea, string telemetryEventName, ITraceLogger logger,
ITelemetryDataCollector telemetryDataCollector, TimeSpan threshold, bool publishTelemetry = true)
{
_name = timerName;
_telemetryEventName = telemetryEventName;
_telemetryArea = telemetryArea;
_logger = logger;
_telemetry = telemetryDataCollector;
_threshold = threshold;
_timer = Stopwatch.StartNew();
_publishTelemetry = publishTelemetry;
}
/// <inheritdoc />
public JasmineParserStateExpectingTestResults(ParserResetAndAttemptPublish parserResetAndAttemptPublish, ITraceLogger logger,
ITelemetryDataCollector telemetryDataCollector, string parseName)
: base(parserResetAndAttemptPublish, logger, telemetryDataCollector, parseName)
{
RegexesToMatch = new List <RegexActionPair>
{
new RegexActionPair(JasmineRegexes.FailedOrPendingTestCase, FailedOrPendingTestCaseMatched),
new RegexActionPair(JasmineRegexes.FailuresStart, FailuresStartMatched),
new RegexActionPair(JasmineRegexes.PendingStart, PendingStartMatched),
new RegexActionPair(JasmineRegexes.TestsSummaryMatcher, SummaryMatched),
new RegexActionPair(JasmineRegexes.TestRunStart, TestRunStartMatched),
new RegexActionPair(JasmineRegexes.SuiteError, SuiteErrorMatched)
};
}
internal RequestProcessor(ref string uriRequest, ref Socket clientSocket)
{
IServiceManager serviceManager = ServiceManager.GetInstance();
logger = serviceManager.GetService <ILoggingService>();
controllerManager = serviceManager.GetService <IControllerManager>();
interceptorManager = serviceManager.GetService <IInterceptorManagerService>();
telemetry = serviceManager.GetService <ITelemetryDataCollector>();
typedObjManager = new TypedObjectsRequestManager();
this.clientSocket = clientSocket;
try
{
using (StringReader sr = new StringReader(uriRequest))
{
using (JsonReader reader = new JsonTextReader(sr))
{
JsonSerializer ser = new JsonSerializer();
ser.ApplyCustomSettings();
requestBody = ser.Deserialize <RequestBody>(reader);
}
}
this.clientSocket = clientSocket;
if (requestBody == null)
{
return;
}
uriRequest = null;
}
catch (Exception ex)
{
string msg = ex.Message;
if (ex.InnerException != null)
{
msg += ex.InnerException.Message;
if (ex.InnerException.InnerException != null)
{
msg += ex.InnerException.InnerException.Message;
}
}
logger.WriteLog($@"A syntax error was detected while converting the request body to a server object.
{msg}", ServerLogType.ERROR);
new SocketRequest().ProcessResponse(ActionResult.Json("", ResponseStatus.ERROR,
$@"A syntax error was detected while converting the request body to a server object.
{msg}"), this.clientSocket, null);
}
}
public override void OnPostExecute(object result)
{
clientSocket = null;
typedObjManager = null;
requestBody = null;
method = null;
logger = null;
controllerManager = null;
interceptorManager = null;
telemetry = null;
controller = null;
DownThreadCount();
}
/// <inheritdoc />
public async Task InitializeAsync(IClientFactory clientFactory, IPipelineConfig pipelineConfig, ITraceLogger traceLogger, ITelemetryDataCollector telemetry)
{
await Task.Run(() =>
{
_logger = traceLogger;
_telemetry = telemetry;
var publisher = new PipelineTestRunPublisher(clientFactory, pipelineConfig, _logger, _telemetry);
_testRunManager = new TestRunManager(publisher, _logger, _telemetry);
var parsers = ParserFactory.GetTestResultParsers(_testRunManager, traceLogger, _telemetry).ToList();
_telemetry.AddOrUpdate(TelemetryConstants.ParserCount, parsers.Count);
foreach (var parser in parsers)
{
// Subscribe parsers to Pub-Sub model
Subscribe(parser.Parse);
}
});
}
public InterceptorManagementServiceImpl()
{
Interceptors = new List <IHandlerInterceptor>(10);
telemetry = ServiceManager.GetInstance().GetService <ITelemetryDataCollector>();
}
/// <inheritdoc />
public JestExpectingTestResults(ParserResetAndAttemptPublish parserResetAndAttemptPublish, ITraceLogger logger, ITelemetryDataCollector telemetryDataCollector)
: base(parserResetAndAttemptPublish, logger, telemetryDataCollector)
{
RegexsToMatch = new List <RegexActionPair>
{
new RegexActionPair(JestRegexs.PassedTestCase, PassedTestCaseMatched),
new RegexActionPair(JestRegexs.FailedTestCase, FailedTestCaseMatched),
new RegexActionPair(JestRegexs.StackTraceStart, StackTraceStartMatched),
new RegexActionPair(JestRegexs.SummaryStart, SummaryStartMatched),
new RegexActionPair(JestRegexs.TestRunStart, TestRunStartMatched),
new RegexActionPair(JestRegexs.FailedTestsSummaryIndicator, FailedTestsSummaryIndicatorMatched)
};
}
/// <summary>
/// For UTs only
/// </summary>
public TestResultLogPlugin(ILogParserGateway inputDataParser, ITraceLogger logger, ITelemetryDataCollector telemetry)
{
_logger = logger;
_telemetry = telemetry;
_inputDataParser = inputDataParser;
}
/// <summary>
/// Constructor for a mocha parser state
/// </summary>
/// <param name="parserResetAndAttempPublish">Delegate sent by the parser to reset the parser and attempt publication of test results</param>
/// <param name="logger"></param>
/// <param name="telemetryDataCollector"></param>
protected MochaParserStateBase(ParserResetAndAttemptPublish parserResetAndAttempPublish, ITraceLogger logger, ITelemetryDataCollector telemetryDataCollector)
{
this.logger = logger;
this.telemetryDataCollector = telemetryDataCollector;
this.attemptPublishAndResetParser = parserResetAndAttempPublish;
}
public TestParser(PublisherConfiguration config, ITelemetryDataCollector telemetryDataCollector, ICoverageParserTool tool) : base(config, telemetryDataCollector)
{
_tool = tool;
}
public TestParser(PublisherConfiguration config, ITelemetryDataCollector telemetryDataCollector) : base(config, telemetryDataCollector)
{
}
internal PythonTestResultParser(ITelemetryDataCollector telemetryCollector, IDiagnosticDataCollector diagnosticsCollector)
{
this.telemetryDataCollector = telemetryCollector;
this.diagnosticDataCollector = diagnosticsCollector;
}
/// <summary>
/// Default constructor accepting only test run manager instance, rest of the requirements assume default values
/// </summary>
public PythonTestResultParser(ITestRunManager testRunManager, ITraceLogger logger, ITelemetryDataCollector telemetry)
: base(testRunManager, logger, telemetry)
{
Logger.Info("PythonTestResultParser : Starting python test result parser.");
Telemetry.AddOrUpdate(PythonTelemetryConstants.Initialize, true, PythonTelemetryConstants.EventArea);
_state = ParserState.ExpectingTestResults;
_currentTestRun = new TestRun($"{Name}/{Version}", "Python", _currentTestRunId);
}
/// <summary>
/// For UTs only
/// </summary>
public TestFilePublisherLogPlugin(ITraceLogger logger, ITelemetryDataCollector telemetry, ITestFilePublisher testFilePublisher)
{
_logger = logger;
_telemetry = telemetry;
_testFilePublisher = testFilePublisher;
}
public static IEnumerable <AbstractTestResultParser> GetTestResultParsers(ITestRunManager testRunManager, ITraceLogger logger, ITelemetryDataCollector telemetry)
{
var currentDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var dllFile = new FileInfo(Path.Combine(currentDir, "Agent.Plugins.Log.TestResultParser.Parser.dll"));
Assembly.LoadFrom(dllFile.FullName);
var interfaceType = typeof(AbstractTestResultParser);
return(AppDomain.CurrentDomain.GetAssemblies()
.SelectMany(x => x.GetTypes())
.Where(x => interfaceType.IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract)
.Select(x => (AbstractTestResultParser)Activator.CreateInstance(x, testRunManager, logger, telemetry)));
}
public static IEnumerable <AbstractTestResultParser> GetTestResultParsers(ITestRunManager testRunManager, ITraceLogger logger, ITelemetryDataCollector telemetry)
{
var currentDir = Path.GetDirectoryName(Assembly.GetExecutingAssembly().Location);
var dllFile = new FileInfo(Path.Combine(currentDir, "Agent.Plugins.Log.TestResultParser.Parser.dll"));
Assembly.LoadFrom(dllFile.FullName);
var interfaceType = typeof(AbstractTestResultParser);
return(AppDomain.CurrentDomain.GetAssemblies()
.SelectMany((x) =>
{
try
{
return x.GetTypes();
}
catch
{
// Skipping issues with assemblies load via reflection - since there are some issues with 'Microsoft.VisualStudio.Services.Agent', although this assembly is not relevant here
return new Type[0];
}
})
.Where(x => interfaceType.IsAssignableFrom(x) && !x.IsInterface && !x.IsAbstract)
.Select(x => (AbstractTestResultParser)Activator.CreateInstance(x, testRunManager, logger, telemetry)));
}
/// <inheritdoc />
public JestExpectingTestRunStart(ParserResetAndAttemptPublish parserResetAndAttemptPublish, ITraceLogger logger, ITelemetryDataCollector telemetryDataCollector)
: base(parserResetAndAttemptPublish, logger, telemetryDataCollector)
{
RegexsToMatch = new List <RegexActionPair>
{
new RegexActionPair(JestRegexs.TestRunStart, TestRunStartMatched),
};
}
