public static IServiceProvider CreateDefaultServiceProvider(IOmniSharpEnvironment environment, IConfiguration configuration, IEventEmitter eventEmitter, IServiceCollection services = null)
{
services = services ?? new ServiceCollection();
services.AddSingleton(environment);
services.AddSingleton(eventEmitter);
// Caching
services.AddSingleton <IMemoryCache, MemoryCache>();
services.AddSingleton <IAssemblyLoader, AssemblyLoader>();
services.AddOptions();
services.AddSingleton <IDotNetCliService, DotNetCliService>();
// MSBuild
services.AddSingleton <IMSBuildLocator>(sp =>
MSBuildLocator.CreateDefault(
loggerFactory: sp.GetService <ILoggerFactory>(),
assemblyLoader: sp.GetService <IAssemblyLoader>()));
// Setup the options from configuration
services.Configure <OmniSharpOptions>(configuration);
services.AddLogging();
return(services.BuildServiceProvider());
}
public CakeScriptService(IOmniSharpEnvironment environment, ICakeConfiguration configuration, ILoggerFactory loggerFactory)
{
if (environment == null)
{
throw new ArgumentNullException(nameof(environment));
}
if (configuration == null)
{
throw new ArgumentNullException(nameof(configuration));
}
if (loggerFactory == null)
{
throw new ArgumentNullException(nameof(loggerFactory));
}
var serverExecutablePath = ScriptGenerationToolResolver.GetExecutablePath(environment.TargetDirectory, configuration);
if (File.Exists(serverExecutablePath))
{
_generationService = PlatformHelper.IsMono ?
new ScriptGenerationClient(new MonoScriptGenerationProcess(serverExecutablePath, environment, loggerFactory), environment.TargetDirectory, loggerFactory) :
new ScriptGenerationClient(serverExecutablePath, environment.TargetDirectory, loggerFactory);
}
IsConnected = _generationService != null;
_cachedReferences = new Dictionary <string, ISet <string> >();
_cachedUsings = new Dictionary <string, ISet <string> >();
}
private static void ProvideWorkspaceOptions(
CompositionHost compositionHost,
OmniSharpWorkspace workspace,
IOptionsMonitor <OmniSharpOptions> options,
ILogger logger,
IOmniSharpEnvironment omnisharpEnvironment)
{
// run all workspace options providers
var workspaceOptionsProviders = compositionHost.GetExports <IWorkspaceOptionsProvider>().OrderBy(x => x.Order);
foreach (var workspaceOptionsProvider in workspaceOptionsProviders)
{
var providerName = workspaceOptionsProvider.GetType().FullName;
try
{
logger.LogInformation($"Invoking Workspace Options Provider: {providerName}, Order: {workspaceOptionsProvider.Order}");
if (!workspace.TryApplyChanges(workspace.CurrentSolution.WithOptions(workspaceOptionsProvider.Process(workspace.Options, options.CurrentValue, omnisharpEnvironment))))
{
logger.LogWarning($"Couldn't apply options from Workspace Options Provider: {providerName}");
}
}
catch (Exception e)
{
var message = $"The workspace options provider '{providerName}' threw exception during execution.";
logger.LogError(e, message);
}
}
}
public ProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
IMSBuildLocator msbuildLocator,
DotNetCliService dotNetCliService,
SdksPathResolver sdksPathResolver,
MetadataFileReferenceCache metadataFileReferenceCache,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
FileSystemHelper fileSystemHelper,
ILoggerFactory loggerFactory)
{
_environment = environment;
_workspace = workspace;
_propertyOverrides = msbuildLocator.RegisteredInstance.PropertyOverrides;
_dotNetCli = dotNetCliService;
_sdksPathResolver = sdksPathResolver;
_metadataFileReferenceCache = metadataFileReferenceCache;
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_fileSystemHelper = fileSystemHelper;
_loggerFactory = loggerFactory;
_projectsToProcess = new Queue <ProjectFileInfo>();
_logger = loggerFactory.CreateLogger <ProjectSystem>();
}
public static IServiceProvider Create(
ITestOutputHelper testOutput,
IOmniSharpEnvironment environment,
IEnumerable <KeyValuePair <string, string> > configurationData = null,
DotNetCliVersion dotNetCliVersion = DotNetCliVersion.Current,
IEventEmitter eventEmitter = null)
{
var loggerFactory = new LoggerFactory()
.AddXunit(testOutput);
eventEmitter = eventEmitter ?? NullEventEmitter.Instance;
var assemblyLoader = CreateAssemblyLoader(loggerFactory);
var dotNetCliService = CreateDotNetCliService(dotNetCliVersion, loggerFactory, eventEmitter);
var configuration = CreateConfiguration(configurationData, dotNetCliService);
var memoryCache = CreateMemoryCache();
var msbuildLocator = CreateMSBuildLocator(loggerFactory, assemblyLoader);
var optionsMonitor = CreateOptionsMonitor(configuration);
var sharedTextWriter = CreateSharedTextWriter(testOutput);
var analyzerAssemblyLoader = new AnalyzerAssemblyLoader();
return(new TestServiceProvider(
environment, loggerFactory, assemblyLoader, analyzerAssemblyLoader, memoryCache, sharedTextWriter,
msbuildLocator, eventEmitter, dotNetCliService, configuration, optionsMonitor));
}
private TestServiceProvider(
IOmniSharpEnvironment environment,
ILoggerFactory loggerFactory,
IAssemblyLoader assemblyLoader,
IAnalyzerAssemblyLoader analyzerAssemblyLoader,
IMemoryCache memoryCache,
ISharedTextWriter sharedTextWriter,
IMSBuildLocator msbuildLocator,
IEventEmitter eventEmitter,
IDotNetCliService dotNetCliService,
IConfigurationRoot configuration,
IOptionsMonitor <OmniSharpOptions> optionsMonitor)
{
_logger = loggerFactory.CreateLogger <TestServiceProvider>();
AddService(environment);
AddService(loggerFactory);
AddService(assemblyLoader);
AddService(memoryCache);
AddService(sharedTextWriter);
AddService(msbuildLocator);
AddService(eventEmitter);
AddService(dotNetCliService);
AddService(configuration);
AddService(optionsMonitor);
AddService(analyzerAssemblyLoader);
}
private static bool LogFilter(string category, LogLevel level, IOmniSharpEnvironment environment)
{
if (environment.LogLevel > level)
{
return(false);
}
if (string.Equals(category, typeof(ExceptionHandlerMiddleware).FullName, StringComparison.OrdinalIgnoreCase))
{
return(true);
}
if (!category.StartsWith("OmniSharp", StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (string.Equals(category, typeof(WorkspaceInformationService).FullName, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
if (string.Equals(category, typeof(ProjectEventForwarder).FullName, StringComparison.OrdinalIgnoreCase))
{
return(false);
}
return(true);
}
public Startup(IOmniSharpEnvironment env)
{
_env = env;
var configBuilder = new ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddJsonFile(Constants.ConfigFile, optional: true)
.AddEnvironmentVariables("OMNISHARP_");
if (env.AdditionalArguments?.Length > 0)
{
configBuilder.AddCommandLine(env.AdditionalArguments);
}
// Use the global omnisharp config if there's any in the shared path
configBuilder.CreateAndAddGlobalOptionsFile(env);
// Use the local omnisharp config if there's any in the root path
configBuilder.AddJsonFile(
new PhysicalFileProvider(env.TargetDirectory).WrapForPolling(),
Constants.OptionsFile,
optional: true,
reloadOnChange: true);
Configuration = configBuilder.Build();
}
public ProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
IMSBuildLocator msbuildLocator,
IDotNetCliService dotNetCliService,
SdksPathResolver sdksPathResolver,
MetadataFileReferenceCache metadataFileReferenceCache,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
FileSystemHelper fileSystemHelper,
ILoggerFactory loggerFactory,
CachingCodeFixProviderForProjects codeFixesForProjects,
RulesetsForProjects rulesetsForProjects,
IAnalyzerAssemblyLoader assemblyLoader,
[ImportMany] IEnumerable <IMSBuildEventSink> eventSinks)
{
_environment = environment;
_workspace = workspace;
_propertyOverrides = msbuildLocator.RegisteredInstance.PropertyOverrides;
_dotNetCli = dotNetCliService;
_sdksPathResolver = sdksPathResolver;
_metadataFileReferenceCache = metadataFileReferenceCache;
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_fileSystemHelper = fileSystemHelper;
_loggerFactory = loggerFactory;
_rulesetsForProjects = rulesetsForProjects;
_eventSinks = eventSinks.ToImmutableArray();
_projectsToProcess = new Queue <ProjectFileInfo>();
_logger = loggerFactory.CreateLogger <ProjectSystem>();
_assemblyLoader = assemblyLoader;
}
public TestServiceProvider(
IOmniSharpEnvironment environment,
ILoggerFactory loggerFactory,
ISharedTextWriter sharedTextWriter,
IConfiguration configuration)
{
_logger = loggerFactory.CreateLogger <TestServiceProvider>();
_services[typeof(IOptionsMonitor <OmniSharpOptions>)] = new OptionsMonitor <OmniSharpOptions>(
new IConfigureOptions <OmniSharpOptions>[] {
new ConfigureOptions <OmniSharpOptions>(c => ConfigurationBinder.Bind(configuration, c))
},
Enumerable.Empty <IOptionsChangeTokenSource <OmniSharpOptions> >()
);
var assemblyLoader = new AssemblyLoader(loggerFactory);
var msbuildLocator = MSBuildLocator.CreateStandAlone(loggerFactory, assemblyLoader, allowMonoPaths: false);
var memoryCache = new MemoryCache(new MemoryCacheOptions());
_services[typeof(ILoggerFactory)] = loggerFactory;
_services[typeof(IOmniSharpEnvironment)] = environment;
_services[typeof(IAssemblyLoader)] = assemblyLoader;
_services[typeof(IMemoryCache)] = memoryCache;
_services[typeof(ISharedTextWriter)] = sharedTextWriter;
_services[typeof(IMSBuildLocator)] = msbuildLocator;
}
public ScriptProjectSystem(OmniSharpWorkspace workspace, IOmniSharpEnvironment env, ILoggerFactory loggerFactory,
MetadataFileReferenceCache metadataFileReferenceCache, IFileSystemWatcher fileSystemWatcher)
{
_metadataFileReferenceCache = metadataFileReferenceCache;
_workspace = workspace;
_env = env;
_fileSystemWatcher = fileSystemWatcher;
_logger = loggerFactory.CreateLogger <ScriptProjectSystem>();
_projects = new ConcurrentDictionary <string, ProjectInfo>();
_compilationDependencyResolver = new CompilationDependencyResolver(type =>
{
// Prefix with "OmniSharp" so that we make it through the log filter.
var categoryName = $"OmniSharp.Script.{type.FullName}";
var dependencyResolverLogger = loggerFactory.CreateLogger(categoryName);
return((level, message) =>
{
if (level == LogLevel.Debug)
{
dependencyResolverLogger.LogDebug(message);
}
if (level == LogLevel.Info)
{
dependencyResolverLogger.LogInformation(message);
}
});
});
}
public CakeConfiguration(IOmniSharpEnvironment environment, ILoggerFactory loggerFactory)
{
_lookup = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase);
// Parse the configuration file.
var configurationPath = Path.Combine(environment.TargetDirectory, "cake.config");
if (File.Exists(configurationPath))
{
try
{
var parser = new ConfigurationParser();
var configuration = parser.Read(configurationPath);
foreach (var key in configuration.Keys)
{
_lookup[KeyNormalizer.Normalize(key)] = configuration[key];
}
}
catch (Exception ex)
{
loggerFactory
.CreateLogger <CakeConfiguration>()
.LogError(ex, "Error occured while parsing Cake configuration.");
}
}
}
private static void ProvideWorkspaceOptions(
CompositionHost compositionHost,
OmniSharpWorkspace workspace,
IOptionsMonitor <OmniSharpOptions> options,
ILogger logger,
IOmniSharpEnvironment omnisharpEnvironment)
{
// run all workspace options providers
var workspaceOptionsProviders = compositionHost.GetExports <IWorkspaceOptionsProvider>().OrderBy(x => x.Order);
foreach (var workspaceOptionsProvider in workspaceOptionsProviders)
{
var providerName = workspaceOptionsProvider.GetType().FullName;
try
{
LoggerExtensions.LogInformation(logger, $"Invoking Workspace Options Provider: {providerName}, Order: {workspaceOptionsProvider.Order}");
workspace.Options = workspaceOptionsProvider.Process(workspace.Options, options.CurrentValue, omnisharpEnvironment);
}
catch (Exception e)
{
var message = $"The workspace options provider '{providerName}' threw exception during execution.";
logger.LogError(e, message);
}
}
}
public ConfigurationBuilder(IOmniSharpEnvironment environment)
{
_environment = environment;
_builder = new Microsoft.Extensions.Configuration.ConfigurationBuilder()
.SetBasePath(AppContext.BaseDirectory)
.AddJsonFile(Constants.ConfigFile, optional: true);
}
public Startup(IOmniSharpEnvironment environment, IEventEmitter eventEmitter, ISharedTextWriter writer)
{
_environment = environment;
_eventEmitter = eventEmitter;
_writer = writer;
_configuration = new ConfigurationBuilder(environment).Build();
}
public CakeScriptService(IOmniSharpEnvironment environment, ICakeConfiguration cakeConfiguration, ILoggerFactory loggerFactory)
{
_environment = environment ?? throw new ArgumentNullException(nameof(environment));
_cakeConfiguration = cakeConfiguration ?? throw new ArgumentNullException(nameof(cakeConfiguration));
_loggerFactory = loggerFactory ?? throw new ArgumentNullException(nameof(loggerFactory));
_cachedReferences = new Dictionary <string, ISet <string> >();
_cachedUsings = new Dictionary <string, ISet <string> >();
}
public ScriptProjectSystem(OmniSharpWorkspace workspace, IOmniSharpEnvironment env, ILoggerFactory loggerFactory, MetadataFileReferenceCache metadataFileReferenceCache)
{
_metadataFileReferenceCache = metadataFileReferenceCache;
_workspace = workspace;
_env = env;
_logger = loggerFactory.CreateLogger <ScriptProjectSystem>();
_projects = new Dictionary <string, ProjectInfo>();
_scriptProjectProvider = ScriptProjectProvider.Create(loggerFactory);
}
public TestServiceProvider(IOmniSharpEnvironment environment, ILoggerFactory loggerFactory, ISharedTextWriter sharedTextWriter)
{
_logger = loggerFactory.CreateLogger <TestServiceProvider>();
_services[typeof(ILoggerFactory)] = loggerFactory;
_services[typeof(IOmniSharpEnvironment)] = environment;
_services[typeof(IAssemblyLoader)] = new AssemblyLoader(loggerFactory);
_services[typeof(IMemoryCache)] = new MemoryCache(new MemoryCacheOptions());
_services[typeof(ISharedTextWriter)] = sharedTextWriter;
}
public ScriptProjectProvider(ScriptOptions scriptOptions, IOmniSharpEnvironment env, ILoggerFactory loggerFactory, bool isDesktopClr)
{
_scriptOptions = scriptOptions ?? throw new ArgumentNullException(nameof(scriptOptions));
_env = env ?? throw new ArgumentNullException(nameof(env));
_logger = loggerFactory.CreateLogger <ScriptProjectSystem>();
_compilationOptions = new Lazy <CSharpCompilationOptions>(CreateCompilationOptions);
_commandLineArgs = new Lazy <CSharpCommandLineArguments>(CreateCommandLineArguments);
_isDesktopClr = isDesktopClr;
}
public PluginProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
ILoggerFactory loggerFactory)
{
_environment = environment;
_workspace = workspace;
_loggerFactory = loggerFactory;
_logger = loggerFactory.CreateLogger <PluginProjectSystem>();
}
public string GetNormalizedRspFilePath(IOmniSharpEnvironment env)
{
if (string.IsNullOrWhiteSpace(RspFilePath))
{
return(null);
}
return(Path.IsPathRooted(RspFilePath)
? RspFilePath
: Path.Combine(env.TargetDirectory, RspFilePath));
}
public ScriptProjectSystem(OmniSharpWorkspace workspace, IOmniSharpEnvironment env, ILoggerFactory loggerFactory,
ScriptContextProvider scriptContextProvider, IFileSystemWatcher fileSystemWatcher, FileSystemHelper fileSystemHelper)
{
_workspace = workspace;
_env = env;
_fileSystemWatcher = fileSystemWatcher;
_fileSystemHelper = fileSystemHelper;
_logger = loggerFactory.CreateLogger <ScriptProjectSystem>();
_scriptContextProvider = scriptContextProvider;
}
public static IServiceProvider CreateDefaultServiceProvider(
IOmniSharpEnvironment environment,
IConfigurationRoot configuration,
IEventEmitter eventEmitter,
IServiceCollection services = null,
Action <ILoggingBuilder> configureLogging = null)
{
services ??= new ServiceCollection();
services.TryAddSingleton(_ => new ManualFileSystemWatcher());
services.TryAddSingleton <IFileSystemNotifier>(sp => sp.GetRequiredService <ManualFileSystemWatcher>());
services.TryAddSingleton <IFileSystemWatcher>(sp => sp.GetRequiredService <ManualFileSystemWatcher>());
services.AddSingleton(environment);
services.AddSingleton(eventEmitter);
// Caching
services.AddSingleton <IMemoryCache, MemoryCache>();
services.AddSingleton <IAssemblyLoader, AssemblyLoader>();
services.AddSingleton <IAnalyzerAssemblyLoader, AnalyzerAssemblyLoader>();
services.AddOptions();
services.AddSingleton <IDotNetCliService, DotNetCliService>();
// MSBuild
services.AddSingleton <IMSBuildLocator>(sp =>
MSBuildLocator.CreateDefault(
loggerFactory: sp.GetService <ILoggerFactory>(),
assemblyLoader: sp.GetService <IAssemblyLoader>(),
msbuildConfiguration: configuration.GetSection("msbuild")));
// Setup the options from configuration
services.Configure <OmniSharpOptions>(configuration)
.PostConfigure <OmniSharpOptions>(OmniSharpOptions.PostConfigure);
services.AddSingleton(configuration);
services.AddSingleton <IConfiguration>(configuration);
services.AddLogging(builder =>
{
var workspaceInformationServiceName = typeof(WorkspaceInformationService).FullName;
var projectEventForwarder = typeof(ProjectEventForwarder).FullName;
builder.AddFilter(
(category, logLevel) =>
environment.LogLevel <= logLevel &&
category.StartsWith("OmniSharp", StringComparison.OrdinalIgnoreCase) &&
!category.Equals(workspaceInformationServiceName, StringComparison.OrdinalIgnoreCase) &&
!category.Equals(projectEventForwarder, StringComparison.OrdinalIgnoreCase));
configureLogging?.Invoke(builder);
});
return(services.BuildServiceProvider());
}
public CompositionHostBuilder(
IServiceProvider serviceProvider,
IOmniSharpEnvironment environment,
IEventEmitter eventEmitter,
IEnumerable <Assembly> assemblies = null)
{
_serviceProvider = serviceProvider;
_environment = environment;
_eventEmitter = eventEmitter;
_assemblies = assemblies ?? Array.Empty <Assembly>();
}
public string GetNormalizedRspFilePath(IOmniSharpEnvironment env)
{
if (string.IsNullOrWhiteSpace(RspFilePath))
{
return(null);
}
var expandedPath = Environment.ExpandEnvironmentVariables(RspFilePath);
return(Path.IsPathRooted(expandedPath)
? expandedPath
: Path.Combine(env.TargetDirectory, expandedPath));
}
public Host(
IOmniSharpEnvironment environment,
ISharedTextWriter sharedTextWriter,
PluginAssemblies commandLinePlugins,
int serverPort,
string serverInterface)
{
_environment = environment;
_sharedTextWriter = sharedTextWriter;
_commandLinePlugins = commandLinePlugins;
_serverPort = serverPort;
_serverInterface = serverInterface;
}
public CakeProjectSystem(
OmniSharpWorkspace workspace,
IOmniSharpEnvironment environment,
IAssemblyLoader assemblyLoader,
ICakeScriptService scriptService,
ILoggerFactory loggerFactory)
{
_workspace = workspace ?? throw new ArgumentNullException(nameof(workspace));
_environment = environment ?? throw new ArgumentNullException(nameof(environment));
_assemblyLoader = assemblyLoader ?? throw new ArgumentNullException(nameof(assemblyLoader));
_scriptService = scriptService ?? throw new ArgumentNullException(nameof(scriptService));
_logger = loggerFactory?.CreateLogger <CakeProjectSystem>() ?? throw new ArgumentNullException(nameof(loggerFactory));
_projects = new Dictionary <string, ProjectInfo>();
_compilationOptions = new Lazy <CSharpCompilationOptions>(CreateCompilationOptions);
}
public TestServiceProvider(IOmniSharpEnvironment environment, ILoggerFactory loggerFactory, ISharedTextWriter sharedTextWriter, IConfiguration configuration)
{
_logger = loggerFactory.CreateLogger <TestServiceProvider>();
_services[typeof(IOptionsMonitor <OmniSharpOptions>)] = new OptionsMonitor <OmniSharpOptions>(
new IConfigureOptions <OmniSharpOptions>[] {
new ConfigureOptions <OmniSharpOptions>(c => ConfigurationBinder.Bind(configuration, c))
},
Enumerable.Empty <IOptionsChangeTokenSource <OmniSharpOptions> >()
);
_services[typeof(ILoggerFactory)] = loggerFactory;
_services[typeof(IOmniSharpEnvironment)] = environment;
_services[typeof(IAssemblyLoader)] = new AssemblyLoader(loggerFactory);
_services[typeof(IMemoryCache)] = new MemoryCache(new MemoryCacheOptions());
_services[typeof(ISharedTextWriter)] = sharedTextWriter;
}
public DotNetProjectSystem(
IOmniSharpEnvironment environment,
OmniSharpWorkspace workspace,
IDotNetCliService dotNetCliService,
MetadataFileReferenceCache metadataFileReferenceCache,
IEventEmitter eventEmitter,
IFileSystemWatcher fileSystemWatcher,
ILoggerFactory loggerFactory)
{
_environment = environment;
_workspace = workspace;
_dotNetCliService = dotNetCliService;
_metadataFileReferenceCache = metadataFileReferenceCache;
_eventEmitter = eventEmitter;
_fileSystemWatcher = fileSystemWatcher;
_logger = loggerFactory.CreateLogger <DotNetProjectSystem>();
_projectStates = new ProjectStatesCache(loggerFactory, _eventEmitter);
}
public FileSystemWatcherWrapper(IOmniSharpEnvironment env)
{
// Environment.SetEnvironmentVariable ("MONO_MANAGED_WATCHER", "1");
_watcher = new FileSystemWatcher(env.TargetDirectory)
{
IncludeSubdirectories = true,
EnableRaisingEvents = true,
};
_watcher.Changed += OnChanged;
_watcher.Created += OnChanged;
_watcher.Deleted += OnChanged;
_watcher.Renamed += (sender, e) =>
{
TriggerChange(e.OldFullPath);
TriggerChange(e.FullPath);
};
}
