public ProjectStateResolver(CompilationEngine compilationEngine,
FrameworkReferenceResolver frameworkReferenceResolver,
Func<CacheContext, Project, FrameworkName, ApplicationHostContext> applicaitonHostContextCreator)
{
_compilationEngine = compilationEngine;
_frameworkReferenceResolver = frameworkReferenceResolver;
_applicationHostContextCreator = applicaitonHostContextCreator;
}
private async Task OpenChannel(int port, string hostId)
{
var contexts = new Dictionary<int, ApplicationContext>();
var protocolManager = new ProtocolManager(maxVersion: 3);
// REVIEW: Should these be on a shared context object that flows?
var applicationEnvironment = (IApplicationEnvironment)_services.GetService(typeof(IApplicationEnvironment));
var runtimeEnvironment = (IRuntimeEnvironment)_services.GetService(typeof(IRuntimeEnvironment));
var loadContextAccessor = (IAssemblyLoadContextAccessor)_services.GetService(typeof(IAssemblyLoadContextAccessor));
var compilationEngine = new CompilationEngine(new CompilationEngineContext(applicationEnvironment, runtimeEnvironment, loadContextAccessor.Default, new CompilationCache()));
var frameworkResolver = new FrameworkReferenceResolver();
// This fixes the mono incompatibility but ties it to ipv4 connections
var listenSocket = new Socket(AddressFamily.InterNetwork, SocketType.Stream, ProtocolType.Tcp);
listenSocket.Bind(new IPEndPoint(IPAddress.Loopback, port));
listenSocket.Listen(10);
Console.WriteLine($"Process ID {Process.GetCurrentProcess().Id}");
Console.WriteLine("Listening on port {0}", port);
while (true)
{
var acceptSocket = await AcceptAsync(listenSocket);
Console.WriteLine("Client accepted {0}", acceptSocket.LocalEndPoint);
var stream = new NetworkStream(acceptSocket);
var queue = new ProcessingQueue(stream);
var connection = new ConnectionContext(
contexts,
_services,
applicationEnvironment,
runtimeEnvironment,
loadContextAccessor,
frameworkResolver,
queue,
protocolManager,
compilationEngine,
hostId);
queue.OnReceive += message =>
{
// Enumerates all project contexts and return them to the
// sender
if (message.MessageType == "EnumerateProjectContexts")
{
WriteProjectContexts(message, queue, contexts);
}
else
{
// Otherwise it's a context specific message
connection.OnReceive(message);
}
};
queue.Start();
}
}
public ConnectionContext(IDictionary<int, ApplicationContext> contexts,
IServiceProvider services,
IApplicationEnvironment applicationEnvironment,
IAssemblyLoadContextAccessor loadContextAccessor,
FrameworkReferenceResolver frameworkResolver,
ProcessingQueue queue,
ProtocolManager protocolManager,
CompilationEngine compilationEngine,
string hostId)
{
_contexts = contexts;
_services = services;
_applicationEnvironment = applicationEnvironment;
_loadContextAccessor = loadContextAccessor;
_frameworkResolver = frameworkResolver;
_queue = queue;
_compilationEngine = compilationEngine;
_protocolManager = protocolManager;
_compilationEngine = compilationEngine;
_hostId = hostId;
}
public ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver frameworkReferenceResolver)
{
FrameworkResolver = frameworkReferenceResolver;
}
public ApplicationHostContext(IServiceProvider hostServices,
string projectDirectory,
string packagesDirectory,
string configuration,
FrameworkName targetFramework,
IAssemblyLoadContextFactory loadContextFactory = null,
bool skipLockFileValidation = false)
{
ProjectDirectory = projectDirectory;
Configuration = configuration;
RootDirectory = Runtime.ProjectResolver.ResolveRootDirectory(ProjectDirectory);
ProjectResolver = new ProjectResolver(ProjectDirectory, RootDirectory);
FrameworkReferenceResolver = new FrameworkReferenceResolver();
ProjectGraphProvider = new ProjectGraphProvider(hostServices);
_serviceProvider = new ServiceProvider(hostServices);
PackagesDirectory = packagesDirectory ?? NuGetDependencyResolver.ResolveRepositoryPath(RootDirectory);
var referenceAssemblyDependencyResolver = new ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver);
NuGetDependencyProvider = new NuGetDependencyResolver(new PackageRepository(PackagesDirectory));
var gacDependencyResolver = new GacDependencyResolver();
ProjectDependencyProvider = new ProjectReferenceDependencyProvider(ProjectResolver);
var unresolvedDependencyProvider = new UnresolvedDependencyProvider();
var projectName = PathUtility.GetDirectoryName(ProjectDirectory);
Project project;
if (ProjectResolver.TryResolveProject(projectName, out project))
{
Project = project;
}
else
{
throw new InvalidOperationException(
string.Format("Unable to resolve project '{0}' from {1}", projectName, ProjectDirectory));
}
var projectLockJsonPath = Path.Combine(ProjectDirectory, LockFileReader.LockFileName);
var lockFileExists = File.Exists(projectLockJsonPath);
var validLockFile = false;
if (lockFileExists)
{
var lockFileReader = new LockFileReader();
_lockFile = lockFileReader.Read(projectLockJsonPath);
validLockFile = _lockFile.IsValidForProject(project);
// When the only invalid part of a lock file is version number,
// we shouldn't skip lock file validation because we want to leave all dependencies unresolved, so that
// VS can be aware of this version mismatch error and automatically do restore
skipLockFileValidation = skipLockFileValidation && (_lockFile.Version == Constants.LockFileVersion);
if (validLockFile || skipLockFileValidation)
{
NuGetDependencyProvider.ApplyLockFile(_lockFile);
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDependencyProvider,
NuGetDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
}
if ((!validLockFile && !skipLockFileValidation) || !lockFileExists)
{
// We don't add NuGetDependencyProvider to DependencyWalker
// It will leave all NuGet packages unresolved and give error message asking users to run "dnu restore"
DependencyWalker = new DependencyWalker(new IDependencyProvider[] {
ProjectDependencyProvider,
referenceAssemblyDependencyResolver,
gacDependencyResolver,
unresolvedDependencyProvider
});
}
LibraryManager = new LibraryManager(() => DependencyWalker.Libraries);
AssemblyLoadContextFactory = loadContextFactory ?? new RuntimeLoadContextFactory(ServiceProvider);
// Create a new Application Environment for running the app. It needs a reference to the Host's application environment
// (if any), which we can get from the service provider we were given.
// If this is null (i.e. there is no Host Application Environment), that's OK, the Application Environment we are creating
// will just have it's own independent set of global data.
IApplicationEnvironment hostEnvironment = null;
if (hostServices != null)
{
hostEnvironment = (IApplicationEnvironment)hostServices.GetService(typeof(IApplicationEnvironment));
}
ApplicationEnvironment = new ApplicationEnvironment(Project, targetFramework, configuration, hostEnvironment);
// Default services
_serviceProvider.Add(typeof(IApplicationEnvironment), ApplicationEnvironment);
_serviceProvider.Add(typeof(ILibraryManager), LibraryManager);
_serviceProvider.Add(typeof(ICompilerOptionsProvider), new CompilerOptionsProvider(ProjectResolver));
// Not exposed to the application layer
_serviceProvider.Add(typeof(IProjectResolver), ProjectResolver, includeInManifest: false);
_serviceProvider.Add(typeof(NuGetDependencyResolver), NuGetDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(ProjectReferenceDependencyProvider), ProjectDependencyProvider, includeInManifest: false);
_serviceProvider.Add(typeof(IAssemblyLoadContextFactory), AssemblyLoadContextFactory, includeInManifest: false);
}
public ReferenceAssemblyDependencyResolver(FrameworkReferenceResolver frameworkReferenceResolver)
{
FrameworkResolver = frameworkReferenceResolver;
}
