private static void RemoveInvalidConfigurations(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
if (extensionPointsConfiguration.ParsersConfiguration != null)
{
RemoveInvalidParserConfigurations(extensionPointsConfiguration, logger);
}
if (extensionPointsConfiguration.WordSplitterConfiguration != null)
{
RemoveInvalidWordSplitterConfiguration(extensionPointsConfiguration, logger);
}
if (extensionPointsConfiguration.ResultsReordererConfiguration != null)
{
RemoveInvalidResultsReordererConfiguration(extensionPointsConfiguration, logger);
}
if (extensionPointsConfiguration.QueryWeightsSupplierConfiguration != null)
{
RemoveInvalidQueryWeightsSupplierConfiguration(extensionPointsConfiguration, logger);
}
if (extensionPointsConfiguration.QueryRewriterConfiguration != null)
{
RemoveInvalidQueryRewriterConfiguration(extensionPointsConfiguration, logger);
}
if (extensionPointsConfiguration.IndexFilterManagerConfiguration != null)
{
RemoveInvalidIndexFilterManagerConfiguration(extensionPointsConfiguration, logger);
}
}
private static void RemoveInvalidQueryWeightsSupplierConfiguration(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
if (IsConfigurationInvalid(extensionPointsConfiguration.QueryWeightsSupplierConfiguration))
{
extensionPointsConfiguration.QueryWeightsSupplierConfiguration = null;
logger.Info(String.Format("Invalid query weights supplier configuration found - it will be omitted during registration process."));
}
}
private static void RemoveInvalidResultsReordererConfiguration(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
if (IsConfigurationInvalid(extensionPointsConfiguration.ResultsReordererConfiguration))
{
extensionPointsConfiguration.ResultsReordererConfiguration = null;
logger.Info(String.Format("Invalid results reorderer configuration found - it will be omitted during registration process."));
}
}
private static void RemoveInvalidIndexFilterManagerConfiguration(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
if (IsConfigurationInvalid(extensionPointsConfiguration.IndexFilterManagerConfiguration))
{
extensionPointsConfiguration.IndexFilterManagerConfiguration = null;
logger.Info(String.Format("Invalid index filter manager configuration found - it will be omitted during registration process."));
}
}
private static void RemoveInvalidParserConfigurations(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
int invalidParserConfigurationCount = extensionPointsConfiguration.ParsersConfiguration.RemoveAll(
p =>
IsConfigurationInvalid(p) ||
p.SupportedFileExtensions == null ||
p.SupportedFileExtensions.Count == 0 ||
p.ProgramElementsConfiguration.Count(pe => IsConfigurationInvalid(pe)) > 0);
if (invalidParserConfigurationCount > 0)
{
logger.Info(String.Format("{0} invalid parser configurations found - they will be omitted during registration process.", invalidParserConfigurationCount));
}
}
public static void FindAndRegisterValidExtensionPoints(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
Contract.Requires(logger != null, "ExtensionPointsConfigurationReader:FindAndRegisterValidExtensionPoints - logger cannot be null!");
logger.Info("-=#|#=- Analyzing configuration started -=#|#=-");
RemoveInvalidConfigurations(extensionPointsConfiguration, logger);
FindAndRegisterValidParserExtensionPoints(extensionPointsConfiguration, logger);
FindAndRegisterValidWordSplitterExtensionPoints(extensionPointsConfiguration, logger);
FindAndRegisterValidResultsReordererExtensionPoints(extensionPointsConfiguration, logger);
FindAndRegisterValidQueryWeightsSupplierExtensionPoints(extensionPointsConfiguration, logger);
FindAndRegisterValidQueryRewriterExtensionPoints(extensionPointsConfiguration, logger);
FindAndRegisterValidIndexFilterManagerExtensionPoints(extensionPointsConfiguration, logger);
logger.Info("-=#|#=- Analyzing configuration finished -=#|#=-");
}
public static void WriteConfiguration(ExtensionPointsConfiguration configuration)
{
StreamWriter writer = null;
try
{
var sandoOptions = ServiceLocator.Resolve<ISandoOptionsProvider>().GetSandoOptions(); ;
writer = new StreamWriter(sandoOptions.ExtensionPointsConfigurationFilePath);
new XmlSerializer(typeof(ExtensionPointsConfiguration)).Serialize(writer,configuration);
}
catch (Exception ex)
{
throw new Exception("Saving extension points configuration file failed! - " + ex.StackTrace);
}
finally
{
writer.Close();
}
}
public static void WriteConfiguration(ExtensionPointsConfiguration configuration)
{
StreamWriter writer = null;
try
{
var sandoOptions = ServiceLocator.Resolve <ISandoOptionsProvider>().GetSandoOptions();;
writer = new StreamWriter(sandoOptions.ExtensionPointsConfigurationFilePath);
new XmlSerializer(typeof(ExtensionPointsConfiguration)).Serialize(writer, configuration);
}
catch (Exception ex)
{
throw new Exception("Saving extension points configuration file failed! - " + ex.StackTrace);
}
finally
{
writer.Close();
}
}
public static ExtensionPointsConfiguration ReadAndValidate(ILog logger)
{
Contract.Requires(logger != null, "ExtensionPointsConfigurationValidator:Validate - logger cannot be null!");
logger.Info("Validating configuration started");
ExtensionPointsConfiguration extensionPointsConfiguration = null;
try
{
extensionPointsConfiguration = TryRetrieveConfigurationObject();
}
catch (Exception ex)
{
logger.Fatal("Validation failed: " + ex.Message);
return(null);
}
logger.Info("Validating configuration finished");
return(extensionPointsConfiguration);
}
private static void FindAndRegisterValidParserExtensionPoints(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
logger.Info("Reading parser extension points configuration started");
foreach (ParserExtensionPointsConfiguration parserConfiguration in extensionPointsConfiguration.ParsersConfiguration)
{
try
{
logger.Info(String.Format("Parser found: {0}, from assembly: {1}", parserConfiguration.FullClassName, parserConfiguration.LibraryFileRelativePath));
IParser parser = CreateInstance <IParser>(extensionPointsConfiguration.PluginDirectoryPath, parserConfiguration.LibraryFileRelativePath, parserConfiguration.FullClassName);
parserConfiguration.ProgramElementsConfiguration.ForEach(pe => LoadAssembly(extensionPointsConfiguration.PluginDirectoryPath, pe.LibraryFileRelativePath));
ExtensionPointsRepository.Instance.RegisterParserImplementation(parserConfiguration.SupportedFileExtensions, parser);
logger.Info(String.Format("Parser {0} successfully registered.", parserConfiguration.FullClassName));
}
catch (Exception ex)
{
logger.Error(String.Format("Parser {0} cannot be registered: {1}", parserConfiguration.FullClassName, ex.Message));
}
}
logger.Info("Reading parser extension points configuration finished");
}
private static ExtensionPointsConfiguration TryRetrieveConfigurationObject()
{
var sandoOptions = ServiceLocator.Resolve <ISandoOptionsProvider>().GetSandoOptions();
if (String.IsNullOrWhiteSpace(sandoOptions.ExtensionPointsConfigurationFilePath))
{
throw new Exception("Extension points configuration file path cannot be null or an empty string!");
}
if (!File.Exists(sandoOptions.ExtensionPointsConfigurationFilePath))
{
throw new Exception("Extension points configuration file wasn't found!");
}
ExtensionPointsConfiguration extensionPointsConfiguration = null;
TextReader textReader = null;
try
{
textReader = new StreamReader(sandoOptions.ExtensionPointsConfigurationFilePath);
extensionPointsConfiguration = (ExtensionPointsConfiguration) new XmlSerializer(typeof(ExtensionPointsConfiguration)).Deserialize(textReader);
}
catch (Exception ex)
{
throw new Exception("Reading extension points configuration file failed! - " + ex.StackTrace);
}finally
{
textReader.Close();
}
if (String.IsNullOrWhiteSpace(extensionPointsConfiguration.PluginDirectoryPath))
{
throw new Exception("Plugin directory path must be set!");
}
if (!Directory.Exists(extensionPointsConfiguration.PluginDirectoryPath))
{
throw new Exception("Plugin directory wasn't found!");
}
return(extensionPointsConfiguration);
}
private static void FindAndRegisterValidIndexFilterManagerExtensionPoints(ExtensionPointsConfiguration extensionPointsConfiguration, ILog logger)
{
logger.Info("Reading index filter manager extension point configuration started");
BaseExtensionPointConfiguration indexFilterManagerConfiguration = extensionPointsConfiguration.IndexFilterManagerConfiguration;
if (indexFilterManagerConfiguration != null)
{
try
{
logger.Info(String.Format("Index filter manager found: {0}, from assembly: {1}", indexFilterManagerConfiguration.FullClassName, indexFilterManagerConfiguration.LibraryFileRelativePath));
IIndexFilterManager indexFilterManager = CreateInstance <IIndexFilterManager>(extensionPointsConfiguration.PluginDirectoryPath, indexFilterManagerConfiguration.LibraryFileRelativePath, indexFilterManagerConfiguration.FullClassName);
ExtensionPointsRepository.Instance.RegisterIndexFilterManagerImplementation(indexFilterManager);
logger.Info(String.Format("Index filter manager {0} successfully registered.", indexFilterManagerConfiguration.FullClassName));
}
catch (Exception ex)
{
logger.Error(String.Format("Index filter manager {0} cannot be registered: {1}", indexFilterManagerConfiguration.FullClassName, ex.Message));
}
}
logger.Info("Reading index filter manager extension point configuration finished");
}
private void CreateExtensionPointsConfiguration(
bool addValidParserConfigurations = false,
bool addInvalidParserConfigurations = false,
bool addValidWordSplitterConfiguration = false,
bool addInvalidWordSplitterConfiguration = false,
bool addValidResultsReordererConfiguration = false,
bool addInvalidResultsReordererConfiguration = false,
bool addValidQueryWeightsSupplierConfiguration = false,
bool addInvalidQueryWeightsSupplierConfiguration = false,
bool addValidQueryRewriterConfiguration = false,
bool addInvalidQueryRewriterConfiguration = false,
bool addValidIndexFilterManagerConfiguration = false,
bool addInvalidIndexFilterManagerConfiguration = false,
bool addInvalidExtensionPoints = false)
{
extensionPointsConfiguration = new ExtensionPointsConfiguration();
extensionPointsConfiguration.PluginDirectoryPath = pluginDirectory;
extensionPointsConfiguration.ParsersConfiguration = new List<ParserExtensionPointsConfiguration>();
if (addValidParserConfigurations)
{
extensionPointsConfiguration.ParsersConfiguration.AddRange(
new List<ParserExtensionPointsConfiguration>()
{
new ParserExtensionPointsConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestCSharpParser",
LibraryFileRelativePath = "TestExtensionPoints.dll",
SupportedFileExtensions = new List<string>() { ".cs" },
ProgramElementsConfiguration = new List<BaseExtensionPointConfiguration>()
{
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestElement",
LibraryFileRelativePath = "TestExtensionPoints.dll"
}
}
},
new ParserExtensionPointsConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestCppParser",
LibraryFileRelativePath = "TestExtensionPoints.dll",
SupportedFileExtensions = new List<string>() { ".h", ".cpp", ".cxx" }
}
});
}
if (addInvalidParserConfigurations)
{
extensionPointsConfiguration.ParsersConfiguration.AddRange(
new List<ParserExtensionPointsConfiguration>()
{
new ParserExtensionPointsConfiguration()
{
FullClassName = "",
LibraryFileRelativePath = "TestExtensionPoints.dll",
SupportedFileExtensions = new List<string>() { ".cs" }
},
new ParserExtensionPointsConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestCppParser",
LibraryFileRelativePath = "",
SupportedFileExtensions = new List<string>() { ".h", ".cpp", ".cxx" }
},
new ParserExtensionPointsConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestCppParser",
LibraryFileRelativePath = "TestExtensionPoints.dll",
SupportedFileExtensions = new List<string>(){".cs"},
ProgramElementsConfiguration = new List<BaseExtensionPointConfiguration>()
{
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestElement",
LibraryFileRelativePath = ""
}
}
}
});
}
if (addValidWordSplitterConfiguration)
{
extensionPointsConfiguration.WordSplitterConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestWordSplitter",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addInvalidWordSplitterConfiguration)
{
extensionPointsConfiguration.WordSplitterConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestWordSplitter",
LibraryFileRelativePath = ""
};
}
if (addValidResultsReordererConfiguration)
{
extensionPointsConfiguration.ResultsReordererConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestResultsReorderer",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addInvalidResultsReordererConfiguration)
{
extensionPointsConfiguration.ResultsReordererConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addValidQueryWeightsSupplierConfiguration)
{
extensionPointsConfiguration.QueryWeightsSupplierConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestQueryWeightsSupplier",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addInvalidQueryWeightsSupplierConfiguration)
{
extensionPointsConfiguration.QueryWeightsSupplierConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addValidQueryRewriterConfiguration)
{
extensionPointsConfiguration.QueryRewriterConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestQueryRewriter",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addInvalidQueryRewriterConfiguration)
{
extensionPointsConfiguration.QueryRewriterConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addValidIndexFilterManagerConfiguration)
{
extensionPointsConfiguration.IndexFilterManagerConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestIndexFilterManager",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addInvalidIndexFilterManagerConfiguration)
{
extensionPointsConfiguration.IndexFilterManagerConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
if (addInvalidExtensionPoints)
{
extensionPointsConfiguration.ParsersConfiguration.AddRange(
new List<ParserExtensionPointsConfiguration>()
{
new ParserExtensionPointsConfiguration()
{
FullClassName = "Sando.NonExistingParser",
LibraryFileRelativePath = "TestExtensionPoints.dll",
SupportedFileExtensions = new List<string>() { ".cs" }
},
new ParserExtensionPointsConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestCppParser",
LibraryFileRelativePath = "NonExistingParser.dll",
SupportedFileExtensions = new List<string>() { ".h", ".cpp", ".cxx" }
},
new ParserExtensionPointsConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestCppParser",
LibraryFileRelativePath = "TestExtensionPoints.dll",
SupportedFileExtensions = new List<string>(){".cs"},
ProgramElementsConfiguration = new List<BaseExtensionPointConfiguration>()
{
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestElement",
LibraryFileRelativePath = "NonExistingTestElement.dll"
}
}
}
});
extensionPointsConfiguration.WordSplitterConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.TestWordSplitter",
LibraryFileRelativePath = "NonExistingWordSplitter.dll"
};
extensionPointsConfiguration.ResultsReordererConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.NonExistingResultsReorderer",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
extensionPointsConfiguration.QueryWeightsSupplierConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.NonExistingQueryWeightsSupplier",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
extensionPointsConfiguration.QueryRewriterConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.NonExistingQueryRewriter",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
extensionPointsConfiguration.IndexFilterManagerConfiguration =
new BaseExtensionPointConfiguration()
{
FullClassName = "Sando.TestExtensionPoints.NonExistingIndexFilterManager",
LibraryFileRelativePath = "TestExtensionPoints.dll"
};
}
}
private void RegisterExtensionPoints()
{
var extensionPointsRepository = ExtensionPointsRepository.Instance;
extensionPointsRepository.RegisterParserImplementation(new List<string> { ".cs" }, new SrcMLCSharpParser());
extensionPointsRepository.RegisterParserImplementation(new List<string> { ".h", ".cpp", ".cxx", ".c" }, new SrcMLCppParser(srcMLService));
extensionPointsRepository.RegisterWordSplitterImplementation(new WordSplitter());
extensionPointsRepository.RegisterResultsReordererImplementation(new SortByScoreResultsReorderer());
extensionPointsRepository.RegisterQueryWeightsSupplierImplementation(new QueryWeightsSupplier());
extensionPointsRepository.RegisterQueryRewriterImplementation(new DefaultQueryRewriter());
extensionPointsRepository.RegisterIndexFilterManagerImplementation(new IndexFilterManager());
var sandoOptions = ServiceLocator.Resolve<ISandoOptionsProvider>().GetSandoOptions();
var loggerPath = Path.Combine(sandoOptions.ExtensionPointsPluginDirectoryPath, "ExtensionPointsLogger.log");
var logger = FileLogger.CreateFileLogger("ExtensionPointsLogger", loggerPath);
_extensionPointsConfiguration = ExtensionPointsConfigurationFileReader.ReadAndValidate(logger);
if (_extensionPointsConfiguration != null)
{
_extensionPointsConfiguration.PluginDirectoryPath = sandoOptions.ExtensionPointsPluginDirectoryPath;
ExtensionPointsConfigurationAnalyzer.FindAndRegisterValidExtensionPoints(_extensionPointsConfiguration, logger);
}
}
