public CLIDexterPluginManager(IDexterPluginInitializer initializer, IDexterClient client,
ILog cliLog, IDexterCLIOption cliOption)
: base(initializer, client)
{
this.cliLog = cliLog;
this.cliOption = cliOption;
}
private static IDexterPluginManager LoadDexterPlugin(IDexterClient client, IDexterCLIOption cliOption)
{
IDexterPluginInitializer initializer = new CLIPluginInitializer(CliLog);
IDexterPluginManager pluginManager = new CLIDexterPluginManager(initializer, client, CliLog, cliOption);
pluginManager.InitDexterPlugins();
return(pluginManager);
}
static void Main(string[] args)
{
DexterCSMain cliMain = new DexterCSMain();
IDexterCLIOption cliOption = new DexterCLIOption(args);
IDexterConfigFile configFile = cliMain.CreateDexterConfigFile(cliOption);
IDexterClient client = cliMain.CreateDexterClient(cliOption);
cliMain.Analyze(cliOption, configFile, client);
}
internal static void SendResultFileThenDelete(IDexterClient client, string resultFilePrefix)
{
string resultFolderStr = DexterConfig.Instance.DexterHome + "/" + DexterConfig.RESULT_FOLDER_NAME;
IList <FileInfo> resultFiles = DexterUtil.GetSubFileNamesByPrefix(resultFolderStr, resultFilePrefix);
foreach (var resultFile in resultFiles)
{
SendResult(resultFile, client);
MmoveResultFileToOldFolder(resultFile);
}
}
public void SendSourceCode(AnalysisConfig config, IDexterClient client)
{
try
{
client.StoreSourceCodeCharSequence(config.SnapshotId, config.GroupId,
config.ModulePath, config.FileName, config.SourcecodeFromFile).Wait();
}
catch (Exception e)
{
CliLog.Error(e.StackTrace);
}
}
private static void SendResult(FileInfo resultFile, IDexterClient client)
{
if (DexterUtil.IsDirectory(resultFile) || !resultFile.Exists || resultFile.IsReadOnly)
{
throw new DexterRuntimeException("Cannot access result file (is not a directory or does not exist or is read-only: " + resultFile);
}
if (!DexterUtil.JSON_EXTENSION.Equals(resultFile.Extension) ||
!resultFile.ToString().StartsWith("result_", StringComparison.Ordinal))
{
return;
}
try
{
client.SendAnalysisResult(File.ReadAllText(resultFile.FullName, Encoding.UTF8)).Wait();
}
catch (Exception e)
{
CliLog.Error(e.StackTrace);
}
}
public void HandleAnalysisResult(List <AnalysisResult> resultList, IDexterClient client)
{
if (resultList.Count == 0)
{
cliLog.Warn("No defect result");
return;
}
List <Defect> allDefectList = DexterAnalyzer.AllDefectList(resultList);
AnalysisResult firstAnalysisResult = resultList[0];
string sourceFileFullPath = firstAnalysisResult.SourceFileFullPath;
try
{
WriteResultFile(allDefectList, sourceFileFullPath);
string resultFilePrefixName = AnalysisResultFileManager.Instance.
GetResultFilePrefixName(firstAnalysisResult.ModulePath, firstAnalysisResult.FileName);
SendResultJob.SendResultFileThenDelete(client, resultFilePrefixName);
}
catch (IOException e)
{
cliLog.Error(e.StackTrace);
}
cliLog.Info(" - " + sourceFileFullPath);
if (allDefectList.Count == 0)
{
cliLog.Info(" > No Defect");
return;
}
else
{
cliLog.Info(" > Total Defects: " + allDefectList.Count);
}
PrintDefect(allDefectList);
}
private List <AnalysisResult> RunStaticAnalysis(AnalysisConfig analysisConfig, IDexterPluginManager pluginManager, IDexterClient client)
{
List <AnalysisResult> resultList = pluginManager.Analyze(analysisConfig);
AnalysisResultFileManager.Instance.WriteJson(resultList);
analysisConfig.ResultHandler.HandleAnalysisResult(resultList, client);
SendSourceCode(analysisConfig, client);
return(resultList);
}
public void Analyze(AnalysisConfig analysisConfig, IDexterPluginManager pluginManager, IDexterClient client)
{
try
{
DexterAnalyzer analyzer = DexterAnalyzer.Instance;
CheckAnalysisConfig(analysisConfig);
//analysisConfig.AddHeaderAndSourceConfiguration(analyzer.ProjectAnalysisConfigurationList);
analyzer.PreSendSourceCode(analysisConfig);
analyzer.PreRunStaticAnalysis(analysisConfig);
List <AnalysisResult> resultList = RunStaticAnalysis(analysisConfig, pluginManager, client);
analyzer.PostRunStaticAnalysis(analysisConfig, resultList);
}
catch (Exception e)
{
CliLog.Error(e.StackTrace);
}
}
public void SetFields(AnalysisConfig config, IDexterPluginManager pluginManager, IDexterClient client)
{
this.config = config;
this.pluginManager = pluginManager;
this.client = client;
}
public SendResultJob(IDexterClient client)
{
this.client = client;
}
public void RunSync(AnalysisConfig analysisConfig, IDexterPluginManager pluginManager, IDexterClient client)
{
dexterAnalyzerSync.Analyze(analysisConfig, pluginManager, client);
}
public BaseDexterPluginManager(IDexterPluginInitializer initializer, IDexterClient client)
{
this.client = client;
this.initializer = initializer;
}
private void AnalyzeSynchronously(IDexterPluginManager pluginManager, IAnalysisResultHandler cliAnalysisResultHandler, AnalysisConfig baseAnalysisConfig, IDexterClient client)
{
cliAnalysisResultHandler.HandleBeginningOfResultFile();
foreach (string fileFullPath in sourceFileFullPathList)
{
AnalysisConfig analysisConfig = CreateAnalysisConfig(fileFullPath, cliAnalysisResultHandler, baseAnalysisConfig);
DexterAnalyzer.Instance.RunSync(analysisConfig, pluginManager, client);
}
cliAnalysisResultHandler.HandleEndOfResultFile();
cliAnalysisResultHandler.PrintLogAfterAnalyze();
}
private void Analyze(IDexterCLIOption cliOption, IDexterConfigFile configFile, IDexterClient client)
{
CliLog.Info(DexterLogConstant.GetStartingAnalysisMessage());
AnalysisConfig baseAnalysisConfig = CreateBaseAnalysisConfig(cliOption, configFile);
IAnalysisResultHandler cliAnalysisResultHandler = CreateCLIAnalysisResultHandler(client, cliOption);
IDexterPluginManager pluginManager = LoadDexterPlugin(client, cliOption);
InitSourceFileFullPathList(configFile, cliOption);
AnalyzeSynchronously(pluginManager, cliAnalysisResultHandler, baseAnalysisConfig, client);
}
private IAnalysisResultHandler CreateCLIAnalysisResultHandler(IDexterClient client, IDexterCLIOption cliOption)
{
return(new CLIAnalysisResultHandler(client.DexterWebUrl, cliOption, CliLog));
}
