public static void Generate(PythonTypeDatabaseCreationRequest request) { var onExit = request.OnExit; GenerateAsync(request).ContinueWith(t => { var exc = t.Exception; if (exc == null) { return; } try { var message = string.Format( "ERROR_STDLIB: {0}\\{1}{2}", request.Factory.Configuration.Id, Environment.NewLine, (exc.InnerException ?? exc).ToString() ); Debug.WriteLine(message); var glogPath = Path.Combine(CompletionDatabasePath, "AnalysisLog.txt"); File.AppendAllText(glogPath, message); } catch (IOException) { } catch (ArgumentException) { } catch (SecurityException) { } catch (UnauthorizedAccessException) { } if (onExit != null) { onExit(PythonTypeDatabase.InvalidOperationExitCode); } }, TaskContinuationOptions.OnlyOnFaulted); }
public virtual void GenerateDatabase(GenerateDatabaseOptions options, Action <int> onExit = null) { var req = new PythonTypeDatabaseCreationRequest { Factory = this, OutputPath = DatabasePath, SkipUnchanged = options.HasFlag(GenerateDatabaseOptions.SkipUnchanged), DetectLibraryPath = !AssumeSimpleLibraryLayout }; GenerateDatabase(req, onExit); }
public override void GenerateDatabase(GenerateDatabaseOptions options, Action <int> onExit = null) { if (!Directory.Exists(Configuration.LibraryPath)) { return; } // Create and mark the DB directory as hidden try { var dbDir = Directory.CreateDirectory(DatabasePath); dbDir.Attributes |= FileAttributes.Hidden; } catch (ArgumentException) { } catch (IOException) { } catch (UnauthorizedAccessException) { } var req = new PythonTypeDatabaseCreationRequest { Factory = this, OutputPath = DatabasePath, SkipUnchanged = options.HasFlag(GenerateDatabaseOptions.SkipUnchanged), DetectLibraryPath = !AssumeSimpleLibraryLayout }; req.ExtraInputDatabases.Add(_base.DatabasePath); _baseHasRefreshed = false; if (_base.IsCurrent) { base.GenerateDatabase(req, onExit); } else { req.WaitFor = _base; req.SkipUnchanged = false; // Clear out the existing base database, since we're going to // need to reload it again. This also means that when // NewDatabaseAvailable is raised, we are expecting it and won't // incorrectly set _baseHasRefreshed to true again. _baseDb = null; // Start our analyzer first, since we will wait up to a minute // for our base analyzer to start (which may cause a one minute // delay if it completes before we start, but that is unlikely). base.GenerateDatabase(req, onExit); _base.GenerateDatabase(GenerateDatabaseOptions.SkipUnchanged); } }
public virtual void GenerateDatabase(GenerateDatabaseOptions options, Action <int> onExit = null) { if (string.IsNullOrEmpty(DatabasePath)) { onExit?.Invoke(PythonTypeDatabase.NotSupportedExitCode); return; } var req = new PythonTypeDatabaseCreationRequest { Factory = this, OutputPath = DatabasePath, SkipUnchanged = options.HasFlag(GenerateDatabaseOptions.SkipUnchanged) }; GenerateDatabase(req, onExit); }
protected virtual void GenerateDatabase(PythonTypeDatabaseCreationRequest request, Action <int> onExit = null) { WatchingLibrary = false; _generating = true; PythonTypeDatabase.GenerateAsync(request).ContinueWith(t => { int exitCode; try { exitCode = t.Result; } catch (Exception ex) { Debug.Fail(ex.ToString()); exitCode = PythonTypeDatabase.InvalidOperationExitCode; } if (exitCode != PythonTypeDatabase.AlreadyGeneratingExitCode) { _generating = false; } if (onExit != null) { onExit(exitCode); } }); }
protected virtual void GenerateDatabase(PythonTypeDatabaseCreationRequest request, Action <int> onExit = null) { // Use the NoPackageManager instance if we don't have a package // manager, so that we still get a valid disposable object while we // are generating. var generating = _generating = (request.Factory.PackageManager ?? NoPackageManager.Instance).SuppressNotifications(); PythonTypeDatabase.GenerateAsync(request).ContinueWith(t => { int exitCode; try { exitCode = t.Result; } catch (Exception ex) { Debug.Fail(ex.ToString()); exitCode = PythonTypeDatabase.InvalidOperationExitCode; } if (exitCode != PythonTypeDatabase.AlreadyGeneratingExitCode) { generating.Dispose(); Interlocked.CompareExchange(ref _generating, null, generating); } onExit?.Invoke(exitCode); }); }
public static void Generate(PythonTypeDatabaseCreationRequest request) { var onExit = request.OnExit; GenerateAsync(request).ContinueWith(t => { var exc = t.Exception; if (exc == null) { return; } try { var message = string.Format( "ERROR_STDLIB: {0}\\{1}{2}{3}", request.Factory.Id, request.Factory.Configuration.Version, Environment.NewLine, (exc.InnerException ?? exc).ToString() ); Debug.WriteLine(message); var glogPath = Path.Combine(CompletionDatabasePath, "AnalysisLog.txt"); File.AppendAllText(glogPath, message); } catch (IOException) { } catch (ArgumentException) { } catch (SecurityException) { } catch (UnauthorizedAccessException) { } if (onExit != null) { onExit(PythonTypeDatabase.InvalidOperationExitCode); } }, TaskContinuationOptions.OnlyOnFaulted); }
public static async Task<int> GenerateAsync(PythonTypeDatabaseCreationRequest request) { var fact = request.Factory; var evt = request.OnExit; if (fact == null || !Directory.Exists(fact.Configuration.LibraryPath)) { if (evt != null) { evt(NotSupportedExitCode); } return NotSupportedExitCode; } var outPath = request.OutputPath; var analyzerPath = PythonToolsInstallPath.GetFile("Microsoft.PythonTools.Analyzer.exe"); Directory.CreateDirectory(CompletionDatabasePath); var baseDb = BaselineDatabasePath; if (request.ExtraInputDatabases.Any()) { baseDb = baseDb + ";" + string.Join(";", request.ExtraInputDatabases); } var logPath = Path.Combine(outPath, "AnalysisLog.txt"); var glogPath = Path.Combine(CompletionDatabasePath, "AnalysisLog.txt"); using (var output = ProcessOutput.RunHiddenAndCapture( analyzerPath, "/id", fact.Id.ToString("B"), "/version", fact.Configuration.Version.ToString(), "/python", fact.Configuration.InterpreterPath, request.DetectLibraryPath ? null : "/library", request.DetectLibraryPath ? null : fact.Configuration.LibraryPath, "/outdir", outPath, "/basedb", baseDb, (request.SkipUnchanged ? null : "/all"), // null will be filtered out; empty strings are quoted "/log", logPath, "/glog", glogPath, "/wait", (request.WaitFor != null ? AnalyzerStatusUpdater.GetIdentifier(request.WaitFor) : "") )) { output.PriorityClass = ProcessPriorityClass.BelowNormal; int exitCode = await output; if (exitCode > -10 && exitCode < 0) { try { File.AppendAllLines( glogPath, new[] { string.Format("FAIL_STDLIB: ({0}) {1}", exitCode, output.Arguments) } .Concat(output.StandardErrorLines) ); } catch (IOException) { } catch (ArgumentException) { } catch (SecurityException) { } catch (UnauthorizedAccessException) { } } if (evt != null) { evt(exitCode); } return exitCode; } }
public static async Task <int> GenerateAsync(PythonTypeDatabaseCreationRequest request) { var fact = request.Factory; var evt = request.OnExit; if (fact == null || !Directory.Exists(fact.Configuration.LibraryPath)) { if (evt != null) { evt(NotSupportedExitCode); } return(NotSupportedExitCode); } var outPath = request.OutputPath; var analyzerPath = PythonToolsInstallPath.GetFile("Microsoft.PythonTools.Analyzer.exe"); Directory.CreateDirectory(CompletionDatabasePath); var baseDb = BaselineDatabasePath; if (request.ExtraInputDatabases.Any()) { baseDb = baseDb + ";" + string.Join(";", request.ExtraInputDatabases); } var logPath = Path.Combine(outPath, "AnalysisLog.txt"); var glogPath = Path.Combine(CompletionDatabasePath, "AnalysisLog.txt"); using (var output = ProcessOutput.RunHiddenAndCapture( analyzerPath, "/id", fact.Configuration.Id, "/version", fact.Configuration.Version.ToString(), "/python", fact.Configuration.InterpreterPath, request.DetectLibraryPath ? null : "/library", request.DetectLibraryPath ? null : fact.Configuration.LibraryPath, "/outdir", outPath, "/basedb", baseDb, (request.SkipUnchanged ? null : "/all"), // null will be filtered out; empty strings are quoted "/log", logPath, "/glog", glogPath, "/wait", (request.WaitFor != null ? AnalyzerStatusUpdater.GetIdentifier(request.WaitFor) : "") )) { output.PriorityClass = ProcessPriorityClass.BelowNormal; int exitCode = await output; if (exitCode > -10 && exitCode < 0) { try { File.AppendAllLines( glogPath, new[] { string.Format("FAIL_STDLIB: ({0}) {1}", exitCode, output.Arguments) } .Concat(output.StandardErrorLines) ); } catch (IOException) { } catch (ArgumentException) { } catch (SecurityException) { } catch (UnauthorizedAccessException) { } } if (evt != null) { evt(exitCode); } return(exitCode); } }
protected virtual void GenerateDatabase(PythonTypeDatabaseCreationRequest request, Action<int> onExit = null) { WatchingLibrary = false; _generating = true; PythonTypeDatabase.GenerateAsync(request).ContinueWith(t => { int exitCode; try { exitCode = t.Result; } catch (Exception ex) { Debug.Fail(ex.ToString()); exitCode = PythonTypeDatabase.InvalidOperationExitCode; } if (exitCode != PythonTypeDatabase.AlreadyGeneratingExitCode) { _generating = false; } if (onExit != null) { onExit(exitCode); } }); }
public virtual void GenerateDatabase(GenerateDatabaseOptions options, Action<int> onExit = null) { var req = new PythonTypeDatabaseCreationRequest { Factory = this, OutputPath = DatabasePath, SkipUnchanged = options.HasFlag(GenerateDatabaseOptions.SkipUnchanged), DetectLibraryPath = !AssumeSimpleLibraryLayout }; GenerateDatabase(req, onExit); }
public void CheckObsoleteGenerateFunction() { var path = PythonPaths.Versions.LastOrDefault(p => p != null && p.IsCPython); path.AssertInstalled(); var factory = InterpreterFactoryCreator.CreateInterpreterFactory(new InterpreterFactoryCreationOptions { Id = path.Id, LanguageVersion = path.Version.ToVersion(), Description = "Test Interpreter", Architecture = path.Isx64 ? ProcessorArchitecture.Amd64 : ProcessorArchitecture.X86, LibraryPath = path.LibPath, PrefixPath = path.PrefixPath, InterpreterPath = path.InterpreterPath, WatchLibraryForNewModules = false }); var tcs = new TaskCompletionSource<int>(); var beforeProc = Process.GetProcessesByName("Microsoft.PythonTools.Analyzer"); var request = new PythonTypeDatabaseCreationRequest { Factory = factory, OutputPath = TestData.GetTempPath(randomSubPath: true), SkipUnchanged = true, OnExit = tcs.SetResult }; Console.WriteLine("OutputPath: {0}", request.OutputPath); #pragma warning disable 618 PythonTypeDatabase.Generate(request); #pragma warning restore 618 int expected = 0; if (!tcs.Task.Wait(TimeSpan.FromMinutes(1.0))) { var proc = Process.GetProcessesByName("Microsoft.PythonTools.Analyzer") .Except(beforeProc) .ToArray(); // Ensure we actually started running Assert.AreNotEqual(0, proc.Length, "Process is not running"); expected = -1; // Kill the process foreach (var p in proc) { Console.WriteLine("Killing process {0}", p.Id); p.Kill(); } Assert.IsTrue(tcs.Task.Wait(TimeSpan.FromMinutes(1.0)), "Process did not die"); } Assert.AreEqual(expected, tcs.Task.Result, "Incorrect exit code"); }
public override void GenerateDatabase(GenerateDatabaseOptions options, Action<int> onExit = null) { if (!Directory.Exists(Configuration.LibraryPath)) { return; } // Create and mark the DB directory as hidden try { var dbDir = Directory.CreateDirectory(DatabasePath); dbDir.Attributes |= FileAttributes.Hidden; } catch (ArgumentException) { } catch (IOException) { } catch (UnauthorizedAccessException) { } var req = new PythonTypeDatabaseCreationRequest { Factory = this, OutputPath = DatabasePath, SkipUnchanged = options.HasFlag(GenerateDatabaseOptions.SkipUnchanged), DetectLibraryPath = !AssumeSimpleLibraryLayout }; req.ExtraInputDatabases.Add(_base.DatabasePath); _baseHasRefreshed = false; if (_base.IsCurrent) { base.GenerateDatabase(req, onExit); } else { req.WaitFor = _base; req.SkipUnchanged = false; // Clear out the existing base database, since we're going to // need to reload it again. This also means that when // NewDatabaseAvailable is raised, we are expecting it and won't // incorrectly set _baseHasRefreshed to true again. _baseDb = null; // Start our analyzer first, since we will wait up to a minute // for our base analyzer to start (which may cause a one minute // delay if it completes before we start, but that is unlikely). base.GenerateDatabase(req, onExit); _base.GenerateDatabase(GenerateDatabaseOptions.SkipUnchanged); } }
/// <summary> /// Regenerates the database for this environment. If the base /// interpreter needs regenerating, it will also be regenerated. /// </summary> public override void GenerateDatabase(GenerateDatabaseOptions options, Action<int> onExit = null) { if (!Directory.Exists(Configuration.LibraryPath)) { return; } var req = new PythonTypeDatabaseCreationRequest { Factory = this, OutputPath = DatabasePath, SkipUnchanged = options.HasFlag(GenerateDatabaseOptions.SkipUnchanged) }; req.ExtraInputDatabases.Add(_base.DatabasePath); _baseHasRefreshed = false; if (_base.IsCurrent) { // The App database is already up to date, so start analyzing // the User database immediately. base.GenerateDatabase(req, onExit); } else { // The App database needs to be updated, so start both and wait // for the base to finish before analyzing User. // Specifying our base interpreter as 'WaitFor' allows the UI to // forward progress and status messages to the user, even though // the factory is not visible. req.WaitFor = _base; // Because the underlying analysis of the standard library has // changed, we must reanalyze the entire database. req.SkipUnchanged = false; // Clear out the existing base database, since we're going to // need to reload it again. This also means that when // NewDatabaseAvailable is raised, we are expecting it and won't // incorrectly set _baseHasRefreshed to true again. _baseDb = null; // Start our analyzer first, since we will wait up to a minute // for the base analyzer to start (which may cause a one minute // delay if it completes before we start, but that is unlikely). base.GenerateDatabase(req, onExit); _base.GenerateDatabase(GenerateDatabaseOptions.SkipUnchanged); } }