Example #1
0
        private void ProcessFile(string fileName, PatternMatcher patternMatcher, WorkflowResult workflowResult, CancellationToken cancellationToken = default(CancellationToken))
        {
            RootUst ust = null;

            try
            {
                Logger.LogInfo(new MessageEventArgs(MessageType.ProcessingStarted, fileName));

                ust = ReadParseAndConvert(fileName, workflowResult);
                if (ust != null && Stage >= Stage.Match)
                {
                    Stopwatch stopwatch = Stopwatch.StartNew();
                    IEnumerable <MatchResult> matchResults = patternMatcher.Match(ust);
                    stopwatch.Stop();
                    Logger.LogInfo($"File {ust.SourceCodeFile.Name} has been matched with patterns (Elapsed: {stopwatch.Elapsed}).");
                    workflowResult.AddMatchTime(stopwatch.ElapsedTicks);
                    workflowResult.AddResultEntity(matchResults);

                    cancellationToken.ThrowIfCancellationRequested();

                    RenderGraphs(workflowResult);
                }
            }
            catch (OperationCanceledException)
            {
                workflowResult.AddTerminatedFilesCount(1);
                Logger.LogInfo($"{fileName} processing has been cancelled");
            }
            catch (ThreadAbortException)
            {
                workflowResult.AddTerminatedFilesCount(1);
                Logger.LogInfo(new OperationCanceledException($"Processing of {fileName} terimated due to depleted timeout ({FileTimeout})"));
                Thread.ResetAbort();
            }
            catch (Exception ex)
            {
                workflowResult.AddTerminatedFilesCount(1);
                Logger.LogError(ex);
            }
            finally
            {
                AntlrParser.ClearCacheIfRequired();

                workflowResult.AddProcessedFilesCount(1);
                double progress = workflowResult.TotalFilesCount == 0
                    ? workflowResult.TotalProcessedFilesCount
                    : (double)workflowResult.TotalProcessedFilesCount / workflowResult.TotalFilesCount;
                Logger.LogInfo(new ProgressEventArgs(progress, fileName));
                Logger.LogInfo(new MessageEventArgs(MessageType.ProcessingCompleted, fileName));

                if (ust == null)
                {
                    Logger.LogInfo(new MessageEventArgs(MessageType.ProcessingIgnored, fileName));
                }

                cancellationToken.ThrowIfCancellationRequested();
            }
        }
Example #2
0
        public override WorkflowResult Process(WorkflowResult workflowResult       = null,
                                               CancellationToken cancellationToken = default(CancellationToken))
        {
            Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;

            BaseLanguages = GetBaseLanguages(AnalyzedLanguages);
            var result = workflowResult ??
                         new WorkflowResult(AnalyzedLanguages.ToArray(), ThreadCount, Stage, IsIncludeIntermediateResult);

            result.BaseLanguages = BaseLanguages.ToArray();
            result.RenderStages  = RenderStages;
            result.IsSimplifyUst = IsSimplifyUst;

            IEnumerable <string> fileNames = SourceCodeRepository.GetFileNames();

            if (fileNames is IList <string> fileNamesList)
            {
                result.TotalFilesCount = fileNamesList.Count;
            }
            else
            {
                filesCountTask = Task.Factory.StartNew(() => result.TotalFilesCount = fileNames.Count());
            }

            try
            {
                var patternMatcher = new PatternMatcher
                {
                    Logger   = Logger,
                    Patterns = ConvertPatterns(result),
                    IsIgnoreFilenameWildcards = IsIgnoreFilenameWildcards
                };

                var parallelOptions = PrepareParallelOptions(cancellationToken);
                Parallel.ForEach(
                    fileNames,
                    parallelOptions,
                    fileName =>
                {
                    Thread.CurrentThread.CurrentCulture = CultureInfo.InvariantCulture;
                    ProcessFileWithTimeout(fileName, patternMatcher, result, parallelOptions.CancellationToken);
                });
            }
            catch (OperationCanceledException)
            {
                Logger.LogInfo("Scan has been cancelled");
            }

            if (result.TotalProcessedFilesCount > 1)
            {
                AntlrParser.ClearCacheIfRequired();
            }

            DumpJsonOutput(result);
            result.ErrorCount = logger?.ErrorCount ?? 0;
            return(result);
        }