/// <summary> /// Creates a build request. /// </summary> private BuildRequest CreateBuildRequest(int nodeRequestId, int configId, string[] targets, NodeAffinity nodeAffinity, BuildRequest parentRequest) { HostServices hostServices = null; if (nodeAffinity != NodeAffinity.Any) { hostServices = new HostServices(); hostServices.SetNodeAffinity(String.Empty, nodeAffinity); } BuildRequest request = new BuildRequest(1 /* submissionId */, nodeRequestId, configId, targets, hostServices, BuildEventContext.Invalid, parentRequest); return(request); }
public void TestClearingAffinities() { HostServices hostServices = new HostServices(); hostServices.SetNodeAffinity("project", NodeAffinity.OutOfProc); Assert.Equal(NodeAffinity.OutOfProc, hostServices.GetNodeAffinity("project")); hostServices.SetNodeAffinity(null, NodeAffinity.OutOfProc); Assert.Equal(NodeAffinity.Any, hostServices.GetNodeAffinity("project")); hostServices.SetNodeAffinity(String.Empty, NodeAffinity.OutOfProc); Assert.Equal(NodeAffinity.OutOfProc, hostServices.GetNodeAffinity("project")); hostServices.SetNodeAffinity(null, NodeAffinity.OutOfProc); Assert.Equal(NodeAffinity.Any, hostServices.GetNodeAffinity("project")); }
public void UnloadedProjectDiscardsHostServicesAllProjects() { HostServices hostServices = new HostServices(); TestHostObject th = new TestHostObject(); ProjectCollection.GlobalProjectCollection.HostServices = hostServices; Project project = LoadDummyProject("foo.proj"); hostServices.RegisterHostObject(project.FullPath, "test", "Message", th); ProjectCollection.GlobalProjectCollection.UnloadAllProjects(); Assert.False(hostServices.HasHostObject(project.FullPath)); }
public override async Task InitializeAsync() { // Let's re-create the database first await using var dbContext = HostServices.GetRequiredService <IDbContextFactory <AppDbContext> >().CreateDbContext(); await dbContext.Database.EnsureDeletedAsync(); await dbContext.Database.EnsureCreatedAsync(); await base.InitializeAsync(); await Host.StartAsync(); await Task.Delay(100); }
/// <summary> /// Create a new instance of a workspace that can be populated by opening solution and project files. /// </summary> /// <param name="properties">The MSBuild properties used when interpreting project files. /// These are the same properties that are passed to msbuild via the /property:<n>=<v> command line argument.</param> /// <param name="hostServices">The <see cref="HostServices"/> used to configure this workspace.</param> public static ErgonWorkspace Create(IDictionary <string, string> properties, HostServices hostServices) { if (properties == null) { throw new ArgumentNullException(nameof(properties)); } if (hostServices == null) { throw new ArgumentNullException(nameof(hostServices)); } return(new ErgonWorkspace(hostServices, properties.ToImmutableDictionary())); }
public void TestValidHostObjectRegistration() { HostServices hostServices = new HostServices(); TestHostObject hostObject = new TestHostObject(); TestHostObject hostObject2 = new TestHostObject(); TestHostObject hostObject3 = new TestHostObject(); hostServices.RegisterHostObject("foo.proj", "target", "task", hostObject); hostServices.RegisterHostObject("foo.proj", "target2", "task", hostObject2); hostServices.RegisterHostObject("foo.proj", "target", "task2", hostObject3); Assert.Same(hostObject, hostServices.GetHostObject("foo.proj", "target", "task")); Assert.Same(hostObject2, hostServices.GetHostObject("foo.proj", "target2", "task")); Assert.Same(hostObject3, hostServices.GetHostObject("foo.proj", "target", "task2")); }
internal VisualStudioWorkspace(HostServices hostServices) : base(hostServices, WorkspaceKind.Host) { _backgroundCompiler = new BackgroundCompiler(this); var cacheService = Services.GetService <IWorkspaceCacheService>(); if (cacheService != null) { cacheService.CacheFlushRequested += OnCacheFlushRequested; } _backgroundParser = new BackgroundParser(this); _backgroundParser.Start(); }
public void TestTranslationHostObjectsWhenEmpty() { var hostServices = new HostServices(); BuildRequest request = new BuildRequest( submissionId: 1, _nodeRequestId++, 1, new string[] { "alpha", "omega" }, hostServices: hostServices, BuildEventContext.Invalid, parentRequest: null); ((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator()); BuildRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator()); }
/// <summary> /// Constructs a new workspace instance. /// </summary> /// <param name="host">The <see cref="HostServices"/> this workspace uses</param> /// <param name="workspaceKind">A string that can be used to identify the kind of workspace. Usually this matches the name of the class.</param> protected Workspace(HostServices host, string workspaceKind) { this.primaryBranchId = BranchId.GetNextId(); this.workspaceKind = workspaceKind; this.services = host.CreateWorkspaceServices(this); // queue used for sending events var workspaceTaskSchedulerFactory = this.services.GetService <IWorkspaceTaskSchedulerFactory>(); this.taskQueue = workspaceTaskSchedulerFactory.CreateTaskQueue(); // initialize with empty solution this.latestSolution = CreateSolution(SolutionId.CreateNewId()); }
async Task InitializeInstanceAsync() { var timings = new Dictionary <string, long> (); var metadata = new CompositionLoadMetadata(timings); using (var timer = Counters.CompositionLoad.BeginTiming(metadata)) { var fullTimer = System.Diagnostics.Stopwatch.StartNew(); var stepTimer = System.Diagnostics.Stopwatch.StartNew(); var mefAssemblies = ReadAssembliesFromAddins(timer); timings ["ReadFromAddins"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); var caching = new Caching(mefAssemblies, new IdeRuntimeCompositionExceptionHandler()); // Try to use cached MEF data var canUse = metadata.ValidCache = caching.CanUse(); if (canUse) { LoggingService.LogInfo("Creating MEF composition from cache"); RuntimeComposition = await TryCreateRuntimeCompositionFromCache(caching); } timings ["LoadFromCache"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); // Otherwise fallback to runtime discovery. if (RuntimeComposition == null) { LoggingService.LogInfo("Creating MEF composition from runtime"); var(runtimeComposition, catalog) = await CreateRuntimeCompositionFromDiscovery(caching, timer); RuntimeComposition = runtimeComposition; CachedComposition cacheManager = new CachedComposition(); caching.Write(RuntimeComposition, catalog, cacheManager).Ignore(); } timings ["LoadRuntimeComposition"] = stepTimer.ElapsedMilliseconds; stepTimer.Restart(); ExportProviderFactory = RuntimeComposition.CreateExportProviderFactory(); ExportProvider = ExportProviderFactory.CreateExportProvider(); HostServices = Microsoft.VisualStudio.LanguageServices.VisualStudioMefHostServices.Create(ExportProvider); timings ["CreateServices"] = stepTimer.ElapsedMilliseconds; metadata.Duration = fullTimer.ElapsedMilliseconds; } }
public bool Stop() { Log.LogInfo("Stopping service"); _listener.Stop(); _cacheServer.Stop(); Log.LogInfo("Service stopped successfully"); // stop this after last log HostServices.Stop(); return(true); }
internal RoslynWorkspace(HostServices host, NuGetConfiguration nuGetConfiguration, CompositionHost compositionContext, string dotnetPath, string sdkPath) : base(host, WorkspaceKind.Host) { this.dotnetPath = dotnetPath; this.sdkPath = sdkPath; _nuGetConfiguration = nuGetConfiguration; _openDocumentTextLoaders = new Dictionary <DocumentId, AvalonEditTextContainer>(); _diagnosticsUpdatedNotifiers = new ConcurrentDictionary <DocumentId, Action <DiagnosticsUpdatedArgs> >(); _compositionContext = compositionContext; this.EnableDiagnostics(DiagnosticOptions.Semantic | DiagnosticOptions.Syntax); GetService <IDiagnosticService>().DiagnosticsUpdated += OnDiagnosticsUpdated; }
public void TestGeneralAffinityRegistration() { HostServices hostServices = new HostServices(); hostServices.SetNodeAffinity(String.Empty, NodeAffinity.InProc); Assert.Equal(NodeAffinity.InProc, hostServices.GetNodeAffinity("project")); Assert.Equal(NodeAffinity.InProc, hostServices.GetNodeAffinity("project2")); hostServices.SetNodeAffinity(String.Empty, NodeAffinity.OutOfProc); Assert.Equal(NodeAffinity.OutOfProc, hostServices.GetNodeAffinity("project")); Assert.Equal(NodeAffinity.OutOfProc, hostServices.GetNodeAffinity("project2")); hostServices.SetNodeAffinity(String.Empty, NodeAffinity.Any); Assert.Equal(NodeAffinity.Any, hostServices.GetNodeAffinity("project")); Assert.Equal(NodeAffinity.Any, hostServices.GetNodeAffinity("project2")); }
public void TestUnregisteringNonConflictingHostObjectRestoresOriginalAffinity() { HostServices hostServices = new HostServices(); TestHostObject hostObject = new TestHostObject(); hostServices.SetNodeAffinity(String.Empty, NodeAffinity.OutOfProc); hostServices.SetNodeAffinity("project", NodeAffinity.Any); Assert.Equal(NodeAffinity.OutOfProc, hostServices.GetNodeAffinity("project2")); Assert.Equal(NodeAffinity.Any, hostServices.GetNodeAffinity("project")); hostServices.RegisterHostObject("project", "target", "task", hostObject); Assert.Equal(NodeAffinity.InProc, hostServices.GetNodeAffinity("project")); hostServices.RegisterHostObject("project", "target", "task", hostObject: null); Assert.Equal(NodeAffinity.Any, hostServices.GetNodeAffinity("project")); Assert.Equal(NodeAffinity.OutOfProc, hostServices.GetNodeAffinity("project2")); }
public void CloneTargets() { var hostServices = new HostServices(); ProjectInstance first = GetSampleProjectInstance(hostServices); ProjectInstance second = first.DeepCopy(); // Targets, tasks are immutable so we can expect the same objects Assert.True(Object.ReferenceEquals(first.Targets, second.Targets)); Assert.True(Object.ReferenceEquals(first.Targets["t"], second.Targets["t"])); var firstTasks = first.Targets["t"]; var secondTasks = second.Targets["t"]; Assert.True(Object.ReferenceEquals(firstTasks.Children[0], secondTasks.Children[0])); }
public HttpResponseMessage CreateCustomer(CreateCustomerRequest request) { CreateCustomerResponse responseData = null; try { //Authenticate API key long?hostId = HostServices.GetCallerHostId(); if (!hostId.HasValue) { Log.Warn(ResponseMessages.InvalidAPIKey); return(Request.CreateResponse(new GenericResponse(null, ResponseCodes.InvalidAPIKey, ResponseMessages.InvalidAPIKey))); } //Validate input if (request == null || string.IsNullOrEmpty(request.ReferenceId)) { return(Request.CreateResponse(new GenericResponse(null, ResponseCodes.InvalidParam, ResponseMessages.InvalidParam))); } //Validate input length if (request.ReferenceId.Length > 30) { return(Request.CreateResponse(new GenericResponse(null, ResponseCodes.InvalidParam, "Reference ID (max 30 length) is too long."))); } //Validate customer reference ID IdentityServices identityService = new IdentityServices(); if (identityService.IsRefIdExists(IdentityServices.RefIdTypes.Customer, hostId.Value, request.ReferenceId)) { return(Request.CreateResponse(new GenericResponse(null, ResponseCodes.DuplicateRefId, ResponseMessages.DuplicateRefId + " (Customer " + request.ReferenceId + ")"))); } //Perform transaction CustomerServices customerServices = new CustomerServices(); responseData = customerServices.CreateCustomer(hostId.Value, request); //Send response return(Request.CreateResponse(new GenericResponse(responseData, ResponseCodes.Success, ResponseMessages.Success))); } catch (Exception ex) { Log.Exception(ex); return(Request.CreateResponse(new GenericResponse(null, ResponseCodes.Error, ResponseMessages.Error))); } }
static WorkspaceHacks() { var assemblyNames = new[] { "Microsoft.CodeAnalysis.Workspaces", "Microsoft.CodeAnalysis.Workspaces.Desktop", "Microsoft.CodeAnalysis.CSharp.Workspaces", "Microsoft.CodeAnalysis.VisualBasic.Workspaces", "Microsoft.CodeAnalysis.Features", "Microsoft.CodeAnalysis.CSharp.Features", "Microsoft.CodeAnalysis.VisualBasic.Features" }; var assemblies = assemblyNames .Select(n => Assembly.Load(n)); Pack = MefHostServices.Create(assemblies); }
/// <summary> /// Create a ProjectInstance from provided project content and host services object /// </summary> private static ProjectInstance GetProjectInstance(string content, HostServices hostServices, IDictionary <string, string> globalProperties, ProjectCollection projectCollection, string toolsVersion = null) { XmlReader reader = XmlReader.Create(new StringReader(content)); if (globalProperties == null) { // choose some interesting defaults if we weren't explicitly asked to use a set. globalProperties = new Dictionary <string, string>(StringComparer.OrdinalIgnoreCase); globalProperties.Add("g1", "v1"); globalProperties.Add("g2", "v2"); } Project project = new Project(reader, globalProperties, toolsVersion ?? ObjectModelHelpers.MSBuildDefaultToolsVersion, projectCollection ?? ProjectCollection.GlobalProjectCollection); ProjectInstance instance = project.CreateProjectInstance(); return(instance); }
public BuildRequest( int submissionId, int nodeRequestId, int configurationId, ProxyTargets proxyTargets, HostServices hostServices, BuildRequestDataFlags buildRequestDataFlags = BuildRequestDataFlags.None, RequestedProjectState requestedProjectState = null, int projectContextId = BuildEventContext.InvalidProjectContextId) : this(submissionId, nodeRequestId, configurationId, hostServices, buildRequestDataFlags, requestedProjectState, projectContextId) { _proxyTargets = proxyTargets; _targets = proxyTargets.ProxyTargetToRealTargetMap.Keys.ToList(); // Only root requests can have proxy targets. _parentGlobalRequestId = InvalidGlobalRequestId; _parentBuildEventContext = BuildEventContext.Invalid; }
public TemporaryWorkspace( HostServices hostServices, string?workspaceKind, SolutionInfo solutionInfo, SerializableOptionSet options ) : base(hostServices, workspaceKind) { SetOptions(Options.WithChangedOption(CacheOptions.RecoverableTreeLengthThreshold, 0)); var documentOptionsProviderFactories = ( (IMefHostExportProvider)Services.HostServices ).GetExports <IDocumentOptionsProviderFactory, OrderableMetadata>(); RegisterDocumentOptionProviders(documentOptionsProviderFactories); OnSolutionAdded(solutionInfo); SetCurrentSolution(CurrentSolution.WithOptions(options)); }
private async Task <string> GetXmlDocumentAsync(HostServices services) { using (var tempRoot = new TempRoot()) { // get original assembly location var mscorlibLocation = typeof(object).Assembly.Location; // set up dll and xml doc content var tempDir = tempRoot.CreateDirectory(); var tempCorlib = tempDir.CopyFile(mscorlibLocation); var tempCorlibXml = tempDir.CreateFile(Path.ChangeExtension(tempCorlib.Path, "xml")); tempCorlibXml.WriteAllText(@"<?xml version=""1.0"" encoding=""utf-8""?> <doc> <assembly> <name>mscorlib</name> </assembly> <members> <member name=""T:System.Object""> <summary>Supports all classes in the .NET Framework class hierarchy and provides low-level services to derived classes. This is the ultimate base class of all classes in the .NET Framework; it is the root of the type hierarchy.To browse the .NET Framework source code for this type, see the Reference Source.</summary> </member> </members> </doc>"); // currently portable layer doesn't support xml documment var solution = new AdhocWorkspace(services).CurrentSolution .AddProject("Project", "Project.dll", LanguageNames.CSharp) .AddMetadataReference(MetadataReference.CreateFromFile(tempCorlib.Path)) .Solution; var snapshotService = (new RemotableDataServiceFactory()).CreateService(solution.Workspace.Services) as IRemotableDataService; using (var scope = await snapshotService.CreatePinnedRemotableDataScopeAsync(solution, CancellationToken.None)) { // recover solution from given snapshot var recovered = await GetSolutionAsync(snapshotService, scope); var compilation = await recovered.Projects.First().GetCompilationAsync(CancellationToken.None); var objectType = compilation.GetTypeByMetadataName("System.Object"); var xmlDocComment = objectType.GetDocumentationCommentXml(); return(xmlDocComment); } } }
internal static Solution CreateFullSolution(HostServices hostServices = null) { var solution = new AdhocWorkspace(hostServices ?? Host.Mef.MefHostServices.DefaultHost).CurrentSolution; var csCode = "class A { }"; var project1 = solution.AddProject("Project", "Project.dll", LanguageNames.CSharp); var document1 = project1.AddDocument("Document1", SourceText.From(csCode)); var vbCode = "Class B\r\nEnd Class"; var project2 = document1.Project.Solution.AddProject("Project2", "Project2.dll", LanguageNames.VisualBasic); var document2 = project2.AddDocument("Document2", SourceText.From(vbCode)); project1 = document2.Project.Solution.GetProject(project1.Id).AddProjectReference(new ProjectReference(project2.Id, ImmutableArray.Create("test"))); project1 = project1.AddMetadataReference(MetadataReference.CreateFromFile(typeof(object).Assembly.Location)); project1 = project1.AddAnalyzerReference(new AnalyzerFileReference(typeof(object).Assembly.Location, new TestAnalyzerAssemblyLoader())); var textDocument1 = project1.AddAdditionalDocument("Additional", SourceText.From("hello"), ImmutableArray.Create("test"), @".\Add"); return(textDocument1.Project.Solution); }
private BuildRequest( int submissionId, int nodeRequestId, int configurationId, HostServices hostServices, BuildRequestDataFlags buildRequestDataFlags = BuildRequestDataFlags.None, RequestedProjectState requestedProjectState = null) { _submissionId = submissionId; _configurationId = configurationId; HostServices = hostServices; _buildEventContext = BuildEventContext.Invalid; _globalRequestId = InvalidGlobalRequestId; _nodeRequestId = nodeRequestId; _buildRequestDataFlags = buildRequestDataFlags; _requestedProjectState = requestedProjectState; }
public CSharpInteractiveEvaluator( HostServices hostServices, IViewClassifierAggregatorService classifierAggregator, IInteractiveWindowCommandsFactory commandsFactory, ImmutableArray <IInteractiveWindowCommand> commands, IContentTypeRegistryService contentTypeRegistry, string responseFileDirectory, string initialWorkingDirectory) : base( contentTypeRegistry.GetContentType(ContentTypeNames.CSharpContentType), hostServices, classifierAggregator, commandsFactory, commands, (responseFileDirectory != null) ? Path.Combine(responseFileDirectory, InteractiveResponseFile) : null, initialWorkingDirectory, typeof(CSharpReplServiceProvider)) { }
public CSharpInteractiveEvaluator( IThreadingContext threadingContext, HostServices hostServices, IViewClassifierAggregatorService classifierAggregator, IInteractiveWindowCommandsFactory commandsFactory, ImmutableArray <IInteractiveWindowCommand> commands, IContentTypeRegistryService contentTypeRegistry, string initialWorkingDirectory) : base( threadingContext, contentTypeRegistry.GetContentType(ContentTypeNames.CSharpContentType), hostServices, classifierAggregator, commandsFactory, commands, InteractiveResponseFile, initialWorkingDirectory, typeof(CSharpReplServiceProvider)) { }
public ActionResult <IEnumerable <string> > Get(string relativeUrl) { var hs = new HostServices(_settings.Tenant, _settings.Tenant, _serviceUrl, _settings.ApiKey); var filePath = _settings.Url + relativeUrl; try { var content = hs.GetContent(filePath); //TODO: consider caching content locally for speed return(File(content.Blob, GetContentType(content.Filename))); } catch (System.Exception ex) { if (ex.Message.Contains("authenticated")) { return(Unauthorized()); } return(NotFound()); } }
internal RoslynWorkspace(HostServices host, NuGetConfiguration nuGetConfiguration, CompositionHost compositionContext, string dotnetPath, string sdkPath) : base(host, WorkspaceKind.Host) { this.dotnetPath = dotnetPath; this.sdkPath = sdkPath; _nuGetConfiguration = nuGetConfiguration; _openDocumentTextLoaders = new Dictionary <DocumentId, AvalonEditTextContainer>(); _diagnosticsUpdatedNotifiers = new ConcurrentDictionary <DocumentId, Action <DiagnosticsUpdatedArgs> >(); _compositionContext = compositionContext; _buildNodes = new BlockingCollection <MSBuildHost>(Environment.ProcessorCount); DiagnosticProvider.Enable(this, DiagnosticProvider.Options.Semantic | DiagnosticProvider.Options.Syntax); //this.EnableDiagnostics(DiagnosticOptions.Semantic | DiagnosticOptions.Syntax); GetService <IDiagnosticService>().DiagnosticsUpdated += OnDiagnosticsUpdated; }
static MonoDevelopWorkspace() { List <Assembly> assemblies = new List <Assembly> (); foreach (var asmName in mefHostServices) { try { var asm = Assembly.Load(asmName); if (asm == null) { continue; } assemblies.Add(asm); } catch (Exception) { LoggingService.LogError("Error - can't load host service assembly: " + asmName); } } assemblies.Add(typeof(MonoDevelopWorkspace).Assembly); services = Microsoft.CodeAnalysis.Host.Mef.MefHostServices.Create(assemblies); }
public CSharpInteractiveEvaluator( HostServices hostServices, IViewClassifierAggregatorService classifierAggregator, IInteractiveWindowCommandsFactory commandsFactory, IInteractiveWindowCommand[] commands, IContentTypeRegistryService contentTypeRegistry, string responseFileDirectory, string initialWorkingDirectory) : base( contentTypeRegistry.GetContentType(ContentTypeNames.CSharpContentType), hostServices, classifierAggregator, commandsFactory, commands, (responseFileDirectory != null) ? Path.Combine(responseFileDirectory, InteractiveResponseFile) : null, initialWorkingDirectory, typeof(InteractiveHostEntryPoint).Assembly.Location, typeof(CSharpRepl)) { }
public void TestTranslationRemoteHostObjects() { var stateInHostObject = 3; var hostServices = new HostServices(); var rot = new MockRunningObjectTable(); hostServices.SetTestRunningObjectTable(rot); var moniker = nameof(TestTranslationRemoteHostObjects) + Guid.NewGuid(); var remoteHost = new MockRemoteHostObject(stateInHostObject); using (var result = rot.Register(moniker, remoteHost)) { hostServices.RegisterHostObject( "WithOutOfProc.targets", "DisplayMessages", "ATask", moniker); BuildRequest request = new BuildRequest( submissionId: 1, _nodeRequestId++, 1, new string[] { "alpha", "omega" }, hostServices: hostServices, BuildEventContext.Invalid, parentRequest: null); ((ITranslatable)request).Translate(TranslationHelpers.GetWriteTranslator()); INodePacket packet = BuildRequest.FactoryForDeserialization(TranslationHelpers.GetReadTranslator()); BuildRequest deserializedRequest = packet as BuildRequest; deserializedRequest.HostServices.SetTestRunningObjectTable(rot); var hostObject = deserializedRequest.HostServices.GetHostObject( "WithOutOfProc.targets", "DisplayMessages", "ATask") as ITestRemoteHostObject; hostObject.GetState().ShouldBe(stateInHostObject); } }