public void CreateRequestToUnity([NotNull] IDeclaredElement declaredElement, IPsiSourceFile selectedSourceFile, string selectAnchor, bool focusUnity) { var finder = mySolution.GetPsiServices().AsyncFinder; var consumer = new UnityUsagesFinderConsumer(myUnitySceneDataLocalCache, mySolutionDirectoryPath); var selectRequest = (selectedSourceFile == null || selectAnchor == null) ? null : CreateRequest(mySolutionDirectoryPath, myUnitySceneDataLocalCache, selectAnchor, selectedSourceFile, false); var lifetimeDef = myLifetime.CreateNested(); var pi = new ProgressIndicator(myLifetime); if (myBackgroundTaskHost != null) { var task = RiderBackgroundTaskBuilder.Create() .WithTitle("Finding usages in Unity for: " + declaredElement.ShortName) .AsIndeterminate() .AsCancelable(() => { pi.Cancel(); }) .Build(); myBackgroundTaskHost.AddNewTask(lifetimeDef.Lifetime, task); } myLocks.Tasks.StartNew(myLifetime, Scheduling.MainGuard, () => { using (ReadLockCookie.Create()) { finder.FindAsync(new[] { declaredElement }, myYamlSearchDomain, consumer, SearchPattern.FIND_USAGES, pi, FinderSearchRoot.Empty, new UnityUsagesAsyncFinderCallback(lifetimeDef, myLifetime, consumer, myUnityHost, myEditorProtocol, myLocks, declaredElement.ShortName, selectRequest, focusUnity)); } }); }
private void RememberExecution([NotNull] FileSystemPath path, bool withProgress) { var definition = Lifetime.CreateNested(); if (withProgress) { var progress = new ProgressIndicator(definition.Lifetime); IProgressIndicator iProgress = progress; iProgress.Start(1); progress.Advance(); var task = RiderBackgroundTaskBuilder .FromProgressIndicator(progress) .AsIndeterminate() .WithHeader("Executing template") .WithDescription($"{path.Name}") .Build(); Solution.Locks.ExecuteOrQueueEx( definition.Lifetime, "T4 execution progress launching", () => BackgroundTaskHost.AddNewTask(definition.Lifetime, task) ); } RunningFiles[path] = definition; }
private async Task RefreshInternal(Lifetime lifetime, RefreshType refreshType) { var lifetimeDef = Lifetime.Define(lifetime); myLogger.Verbose($"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Started"); mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime, RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...") .AsIndeterminate().AsNonCancelable()); try { try { var version = UnityVersion.Parse(myEditorProtocol.UnityModel.Value.UnityApplicationData.Value.ApplicationVersion); if (version != null && version.Major < 2018) { using (mySolution.GetComponent <VfsListener>().PauseChanges()) { await myEditorProtocol.UnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask(); } } else // it is a risk to pause vfs https://github.com/JetBrains/resharper-unity/issues/1601 { await myEditorProtocol.UnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask(); } } catch (Exception e) { myLogger.Warn("connection usually brakes during refresh.", e); } finally { try { myLogger.Verbose( $"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Finished"); var solution = mySolution.GetProtocolSolution(); var solFolder = mySolution.SolutionDirectory; var list = new List <string> { solFolder.FullPath }; myLogger.Verbose($"RefreshPaths.StartAsTask Finished."); await solution.GetFileSystemModel().RefreshPaths.Start(lifetimeDef.Lifetime, new RdRefreshRequest(list, true)).AsTask(); } finally { myLogger.Verbose($"RefreshPaths.StartAsTask Finished."); lifetimeDef.Terminate(); } } } catch (Exception e) { myLogger.LogException(e); } finally { lifetimeDef.Terminate(); } }
public void HandleManualInstallPlugin(InstallPluginDescription installPluginDescription) { var unrealPluginInstallInfo = myPluginDetector.InstallInfoProperty.Value; if (unrealPluginInstallInfo == null) { return; } Lifetime.UsingNestedAsync(async lt => { var lifetimeDefinition = lt.CreateNested(); var lifetime = lifetimeDefinition.Lifetime; lifetime.Bracket( () => myUnrealHost.myModel.RiderLinkInstallationInProgress.Value = true, () => myUnrealHost.myModel.RiderLinkInstallationInProgress.Value = false ); var prefix = unrealPluginInstallInfo.EnginePlugin.IsPluginAvailable ? "Updating" : "Installing"; var header = $"{prefix} RiderLink plugin"; var progress = new Property <double>("UnrealLink.InstallPluginProgress", 0.0); var task = RiderBackgroundTaskBuilder.Create() .AsCancelable(() => { myUnrealHost.myModel.RiderLinkInstallMessage( new InstallMessage("RiderLink installation has been cancelled", ContentType.Error)); lifetimeDefinition.Terminate(); }) .WithHeader(header) .WithProgress(progress) .WithDescriptionFromProgress(); myBackgroundTaskHost.AddNewTask(lifetime, task); myUnrealHost.myModel.CancelRiderLinkInstall.AdviseOnce(lifetime, unit => { myUnrealHost.myModel.RiderLinkInstallMessage( new InstallMessage("RiderLink installation has been cancelled", ContentType.Error)); lifetimeDefinition.Terminate(); }); myUnrealHost.myModel.RiderLinkInstallPanelInit(); await lifetime.StartBackgroundAsync(async() => { if (installPluginDescription.Location == PluginInstallLocation.Engine) { await InstallPluginInEngineIfRequired(lifetime, unrealPluginInstallInfo, progress, installPluginDescription.ForceInstall); } else { await InstallPluginInGameIfRequired(lifetime, unrealPluginInstallInfo, progress, installPluginDescription.ForceInstall); } }); }); }
public void Refresh(bool force) { myLocks.AssertMainThread(); if (IsRefreshing) { return; } if (myPluginProtocolController.UnityModel.Value == null) { return; } if (!myBoundSettingsStore.GetValue((UnitySettings s) => s.AllowAutomaticRefreshInUnity) && !force) { return; } IsRefreshing = true; var result = myPluginProtocolController.UnityModel.Value.Refresh.Start(force)?.Result; if (result == null) { IsRefreshing = false; return; } var lifetimeDef = Lifetimes.Define(myLifetime); var solution = mySolution.GetProtocolSolution(); var solFolder = mySolution.SolutionFilePath.Directory; mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime, RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...").AsIndeterminate().AsNonCancelable()); result.Advise(lifetimeDef.Lifetime, _ => { try { var list = new List <string> { solFolder.FullPath }; solution.GetFileSystemModel().RefreshPaths.Start(new RdRefreshRequest(list, true)); } finally { IsRefreshing = false; lifetimeDef.Terminate(); } }); }
public Task Refresh(bool force) { myLocks.AssertMainThread(); if (CurrentTask != null) { return(CurrentTask); } if (myEditorProtocol.UnityModel.Value == null) { return(new Task(() => {})); } if (!myBoundSettingsStore.GetValue((UnitySettings s) => s.AllowAutomaticRefreshInUnity) && !force) { return(new Task(() => {})); } myLogger.Verbose($"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {force}"); var task = myEditorProtocol.UnityModel.Value.Refresh.StartAsTask(force); CurrentTask = task; var lifetimeDef = Lifetimes.Define(myLifetime); var solution = mySolution.GetProtocolSolution(); var solFolder = mySolution.SolutionFilePath.Directory; mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime, RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...").AsIndeterminate().AsNonCancelable()); task.ContinueWith(_ => { mySolution.Locks.ExecuteOrQueueEx(lifetimeDef.Lifetime, "RefreshPaths", () => { try { var list = new List <string> { solFolder.FullPath }; solution.GetFileSystemModel().RefreshPaths.Start(new RdRefreshRequest(list, true)); } finally { CurrentTask = null; lifetimeDef.Terminate(); } }); }); return(task); }
public void CreateRequestToUnity([NotNull] IDeclaredElement declaredElement, LocalReference location, bool focusUnity) { var finder = mySolution.GetPsiServices().AsyncFinder; var consumer = new UnityUsagesFinderConsumer(myAssetHierarchyProcessor, myAnimatorContainer, myPersistentIndexManager, mySolutionDirectoryPath, declaredElement); var sourceFile = myPersistentIndexManager[location.OwningPsiPersistentIndex]; if (sourceFile == null) { return; } var selectRequest = CreateRequest(mySolutionDirectoryPath, myAssetHierarchyProcessor, myAnimatorContainer, location, sourceFile, declaredElement, false); var lifetimeDef = myLifetime.CreateNested(); var pi = new ProgressIndicator(myLifetime); if (myBackgroundTaskHost != null) { var task = RiderBackgroundTaskBuilder.Create() .WithTitle("Finding usages in Unity for: " + declaredElement.ShortName) .AsIndeterminate() .AsCancelable(() => { pi.Cancel(); }) .Build(); myBackgroundTaskHost.AddNewTask(lifetimeDef.Lifetime, task); } myLocks.Tasks.StartNew(myLifetime, Scheduling.MainGuard, () => { using (ReadLockCookie.Create()) { finder.FindAsync(new[] { declaredElement }, myYamlSearchDomain, consumer, SearchPattern.FIND_USAGES, pi, FinderSearchRoot.Empty, new UnityUsagesAsyncFinderCallback(lifetimeDef, myLifetime, consumer, myFrontendBackendHost, myBackendUnityHost, myLocks, declaredElement.ShortName, selectRequest, focusUnity)); } }); }
public void Refresh() { myLocks.AssertMainThread(); if (IsRefreshing) { return; } IsRefreshing = true; var result = myPluginProtocolController.UnityModel?.Refresh.Start(RdVoid.Instance)?.Result; if (result == null) { IsRefreshing = false; return; } var lifetimeDef = Lifetimes.Define(myLifetime); var solution = mySolution.GetProtocolSolution(); var solFolder = mySolution.SolutionFilePath.Directory; mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime, RiderBackgroundTaskBuilder.Create().WithHeader("Refresh").AsIndeterminate().AsNonCancelable()); result.Advise(lifetimeDef.Lifetime, _ => { try { var list = new List <string> { solFolder.FullPath }; solution.FileSystemModel.RefreshPaths.Start(new RdRefreshRequest(list, true)); } finally { IsRefreshing = false; lifetimeDef.Terminate(); } }); }
private async Task RefreshInternal(RefreshType force) { var lifetimeDef = Lifetime.Define(myLifetime); myLogger.Verbose( $"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {force} Started"); try { using (mySolution.GetComponent <VfsListener>().PauseChanges()) { await myEditorProtocol.UnityModel.Value.Refresh.StartAsTask(force); } myLogger.Verbose( $"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {force} Finished"); var solution = mySolution.GetProtocolSolution(); var solFolder = mySolution.SolutionDirectory; mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime, RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...") .AsIndeterminate().AsNonCancelable()); var list = new List <string> { solFolder.FullPath }; myLogger.Verbose($"RefreshPaths.StartAsTask Started."); await solution.GetFileSystemModel().RefreshPaths.StartAsTask(new RdRefreshRequest(list, true)); myLogger.Verbose($"RefreshPaths.StartAsTask Finished."); myLogger.Verbose($"lifetimeDef.Terminate"); lifetimeDef.Terminate(); } catch (Exception e) { myLogger.Log(LoggingLevel.ERROR, "Exception during Refresh.", e); } }
public static void RefreshProjects(Lifetime parentLifetime, [NotNull] ISolution solution, [CanBeNull] UnrealPluginInstallInfo.InstallDescription installDescription, [CanBeNull] VirtualFileSystemPath engineRoot) { parentLifetime.UsingNestedAsync(async lt => { var lifetimeDefinition = lt.CreateNested(); var lifetime = lifetimeDefinition.Lifetime; var unrealHost = solution.GetComponent <UnrealHost>(); lifetime.Bracket( () => unrealHost.myModel.RefreshInProgress.Value = true, () => unrealHost.myModel.RefreshInProgress.Value = false ); var task = RiderBackgroundTaskBuilder.Create() .AsCancelable(() => { unrealHost.myModel.RiderLinkInstallMessage( new InstallMessage("RiderLink projects refresh has been cancelled", ContentType.Error)); lifetimeDefinition.Terminate(); }) .WithHeader("Refreshing project model"); var backgroundTaskHost = solution.GetComponent <RiderBackgroundTaskHost>(); backgroundTaskHost.AddNewTask(lifetime, task); var uprojectFile = installDescription?.UprojectPath; if (uprojectFile.IsNullOrEmpty()) { var cppUe4SolutionDetector = solution.GetComponent <CppUE4SolutionDetector>(); using (solution.Locks.UsingReadLock()) { uprojectFile = cppUe4SolutionDetector.GetUProjectPath(); } } await lifetime.StartBackground(() => RegenerateProjectFiles(lifetime, solution, unrealHost, engineRoot, uprojectFile)); }); }
public override void Start(Lifetime startLifetime) { if (myRiderBackgroundTaskHost != null) { // avoid problems with background task host after terminating lifetime on daemon thread var lifetimeDef = myLifetime.CreateNested(); startLifetime.OnTermination(() => { myLocks.Tasks.StartNew(myLifetime, Scheduling.MainDispatcher, () => lifetimeDef.Terminate()); }); var count = myCache.FilesToProcess.Count; var processedCount = 0; var progress = new Property <double>(startLifetime, "DeferredCacheProgressBarProgress", 0); myCache.AfterRemoveFromProcess.Advise(startLifetime, _ => { processedCount++; if (count != 0) { progress.Value = Math.Min(0.99, ((double)processedCount) / count); } }); var description = new Property <string>(startLifetime, "DeferredCacheProgressBarDescription", "Processing assets"); var task = RiderBackgroundTaskBuilder.Create() .WithTitle("Calculating asset index") .WithDescription(description) .WithProgress(progress) .Build(); CurrentFile.AdviseNotNull(startLifetime, v => { description.Value = $"Processing {v.DisplayName}"; }); myLocks.Tasks.StartNew(startLifetime, Scheduling.MainDispatcher, () => { myRiderBackgroundTaskHost.AddNewTask(lifetimeDef.Lifetime, task); }); } }
private async Task RefreshInternal(Lifetime lifetime, RefreshType refreshType) { myLocks.ReentrancyGuard.AssertGuarded(); if (myBackendUnityHost.BackendUnityModel.Value == null) { return; } if (!myBackendUnityHost.IsConnectionEstablished()) { return; } var lifetimeDef = Lifetime.Define(lifetime); try { myLogger.Verbose($"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Started"); mySolution.GetComponent <RiderBackgroundTaskHost>().AddNewTask(lifetimeDef.Lifetime, RiderBackgroundTaskBuilder.Create().WithHeader("Refreshing solution in Unity Editor...") .AsIndeterminate().AsNonCancelable()); var version = myUnityVersion.ActualVersionForSolution.Value; try { if (version != null && version.Major < 2018) { using (mySolution.GetComponent <VfsListener>().PauseChanges()) { try { await myBackendUnityHost.BackendUnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask(); } finally { await myLocks.Tasks.YieldTo(myLifetime, Scheduling.MainGuard); } } } else // it is a risk to pause vfs https://github.com/JetBrains/resharper-unity/issues/1601 { await myBackendUnityHost.BackendUnityModel.Value.Refresh.Start(lifetimeDef.Lifetime, refreshType).AsTask(); } } catch (Exception e) { myLogger.Warn(e, comment: "connection usually brakes during refresh."); } finally { await myLocks.Tasks.YieldTo(myLifetime, Scheduling.MainGuard); myLogger.Verbose( $"myPluginProtocolController.UnityModel.Value.Refresh.StartAsTask, force = {refreshType} Finished"); var solution = mySolution.GetProtocolSolution(); var solFolder = mySolution.SolutionDirectory; var list = new List <string> { solFolder.FullPath }; myLogger.Verbose("RefreshPaths.StartAsTask Finished."); await solution.GetFileSystemModel().RefreshPaths .Start(lifetimeDef.Lifetime, new RdRefreshRequest(list, true)).AsTask(); await myLocks.Tasks.YieldTo(myLifetime, Scheduling.MainGuard); } } catch (Exception e) { myLogger.LogException(e); } finally { lifetimeDef.Terminate(); } }