private void GetFullUrl(LaunchConfiguration config, out Uri uri, out int port) { int p; if (!int.TryParse(config.GetLaunchOption(PythonConstants.WebBrowserPortSetting) ?? "", out p)) { p = TestServerPort; } port = p; var host = config.GetLaunchOption(PythonConstants.WebBrowserUrlSetting); if (string.IsNullOrEmpty(host)) { uri = null; return; } try { uri = GetFullUrl(host, p); } catch (UriFormatException) { var output = OutputWindowRedirector.GetGeneral(_serviceProvider); output.WriteErrorLine(Strings.ErrorInvalidLaunchUrl.FormatUI(host)); output.ShowAndActivate(); uri = null; } }
public override void AddToLaunchConfiguration(LaunchConfiguration configuration) { base.AddToLaunchConfiguration(configuration); var command = this.Config.Commands.AddCommand <Command>("CreateWindowsShare"); const string CreateWindowsShare = "c:/cfn/scripts/CreateWindowsShare.ps1"; var script = this.Config.Files.GetFile(CreateWindowsShare); script.Source = "https://s3.amazonaws.com/gtbb/CreateWindowsShare.ps1"; command.Command = new FnJoinPowershellCommand(FnJoinDelimiter.Space, CreateWindowsShare, this.Path, this.ShareName, "@(", new FnJoin(FnJoinDelimiter.Comma, this.Accounts), ")"); SecurityGroup securityGroupSmbAccess = new SecurityGroup("Security Group For SMB Access", configuration.Subnet.Vpc); securityGroupSmbAccess.AddIngress(PredefinedCidr.AllVpcs, Protocol.Tcp, Ports.Smb); securityGroupSmbAccess.AddIngress(PredefinedCidr.AllVpcs, Protocol.Tcp, Ports.NetBt, Ports.NetBiosNameServices); configuration.Template.Resources.Add(securityGroupSmbAccess.LogicalId, securityGroupSmbAccess); Instance launchConfigurationAsInstance = configuration as Instance; launchConfigurationAsInstance.SecurityGroupIds.Add(new ReferenceProperty(securityGroupSmbAccess)); }
/// <inheritdoc/> public Task SetLaunchConfigurationAsync(ScalingGroupId groupId, LaunchConfiguration configuration, CancellationToken cancellationToken) { if (groupId == null) { throw new ArgumentNullException("groupId"); } if (configuration == null) { throw new ArgumentNullException("configuration"); } UriTemplate template = new UriTemplate("/groups/{groupId}/launch"); var parameters = new Dictionary <string, string> { { "groupId", groupId.Value } }; Func <Task <Tuple <IdentityToken, Uri> >, Task <HttpWebRequest> > prepareRequest = PrepareRequestAsyncFunc(HttpMethod.PUT, template, parameters, configuration); Func <Task <HttpWebRequest>, Task <string> > requestResource = GetResponseAsyncFunc(cancellationToken); return(AuthenticateServiceAsync(cancellationToken) .Then(prepareRequest) .Then(requestResource)); }
public void LaunchWebBrowserUriTests() { var testCases = new[] { new { Url = "/fob", Port = 1, Expected = "http://localhost:1/fob" }, new { Url = "http://localhost:9999/fob", Port = 9999, Expected = "http://localhost:9999/fob" }, new { Url = "http://localhost/fob", Port = 9999, Expected = "http://localhost:9999/fob" }, new { Url = "fob", Port = 9999, Expected = "http://localhost:9999/fob" }, new { Url = "/hello/world", Port = 367, Expected = "http://localhost:367/hello/world" }, new { Url = "/fob", Port = -1, Expected = "http://localhost:{port}/fob" }, }; foreach (var testCase in testCases) { Console.WriteLine("{0} {1} == {2}", testCase.Url, testCase.Port, testCase.Expected); Uri url; int port; var config = new LaunchConfiguration(null, new Dictionary <string, string> { { PythonConstants.WebBrowserUrlSetting, testCase.Url } }); if (testCase.Port >= 0) { config.LaunchOptions[PythonConstants.WebBrowserPortSetting] = testCase.Port.ToString(); } PythonWebLauncher.GetFullUrl(null, config, out url, out port); Assert.AreEqual( testCase.Expected.Replace("{port}", port.ToString()), url.AbsoluteUri ); } }
private static void ProfileStandaloneTarget(SessionNode session, StandaloneTarget runTarget, bool openReport) { LaunchConfiguration config; if (runTarget.PythonInterpreter != null) { var registry = session._serviceProvider.GetComponentModel().GetService <IInterpreterRegistryService>(); var interpreter = registry.FindConfiguration(runTarget.PythonInterpreter.Id); if (interpreter == null) { return; } config = new LaunchConfiguration(interpreter); } else { config = new LaunchConfiguration(null); } config.InterpreterPath = runTarget.InterpreterPath; config.ScriptName = runTarget.Script; config.ScriptArguments = runTarget.Arguments; config.WorkingDirectory = runTarget.WorkingDirectory; RunProfiler(session, config, openReport); }
internal static string DoSubstitutions(LaunchConfiguration original, IPythonProject project, string str) { if (string.IsNullOrEmpty(str)) { return(str); } return(SubstitutionPattern.Replace( str, m => { switch (m.Groups[1].Value.ToLowerInvariant()) { case "startupfile": return original.ScriptName; case "startupmodule": try { return ModulePath.FromFullPath(original.ScriptName, project.ProjectHome).ModuleName; } catch (ArgumentException) { } break; } return m.Value; } )); }
private void StartInterpreter_Executed(object sender, ExecutedRoutedEventArgs e) { try { var view = (EnvironmentView)e.Parameter; var config = new LaunchConfiguration(view.Factory.Configuration) { PreferWindowedInterpreter = (e.Command == EnvironmentPathsExtension.StartWindowsInterpreter), WorkingDirectory = view.Factory.Configuration.GetPrefixPath(), SearchPaths = new List <string>() }; var sln = (IVsSolution)_site.GetService(typeof(SVsSolution)); foreach (var pyProj in sln.EnumerateLoadedPythonProjects()) { if (pyProj.InterpreterConfigurations.Contains(config.Interpreter)) { config.SearchPaths.AddRange(pyProj.GetSearchPaths()); } } config.LaunchOptions[PythonConstants.NeverPauseOnExit] = "true"; Process.Start(Debugger.DebugLaunchHelper.CreateProcessStartInfo(_site, config))?.Dispose(); } catch (Exception ex) when(!ex.IsCriticalException()) { TaskDialog.ForException(_site, ex, Strings.ErrorStartingInterpreter, Strings.IssueTrackerUrl).ShowModal(); return; } }
private void StartInterpreter_Executed(object sender, ExecutedRoutedEventArgs e) { var view = (EnvironmentView)e.Parameter; var config = new LaunchConfiguration(view.Factory.Configuration) { PreferWindowedInterpreter = (e.Command == EnvironmentPathsExtension.StartWindowsInterpreter), WorkingDirectory = view.Factory.Configuration.PrefixPath, SearchPaths = new List <string>() }; var sln = (IVsSolution)_site.GetService(typeof(SVsSolution)); foreach (var pyProj in sln.EnumerateLoadedPythonProjects()) { if (pyProj.InterpreterConfigurations.Contains(config.Interpreter)) { config.SearchPaths.AddRange(pyProj.GetSearchPaths()); } } config.LaunchOptions[PythonConstants.NeverPauseOnExit] = "true"; Process.Start(Debugger.DebugLaunchHelper.CreateProcessStartInfo(_site, config)).Dispose(); }
private void configComboBox_SelectedIndexChanged(object sender, EventArgs e) { // Sélection d'une autre configuration dans la liste : mise à jour des paramètres int selectedConfig = configComboBox.SelectedIndex; if (selectedConfig != -1) { if (selectedConfig == 0) { // Ajout de config _InitializeLaunchFormContents(null); } else { // Récupération de la configuration selectedConfig -= 1; LaunchConfiguration currentConfig = _TemporaryConfigList[selectedConfig]; if (currentConfig != null) { _InitializeLaunchFormContents(currentConfig); } } } }
public override void AddToLaunchConfiguration(LaunchConfiguration configuration) { base.AddToLaunchConfiguration(configuration); FileInfo iso = new FileInfo("c:/cfn/files/en_sql_server_2014_standard_edition_with_service_pack_1_x64_dvd_6669998.iso"); this.Config.Files.GetFile(iso.FullName).Source = $"https://s3.amazonaws.com/{this.BucketName}/software/{iso.Name}"; }
public override void AddToLaunchConfiguration(LaunchConfiguration configuration) { base.AddToLaunchConfiguration(configuration); var command = this.Config.Commands.AddCommand <Command>("dir2"); command.Command = "dir>dir2.txt"; }
public Dictionary <string, string> GetFullEnvironment(LaunchConfiguration config) { // Start with global environment, add configured environment, // then add search paths. var baseEnv = Environment.GetEnvironmentVariables(); // Clear search paths from the global environment. The launch // configuration should include the existing value baseEnv[config.Interpreter.PathEnvironmentVariable] = string.Empty; var env = PathUtils.MergeEnvironments( baseEnv.AsEnumerable <string, string>(), config.GetEnvironmentVariables(), "Path", config.Interpreter.PathEnvironmentVariable ); if (config.SearchPaths != null && config.SearchPaths.Any()) { env = PathUtils.MergeEnvironments( env, new[] { new KeyValuePair <string, string>( config.Interpreter.PathEnvironmentVariable, PathUtils.JoinPathList(config.SearchPaths) ) }, config.Interpreter.PathEnvironmentVariable ); } return(env); }
internal static void GetFullUrl(IServiceProvider provider, LaunchConfiguration config, out Uri uri, out int port) { int p; if (int.TryParse(config.GetLaunchOption(PythonConstants.WebBrowserPortSetting) ?? "", out p)) { port = p; } else { SocketUtils.GetRandomPortListener(IPAddress.Loopback, out port).Stop(); p = -1; } var host = config.GetLaunchOption(PythonConstants.WebBrowserUrlSetting); if (string.IsNullOrEmpty(host)) { uri = null; return; } try { UriBuilder builder; if (Uri.TryCreate(host, UriKind.Absolute, out uri)) { builder = new UriBuilder(uri); } else { builder = new UriBuilder(); builder.Scheme = Uri.UriSchemeHttp; builder.Host = "localhost"; builder.Path = host; } if (p >= 0) { builder.Port = p; } else if (builder.Port < 0 || (builder.Uri.IsDefaultPort && !host.Contains(":{0}".FormatInvariant(builder.Port)))) { SocketUtils.GetRandomPortListener(IPAddress.Loopback, out port).Stop(); builder.Port = port; } uri = builder.Uri; port = uri.Port; } catch (UriFormatException) { if (provider == null) { throw; } var output = OutputWindowRedirector.GetGeneral(provider); output.WriteErrorLine(Strings.ErrorInvalidLaunchUrl.FormatUI(host)); output.ShowAndActivate(); uri = null; } }
internal LaunchConfigurationViewModel(EngineLauncherViewModel launcher, LaunchConfiguration config) { this.config = config; this.DeleteCommand = new UiCommand( () => launcher.DeleteConfig(this), () => this.IsUserPath); }
public TeamFoundationServerBuildServerBase(TeamFoundationServerEdition edition, LaunchConfiguration applicationServer, string bucketName, string recipeName, DbInstance sqlServer4Build) : base(edition, bucketName, recipeName) { this.ApplicationServer = applicationServer; this.SqlServer4Build = sqlServer4Build; }
private int Launch(LaunchConfiguration config, bool debug) { DebugLaunchHelper.RequireStartupFile(config); //if (factory.Id == _cpyInterpreterGuid || factory.Id == _cpy64InterpreterGuid) { // MessageBox.Show( // "The project is currently set to use the .NET debugger for IronPython debugging but the project is configured to start with a CPython interpreter.\r\n\r\nTo fix this change the debugger type in project properties->Debug->Launch mode.\r\nIf IronPython is not an available interpreter you may need to download it from http://ironpython.codeplex.com.", // "Visual Studio"); // return VSConstants.S_OK; //} try { if (debug) { if (string.IsNullOrEmpty(config.InterpreterArguments)) { config.InterpreterArguments = "-X:Debug"; } else if (config.InterpreterArguments.IndexOf("-X:Debug", StringComparison.OrdinalIgnoreCase) < 0) { config.InterpreterArguments = "-X:Debug " + config.InterpreterArguments; } var debugStdLib = _project.GetProperty(IronPythonLauncherOptions.DebugStandardLibrarySetting); bool debugStdLibResult; if (!bool.TryParse(debugStdLib, out debugStdLibResult) || !debugStdLibResult) { string interpDir = config.Interpreter.PrefixPath; config.InterpreterArguments += " -X:NoDebug \"" + System.Text.RegularExpressions.Regex.Escape(Path.Combine(interpDir, "Lib\\")) + ".*\""; } using (var dti = DebugLaunchHelper.CreateDebugTargetInfo(_serviceProvider, config)) { // Set the CLR debugger dti.Info.clsidCustom = VSConstants.CLSID_ComPlusOnlyDebugEngine; dti.Info.grfLaunch = (uint)__VSDBGLAUNCHFLAGS.DBGLAUNCH_StopDebuggingOnEnd; // Clear the CLSID list while launching, then restore it // so Dispose() can free it. var clsidList = dti.Info.pClsidList; dti.Info.pClsidList = IntPtr.Zero; dti.Info.dwClsidCount = 0; try { dti.Launch(); } finally { dti.Info.pClsidList = clsidList; } } } else { var psi = DebugLaunchHelper.CreateProcessStartInfo(_serviceProvider, config); Process.Start(psi).Dispose(); } } catch (FileNotFoundException) { } return(VSConstants.S_OK); }
public Config(LaunchConfiguration resource) : base(resource) { Commands = this.Add("commands", new Commands(resource)) as Commands; Files = this.Add("files", new Files(resource)) as Files; Services = this.Add("services", new CloudFormationDictionary(resource)); Sources = this.Add("sources", new Sources(resource)) as Sources; Packages = this.Add("packages", new Packages(resource)) as Packages; this.Add("ignoreErrors", false.ToString()); }
private static void RunVTune(SessionNode session, LaunchConfiguration config, bool openReport) { var interpreter = config.GetInterpreterPath(); if (!File.Exists(interpreter)) { MessageBox.Show(Strings.CannotFindPythonInterpreter, Strings.ProductTitle); return; } string outPathDir = Path.GetTempPath(); var subpath = Path.Combine(outPathDir, Path.GetRandomFileName()); while (Directory.Exists(subpath) || File.Exists(subpath)) { subpath = Path.Combine(outPathDir, Path.GetRandomFileName()); } outPathDir = subpath; string outPath = Path.Combine(outPathDir, "pythontrace.diagsession"); var driver = PythonToolsInstallPath.GetFile(ExternalProfilerDriverExe, typeof(PythonProfilingPackage).Assembly); var procInfo = new ProcessStartInfo(driver) { CreateNoWindow = false, Arguments = string.Join(" ", new[] { "-d", ProcessOutput.QuoteSingleArgument(outPathDir), "--", ProcessOutput.QuoteSingleArgument(interpreter), config.InterpreterArguments, string.IsNullOrEmpty(config.ScriptName) ? "" : ProcessOutput.QuoteSingleArgument(config.ScriptName), config.ScriptArguments }), WorkingDirectory = config.WorkingDirectory, }; var proc = new Process { StartInfo = procInfo }; var dte = (EnvDTE.DTE)session._serviceProvider.GetService(typeof(EnvDTE.DTE)); proc.EnableRaisingEvents = true; proc.Exited += (_, args) => { if (!File.Exists(Path.Combine(outPathDir, "Sample.dwjson"))) { MessageBox.Show(Strings.CannotFindGeneratedFile, Strings.ProductTitle); } else { PackageTrace(outPathDir); dte.ItemOperations.OpenFile(Path.Combine(outPathDir, "trace.diagsession")); } }; proc.Start(); }
internal Dictionary <string, string> GetFullEnvironment(LaunchConfiguration config) { if (config == null) { throw new ArgumentNullException(nameof(config)); } // Start with global environment, add configured environment, // then add search paths. var baseEnv = Environment.GetEnvironmentVariables(); // Clear search paths from the global environment. The launch // configuration should include the existing value var pathVar = config.Interpreter?.PathEnvironmentVariable; if (string.IsNullOrEmpty(pathVar)) { pathVar = "PYTHONPATH"; } baseEnv[pathVar] = string.Empty; // TODO: We could introduce a cache so that we don't activate the // environment + capture the env variables every time. Not doing this // right now to minimize risk/complexity so close to release. if (CondaUtils.IsCondaEnvironment(config.Interpreter.GetPrefixPath())) { var condaExe = CondaUtils.GetRootCondaExecutablePath(Site); var prefixPath = config.Interpreter.GetPrefixPath(); if (File.Exists(condaExe) && Directory.Exists(prefixPath)) { var condaEnv = CondaUtils.CaptureActivationEnvironmentVariablesForPrefix(condaExe, prefixPath); baseEnv = PathUtils.MergeEnvironments(baseEnv.AsEnumerable <string, string>(), condaEnv, "Path", pathVar); } } var env = PathUtils.MergeEnvironments( baseEnv.AsEnumerable <string, string>(), config.GetEnvironmentVariables(), "Path", pathVar ); if (config.SearchPaths != null && config.SearchPaths.Any()) { env = PathUtils.MergeEnvironments( env, new[] { new KeyValuePair <string, string>( pathVar, PathUtils.JoinPathList(config.SearchPaths) ) }, pathVar ); } return(env); }
private static string GetOptions(IServiceProvider provider, LaunchConfiguration config) { var pyService = provider.GetPythonToolsService(); return(string.Join(";", GetGlobalDebuggerOptions(pyService) .Concat(GetLaunchConfigurationOptions(config)) .Where(s => !string.IsNullOrEmpty(s)) .Select(s => s.Replace(";", ";;")) )); }
public override void AddToLaunchConfiguration(LaunchConfiguration configuration) { base.AddToLaunchConfiguration(configuration); this.Config.Files.Add("c:/cfn/scripts/ReSharperUltimate.10.0.2.exe") .Add("source", "https://s3.amazonaws.com/gtbb/software/JetBrains.ReSharperUltimate.10.0.2.exe"); var command = this.Config.Commands.AddCommand <Command>("InstallResharper"); command.Command = "c:/cfn/scripts/ReSharperUltimate.10.0.2.exe /VsVersion=14 /SpecificProductNames=ReSharper /Silent=True /PerMachine=True"; command.Test = "IF EXIST \"C:\\Program Files (x86)\\JetBrains\\Installations\\ReSharperPlatformVs14\\CsLex.exe\" EXIT /B 1"; command.WaitAfterCompletion = 0.ToString(); }
/// <summary> /// Constructeur par défaut /// </summary> public MainForm() { InitializeComponent(); _Instance = this; // Titre Text = _TITLE_MAIN_FORM; // EVO_73: Debug mode notify if (bool.Parse(Program.ApplicationSettings.DebugModeEnabled)) { Text += _TITLE_BRIBE_DEBUG; } // EVO_40 : lancement automatique d'un module try { string moduleName = Program.ApplicationSettings.StartupModule; if (StartupModuleList.Contains(moduleName)) { ModuleType moduleType = (ModuleType)Enum.Parse(typeof(ModuleType), moduleName); LoadTool(moduleType, null); } } catch (Exception ex) { // Exception silencieuse Exception2.PrintStackTrace(new Exception("Unable to launch startup module.", ex)); } // EVO_36 : initialisation des configurations de lancement string launchConfigurationsValue = Program.ApplicationSettings.TduLaunchConfigurations; if (string.IsNullOrEmpty(launchConfigurationsValue)) { Collection <LaunchConfiguration> launchConfigs = new Collection <LaunchConfiguration>(); LaunchConfiguration launchConfig = new LaunchConfiguration { Default = true, Name = _LAUNCH_CONFIG_DEFAULT_NAME }; launchConfigs.Add(launchConfig); Program.ApplicationSettings.TduLaunchConfigurations = LaunchConfigurationConverter.ConvertToString(launchConfigs); Program.ApplicationSettings.Save(); } // View mode _isBasicView = !bool.Parse(Program.ApplicationSettings.AdvancedMode); _SetView(); }
public override void AddToLaunchConfiguration(LaunchConfiguration configuration) { base.AddToLaunchConfiguration(configuration); var node = GetChefNodeJsonContent(configuration); var tfsNode = node.Add("tfs"); var sqlServer = new FnJoin(FnJoinDelimiter.Period, SqlServer.LogicalId, new ReferenceProperty(ActiveDirectoryBase.DomainFqdnParameterName)); tfsNode.Add("application_server_sqlname", sqlServer); tfsNode.Add(TeamFoundationServerBuildServerBase.TfsServiceAccountNameParameterName, new ReferenceProperty(TeamFoundationServerBuildServerBase.TfsServiceAccountNameParameterName)); tfsNode.Add(TeamFoundationServerBuildServerBase.TfsServicePasswordParameterName, new ReferenceProperty(TeamFoundationServerBuildServerBase.TfsServicePasswordParameterName)); }
internal void AddPropertiesAfter(LaunchConfiguration config) { AddArgumentAtEnd(config.ScriptArguments); WorkingDirectory = ChooseFirst(WorkingDirectory, config.WorkingDirectory); EnvironmentVariables = PathUtils.MergeEnvironments( EnvironmentVariables.MaybeEnumerate(), config.Environment.MaybeEnumerate(), "PATH", config.Interpreter.PathEnvironmentVariable ); }
public override void AddUser(LaunchConfiguration instance, string ou, ReferenceProperty user, ReferenceProperty password) { if (this.Type == ResourceType.AwsDirectoryServiceMicrosoftAd) { AddUserMicrosoftAd(instance, ou, (object)user, (object)password); } else { AddUserSimpleAd(instance, ou, (object)user, (object)password); } }
/// <summary> /// Default implementation of the "Start without Debugging" command. /// </summary> private Process StartWithoutDebugger(LaunchConfiguration config) { try { _serviceProvider.GetPythonToolsService().Logger.LogEvent(Logging.PythonLogEvent.Launch, new Logging.LaunchInfo { IsDebug = false, Version = config.Interpreter?.Version.ToString() ?? "" }); } catch (Exception ex) { Debug.Fail(ex.ToUnhandledExceptionMessage(GetType())); } return(Process.Start(DebugLaunchHelper.CreateProcessStartInfo(_serviceProvider, config))); }
public override void AddToLaunchConfiguration(LaunchConfiguration configuration) { base.AddToLaunchConfiguration(configuration); const string powerShellToolsVsixLocalPath = "c:/cfn/scripts/PowerShellTools.14.0.vsix"; var powerShellToolsVsix = this.Config.Files.GetFile(powerShellToolsVsixLocalPath); powerShellToolsVsix.Source = "https://visualstudiogallery.msdn.microsoft.com/c9eb3ba8-0c59-4944-9a62-6eee37294597/file/199313/2/PowerShellTools.14.0.vsix"; var installPowerSehllToolsVsix = this.Config.Commands.AddCommand <Command>("PowerShellTools140vsix"); installPowerSehllToolsVsix.Command = $"\"C:\\Program Files (x86)\\Microsoft Visual Studio 14.0\\Common7\\IDE\\VSIXInstaller.exe\" /q {powerShellToolsVsixLocalPath}"; installPowerSehllToolsVsix.WaitAfterCompletion = 0.ToString(); }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public override IDebugLaunchSettings [] QueryDebugTargets(DebugLaunchOptions launchOptions) { LoggingUtils.PrintFunction(); IDebugLauncher debugLauncher = null; try { debugLauncher = GetDebugLauncher(ServiceProvider); debugLauncher.PrepareLaunch(); DebugLaunchSettings debugLaunchSettings; Dictionary <string, string> projectProperties = DebuggerProperties.ProjectPropertiesToDictionary(); projectProperties.Add("ConfigurationGeneral.ProjectDir", Path.GetDirectoryName(DebuggerProperties.GetConfiguredProject().UnconfiguredProject.FullPath)); LaunchConfiguration launchConfig = debugLauncher.GetLaunchConfigurationFromProjectProperties(projectProperties); LaunchProps [] launchProps = debugLauncher.GetLaunchPropsFromProjectProperties(projectProperties); if (launchOptions.HasFlag(DebugLaunchOptions.NoDebug)) { debugLaunchSettings = (DebugLaunchSettings)debugLauncher.StartWithoutDebugging((int)launchOptions, launchConfig, launchProps, projectProperties); } else { debugLaunchSettings = (DebugLaunchSettings)debugLauncher.StartWithDebugging((int)launchOptions, launchConfig, launchProps, projectProperties); } return(new IDebugLaunchSettings [] { debugLaunchSettings }); } catch (Exception e) { LoggingUtils.HandleException(e); string description = string.Format("'QueryDebugTargets' failed:\n[Exception]{0}", e.Message); #if DEBUG description += "\n[Exception] Stack trace:\n" + e.StackTrace; #endif if (debugLauncher != null) { LoggingUtils.RequireOk(debugLauncher.GetConnectionService().LaunchDialogUpdate(description, true)); } VsShellUtilities.ShowMessageBox(ServiceProvider, description, "Android++ Debugger", OLEMSGICON.OLEMSGICON_CRITICAL, OLEMSGBUTTON.OLEMSGBUTTON_OK, OLEMSGDEFBUTTON.OLEMSGDEFBUTTON_FIRST); } return(null); }
public override void AddToLaunchConfiguration(LaunchConfiguration configuration) { base.AddToLaunchConfiguration(configuration); const string fileName = "Git-2.7.1.2-64-bit.exe"; const string filePath = "c:/cfn/scripts/" + fileName; this.Config.Files.Add(filePath) .Add("source", $"https://s3.amazonaws.com/{this.BucketName}/software/{fileName}"); this.Config.Commands.AddCommand <Command>(fileName.Replace('.', '-')).Command = $"{filePath} /silent"; }
public static void RequireStartupFile(LaunchConfiguration config) { if (string.IsNullOrEmpty(config.ScriptName)) { throw new NoStartupFileException(Strings.DebugLaunchScriptNameMissing); } if (!File.Exists(config.ScriptName)) { throw new NoStartupFileException(Strings.DebugLaunchScriptNameDoesntExist.FormatUI(config.ScriptName)); } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public DebugEngine () { m_broadcastHandleLock = new AutoResetEvent (false); m_breakpointManager = new DebugBreakpointManager (this); m_launchConfiguration = new LaunchConfiguration (); Program = null; NativeDebugger = null; JavaDebugger = null; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// private void InstallApplicationAsync(AndroidDevice debuggingDevice, LaunchConfiguration launchConfig) { // // Asynchronous installation process, so the UI can be updated appropriately. // LoggingUtils.PrintFunction (); ManualResetEvent installCompleteEvent = new ManualResetEvent (false); Exception installFailedException = null; System.Threading.Thread asyncInstallApplicationThread = new System.Threading.Thread (delegate () { try { string targetLocalApk = launchConfig ["TargetApk"]; string targetRemoteTemporaryPath = "/data/local/tmp"; string targetRemoteTemporaryFile = targetRemoteTemporaryPath + '/' + Path.GetFileName (targetLocalApk); bool keepData = launchConfig ["KeepAppData"].Equals ("true"); string installerPackage = launchConfig ["InstallerPackage"]; // // Construct 'am install' arguments for installing the application in a manner compatible with GDB. // // Note: Installations to /mnt/asec/ cause 'run-as' to fail regarding permissions. // StringBuilder installArgsBuilder = new StringBuilder (); installArgsBuilder.Append ("-f "); // install package on internal flash. (required for debugging) if (keepData) { installArgsBuilder.Append ("-r "); // reinstall an existing app, keeping its data. } if (!string.IsNullOrWhiteSpace (installerPackage)) { installArgsBuilder.Append (string.Format (CultureInfo.InvariantCulture, "-i {0} ", installerPackage)); } installArgsBuilder.Append (targetRemoteTemporaryFile); // // Explicitly install the target APK using 'pm' tool, as this allows more customisation. // // 1) APKs must already be on the device for this tool to work. We push these manually. // // 2) Installations can fail for various reasons; errors are reported thusly: // pkg: /data/local/tmp/hello-gdbserver-Debug.apk // Failure [INSTALL_FAILED_INVALID_URI] // m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "[adb:push] {0} {1}", targetLocalApk, targetRemoteTemporaryPath), false); debuggingDevice.Push (targetLocalApk, targetRemoteTemporaryPath); m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "[adb:shell:pm] {0} {1}", "install", installArgsBuilder.ToString ()), false); string installReport = debuggingDevice.Shell ("pm", "install " + installArgsBuilder.ToString (), int.MaxValue); if (!installReport.Contains ("Success")) { string sanitisedFailure = installReport; throw new InvalidOperationException (string.Format (CultureInfo.InvariantCulture, "[adb:shell:pm] install failed: {0}", sanitisedFailure)); } m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "[adb:shell:rm] {0}", targetRemoteTemporaryFile), false); debuggingDevice.Shell ("rm", targetRemoteTemporaryFile); } catch (Exception e) { LoggingUtils.HandleException (e); installFailedException = e; throw; } finally { installCompleteEvent.Set (); } }); asyncInstallApplicationThread.Start (); while (!installCompleteEvent.WaitOne (0)) { Application.DoEvents (); System.Threading.Thread.Sleep (100); } if (installFailedException != null) { throw installFailedException; } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public object StartWithoutDebugging(int launchOptions, LaunchConfiguration launchConfig, LaunchProps [] launchProps, IDictionary<string, string> projectProperties) { LoggingUtils.PrintFunction (); if (launchConfig == null) { throw new ArgumentNullException ("launchConfig"); } if (launchProps == null) { throw new ArgumentNullException ("launchProps"); } if (projectProperties == null) { throw new ArgumentNullException ("projectProperties"); } try { // // Refresh ADB service and evaluate a list of connected devices or emulators. // AndroidAdb.Refresh (); AndroidDevice debuggingDevice = GetPrioritisedConnectedDevice (); if (debuggingDevice == null) { throw new InvalidOperationException ("No device/emulator found or connected. Check status using \"adb devices\"."); } // // Construct VS launch settings to debug or attach to the specified target application. // launchOptions |= (int) DebugLaunchOptions.Silent; DebugLaunchSettings nonDebuglaunchSettings = new DebugLaunchSettings ((DebugLaunchOptions) launchOptions); nonDebuglaunchSettings.LaunchDebugEngineGuid = new Guid ("8310DAF9-1043-4C8E-85A0-FF68896E1922"); nonDebuglaunchSettings.PortSupplierGuid = new Guid ("3AEE417F-E5F9-4B89-BC31-20534C99B7F5"); nonDebuglaunchSettings.PortName = debuggingDevice.ID; nonDebuglaunchSettings.Options = launchConfig.ToString (); nonDebuglaunchSettings.Executable = launchConfig ["TargetApk"]; nonDebuglaunchSettings.LaunchOperation = DebugLaunchOperation.Custom; return nonDebuglaunchSettings; } catch (Exception e) { LoggingUtils.HandleException (e); throw; } }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public object StartWithDebugging(int launchOptions, LaunchConfiguration launchConfig, LaunchProps [] launchProps, IDictionary<string, string> projectProperties) { LoggingUtils.PrintFunction (); if (launchConfig == null) { throw new ArgumentNullException ("launchConfig"); } if (launchProps == null) { throw new ArgumentNullException ("launchProps"); } if (projectProperties == null) { throw new ArgumentNullException ("projectProperties"); } try { // // Refresh ADB service and evaluate a list of connected devices or emulators. // AndroidAdb.Refresh (); AndroidDevice debuggingDevice = GetPrioritisedConnectedDevice (); if (debuggingDevice == null) { throw new InvalidOperationException ("No device/emulator found or connected. Check status using \"adb devices\"."); } // // Enforce required device/emulator properties. // foreach (LaunchProps prop in launchProps) { debuggingDevice.Shell ("setprop", string.Format (CultureInfo.InvariantCulture, "{0} {1}", prop.Item1, prop.Item2)); } // // Construct VS launch settings to debug or attach to the specified target application. // bool shouldAttach = false; #if false AndroidProcess [] debuggingDeviceProcesses = debuggingDevice.GetProcesses (); foreach (AndroidProcess process in debuggingDeviceProcesses) { if (process.Name.Equals (applicationPackageName)) { shouldAttach = true; break; } } #endif launchOptions |= (int) DebugLaunchOptions.Silent; DebugLaunchSettings debugLaunchSettings = new DebugLaunchSettings ((DebugLaunchOptions) launchOptions); debugLaunchSettings.LaunchDebugEngineGuid = new Guid ("8310DAF9-1043-4C8E-85A0-FF68896E1922"); debugLaunchSettings.PortSupplierGuid = new Guid ("3AEE417F-E5F9-4B89-BC31-20534C99B7F5"); debugLaunchSettings.PortName = debuggingDevice.ID; debugLaunchSettings.Options = launchConfig.ToString (); if (shouldAttach) { debugLaunchSettings.Executable = launchConfig ["PackageName"]; debugLaunchSettings.LaunchOperation = DebugLaunchOperation.AlreadyRunning; } else { // // Determine whether the application is currently installed, and if it is; // check last modified date to ensure we don't re-installed unchanged binaries. // bool upToDateCheck = launchConfig ["UpToDateCheck"].Equals ("true"); bool appIsInstalled = false; bool appIsOutOfDate = true; if (upToDateCheck) { FileInfo targetApkFileInfo = new FileInfo (launchConfig ["TargetApk"]); try { string [] adbPmPathOutput = debuggingDevice.Shell ("pm", "path " + launchConfig ["PackageName"]).Replace ("\r", "").Split (new char [] { '\n' }, StringSplitOptions.RemoveEmptyEntries); foreach (string line in adbPmPathOutput) { if (line.StartsWith ("package:", StringComparison.OrdinalIgnoreCase)) { appIsInstalled = true; LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "'{0}' already installed on target '{1}'.", launchConfig ["PackageName"], debuggingDevice.ID), false)); string path = line.Substring ("package:".Length); // // Get the target device/emulator's UTC current time. // // This is done by specifying the '-u' argument to 'date'. Despite this though, // the returned string will always claim to be in GMT: // // i.e: "Fri Jan 9 14:35:23 GMT 2015" // DateTime debuggingDeviceUtcTime; try { string [] deviceDateOutput = debuggingDevice.Shell ("date", "-u").Replace ("\r", "").Split (new char [] { '\n' }, StringSplitOptions.RemoveEmptyEntries); string debuggingDeviceUtcTimestamp = deviceDateOutput [0]; string [] debuggingDeviceUtcTimestampComponents = debuggingDeviceUtcTimestamp.Split (new char [] { ' ' }, StringSplitOptions.RemoveEmptyEntries); debuggingDeviceUtcTimestampComponents [4] = "-00:00"; if (!DateTime.TryParseExact (string.Join (" ", debuggingDeviceUtcTimestampComponents), "ddd MMM d HH:mm:ss zzz yyyy", CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out debuggingDeviceUtcTime)) { break; } debuggingDeviceUtcTime = debuggingDeviceUtcTime.ToUniversalTime (); } catch (Exception e) { throw new InvalidOperationException ("Failed to evaluate device local time.", e); } // // Convert current device/emulator time to UTC, and probe the working machine's time too. // DateTime thisMachineUtcTime = DateTime.UtcNow; TimeSpan thisMachineUtcVersusDeviceUtc = debuggingDeviceUtcTime - thisMachineUtcTime; LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "Current UTC time on '{0}': {1}", debuggingDevice.ID, debuggingDeviceUtcTime.ToString ()), false)); LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "Current UTC time on '{0}': {1}", System.Environment.MachineName, thisMachineUtcTime.ToString ()), false)); LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "Difference in UTC time between '{0}' and '{1}': {2}", System.Environment.MachineName, debuggingDevice.ID, thisMachineUtcVersusDeviceUtc.ToString ()), false)); // // Check the last modified date; ls output currently uses this format: // // -rw-r--r-- system system 11533274 2015-01-09 13:47 com.example.native_activity-2.apk // DateTime lastModifiedTimestampDeviceLocalTime; try { string [] extendedLsOutput = debuggingDevice.Shell ("ls -l", path).Replace ("\r", "").Split (new char [] { '\n' }, StringSplitOptions.RemoveEmptyEntries); string [] extendedLsOutputComponents = extendedLsOutput [0].Split (new char [] { ' ' }, StringSplitOptions.RemoveEmptyEntries); string date = extendedLsOutputComponents [4]; string time = extendedLsOutputComponents [5]; if (!DateTime.TryParseExact (date + " " + time, "yyyy-MM-dd HH:mm", CultureInfo.InvariantCulture, DateTimeStyles.AllowWhiteSpaces, out lastModifiedTimestampDeviceLocalTime)) { break; } } catch (Exception e) { throw new InvalidOperationException (string.Format (CultureInfo.InvariantCulture, "Failed to evaluate device local modified time of: {0}", path), e); } // // Calculate how long ago the APK was changed, according to the device's local time. // TimeSpan timeSinceLastModification = debuggingDeviceUtcTime - lastModifiedTimestampDeviceLocalTime; DateTime debuggingDeviceUtcTimeAtLastModification = debuggingDeviceUtcTime - timeSinceLastModification; DateTime thisMachineUtcTimeAtLastModification = thisMachineUtcTime - timeSinceLastModification; LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "'{0}' was last modified on '{1}' at: {2}.", launchConfig ["PackageName"], debuggingDevice.ID, debuggingDeviceUtcTimeAtLastModification.ToString ()), false)); LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "{0} (on {1}) was around {2} (on {3}).", debuggingDeviceUtcTimeAtLastModification.ToString (), debuggingDevice.ID, thisMachineUtcTimeAtLastModification.ToString (), System.Environment.MachineName), false)); LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "'{0}' was last modified on '{1}' at: {2}.", Path.GetFileName (targetApkFileInfo.FullName), System.Environment.MachineName, targetApkFileInfo.LastWriteTime.ToString ()), false)); if ((targetApkFileInfo.LastWriteTime + thisMachineUtcVersusDeviceUtc) > thisMachineUtcTimeAtLastModification) { LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "'{0}' was determined to be out-of-date. Reinstalling...", launchConfig ["PackageName"]), false)); } else { appIsOutOfDate = false; } break; } } } catch (Exception) { appIsInstalled = false; } } else { LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate ("Skipping up-to-date check.", false)); } if (!appIsInstalled || appIsOutOfDate) { LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "Installing '{0}' to '{1}'...", launchConfig ["PackageName"], debuggingDevice.ID), false)); InstallApplicationAsync (debuggingDevice, launchConfig); LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "'{0}' installed successfully.", launchConfig ["PackageName"]), false)); } else { LoggingUtils.RequireOk (m_debugConnectionService.LaunchDialogUpdate (string.Format (CultureInfo.InvariantCulture, "'{0}' on '{1}' is up-to-date. Skipping installation...", launchConfig ["PackageName"], debuggingDevice.ID), false)); } debugLaunchSettings.Executable = launchConfig ["TargetApk"]; debugLaunchSettings.LaunchOperation = DebugLaunchOperation.Custom; } return debugLaunchSettings; } catch (Exception e) { LoggingUtils.HandleException (e); throw; } }
public LaunchConfiguration GetLaunchConfigurationFromProjectProperties(IDictionary<string, string> projectProperties) { LoggingUtils.PrintFunction (); // // Retrieve standard project macro values, and determine the preferred debugger configuration. // string projectTargetName = EvaluateProjectProperty (projectProperties, "ConfigurationGeneral", "TargetName"); string projectProjectDir = EvaluateProjectProperty (projectProperties, "ConfigurationGeneral", "ProjectDir"); string debuggerMode = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigMode"); string debuggerTargetApk = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigTargetApk"); string debuggerUpToDateCheck = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigUpToDateCheck"); string debuggerLaunchActivity = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigLaunchActivity"); string debuggerDebugMode = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigDebugMode"); string debuggerOpenGlTrace = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigOpenGlTrace"); string debuggerKeepAppData = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigKeepAppData"); string debuggerInstallerPackage = EvaluateProjectProperty (projectProperties, "AndroidPlusPlusDebugger", "DebuggerConfigInstallerPackage"); if (string.IsNullOrEmpty (debuggerMode)) { debuggerMode = "Custom"; } else if (debuggerMode.Equals ("vs-android")) { // // Support for vs-android. // string antBuildPath = EvaluateProjectProperty (projectProperties, "AntBuild", "AntBuildPath"); string antBuildType = EvaluateProjectProperty (projectProperties, "AntBuild", "AntBuildType"); string antBuildXml = Path.Combine (antBuildPath, "build.xml"); XmlDocument buildXmlDocument = new XmlDocument (); buildXmlDocument.Load (antBuildXml); string antBuildXmlProjectName = buildXmlDocument.DocumentElement.GetAttribute ("name"); debuggerTargetApk = Path.Combine (antBuildPath, "bin", string.Format (CultureInfo.InvariantCulture, "{0}-{1}.apk", antBuildXmlProjectName, antBuildType)); } // // Ensure the provided target APK is found and absolute. // if (string.IsNullOrEmpty (debuggerTargetApk)) { throw new FileNotFoundException ("Could not locate target application. Empty path provided."); } else if (!Path.IsPathRooted (debuggerTargetApk) && !string.IsNullOrWhiteSpace (projectProjectDir)) { debuggerTargetApk = Path.Combine (projectProjectDir, debuggerTargetApk); } if (!Path.IsPathRooted (debuggerTargetApk)) { throw new InvalidOperationException ("Could not evaluate an absolute path to the target application. Tried: " + debuggerTargetApk); } debuggerTargetApk = Path.GetFullPath (debuggerTargetApk); // normalises relative paths. if (!File.Exists (debuggerTargetApk)) { throw new FileNotFoundException ("Could not find required target application. Expected: " + debuggerTargetApk); } // // Find the selected Android SDK (and associated build-tools) deployment. // string androidSdkRoot = EvaluateProjectProperty (projectProperties, "ConfigurationGeneral", "AndroidSdkRoot"); if (string.IsNullOrWhiteSpace (androidSdkRoot)) { throw new DirectoryNotFoundException ("Could not locate Android SDK. \"AndroidSdkRoot\" property is empty."); } else if (!Directory.Exists (androidSdkRoot)) { throw new DirectoryNotFoundException ("Could not locate Android SDK. \"AndroidSdkRoot\" property references a directory which does not exist. Expected: " + androidSdkRoot); } string androidSdkBuildToolsVersion = EvaluateProjectProperty (projectProperties, "ConfigurationGeneral", "AndroidSdkBuildToolsVersion"); string androidSdkBuildToolsPath = Path.Combine (androidSdkRoot, "build-tools", androidSdkBuildToolsVersion); if (!Directory.Exists (androidSdkBuildToolsPath)) { throw new DirectoryNotFoundException (string.Format (CultureInfo.CurrentCulture, "Could not locate Android SDK build-tools (v{0}). Expected: {1}", androidSdkBuildToolsVersion, androidSdkBuildToolsPath)); } // // Spawn a AAPT.exe instance to gain some extra information about the APK we are trying to load. // string applicationPackageName = string.Empty; string applicationLaunchActivity = string.Empty; string aaptToolPath = Path.Combine (androidSdkBuildToolsPath, "aapt.exe"); if (!File.Exists (aaptToolPath)) { throw new FileNotFoundException ("Could not locate AAPT tool (under Android SDK build-tools).", aaptToolPath); } using (SyncRedirectProcess getApkDetails = new SyncRedirectProcess (aaptToolPath, "dump --values badging " + PathUtils.SantiseWindowsPath (debuggerTargetApk))) { int exitCode = getApkDetails.StartAndWaitForExit (); if (exitCode != 0) { throw new InvalidOperationException ("AAPT failed to dump required application badging information. Exit-code: " + exitCode); } string [] apkDetails = getApkDetails.StandardOutput.Replace ("\r", "").Split (new char [] { '\n' }); foreach (string singleLine in apkDetails) { if (singleLine.StartsWith ("package: ", StringComparison.OrdinalIgnoreCase)) { // // Retrieve package name from format: "package: name='com.example.hellogdbserver' versionCode='1' versionName='1.0'" // string [] packageData = singleLine.Substring ("package: ".Length).Split (' '); foreach (string data in packageData) { if (data.StartsWith ("name=", StringComparison.OrdinalIgnoreCase)) { applicationPackageName = data.Substring ("name=".Length).Trim ('\''); } } } else if (singleLine.StartsWith ("launchable-activity: ", StringComparison.OrdinalIgnoreCase)) { string [] launchActivityData = singleLine.Substring ("launchable-activity: ".Length).Split (' '); foreach (string data in launchActivityData) { if (data.StartsWith ("name=", StringComparison.OrdinalIgnoreCase)) { applicationLaunchActivity = data.Substring ("name=".Length).Trim ('\''); } } } } } // // If a specific launch activity was not requested, ensure that the default one is referenced. // if (string.IsNullOrEmpty (debuggerLaunchActivity)) { debuggerLaunchActivity = applicationLaunchActivity; } LaunchConfiguration launchConfig = new LaunchConfiguration (); launchConfig ["TargetApk"] = debuggerTargetApk; launchConfig ["UpToDateCheck"] = debuggerUpToDateCheck; launchConfig ["PackageName"] = applicationPackageName; launchConfig ["LaunchActivity"] = debuggerLaunchActivity; launchConfig ["DebugMode"] = debuggerDebugMode; launchConfig ["OpenGlTrace"] = debuggerOpenGlTrace; launchConfig ["KeepAppData"] = debuggerKeepAppData; launchConfig ["InstallerPackage"] = debuggerInstallerPackage; return launchConfig; }
//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// //////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////// public CLangDebugger (DebugEngine debugEngine, LaunchConfiguration launchConfiguration, DebuggeeProgram debugProgram) { Engine = debugEngine; m_launchConfiguration = launchConfiguration; NativeProgram = new CLangDebuggeeProgram (this, debugProgram); NativeMemoryBytes = new CLangDebuggeeMemoryBytes (this); VariableManager = new CLangDebuggerVariableManager (this); // // Evaluate target device's architecture triple. // string preferedGdbAbiToolPrefix = string.Empty; bool allow64BitAbis = true; switch (debugProgram.DebugProcess.NativeProcess.PrimaryCpuAbi) { case "armeabi": case "armeabi-v7a": { preferedGdbAbiToolPrefix = "arm-linux-androideabi"; break; } case "arm64-v8a": { if (allow64BitAbis) { preferedGdbAbiToolPrefix = "aarch64-linux-android"; } else { preferedGdbAbiToolPrefix = "arm-linux-androideabi"; } break; } case "x86": { preferedGdbAbiToolPrefix = "i686-linux-android"; break; } case "x86_64": { if (allow64BitAbis) { preferedGdbAbiToolPrefix = "x86_64-linux-android"; } else { preferedGdbAbiToolPrefix = "i686-linux-android"; } break; } case "mips": { preferedGdbAbiToolPrefix = "mipsel-linux-android"; break; } case "mips64": { if (allow64BitAbis) { preferedGdbAbiToolPrefix = "mips64el-linux-android"; } else { preferedGdbAbiToolPrefix = "mipsel-linux-android"; } break; } } if (string.IsNullOrEmpty (preferedGdbAbiToolPrefix)) { throw new InvalidOperationException (string.Format ("Unrecognised target primary CPU ABI: {0}", debugProgram.DebugProcess.NativeProcess.PrimaryCpuAbi)); } bool preferedGdbAbiIs64Bit = preferedGdbAbiToolPrefix.Contains ("64"); Engine.Broadcast (new DebugEngineEvent.DebuggerConnectionEvent (DebugEngineEvent.DebuggerConnectionEvent.EventType.LogStatus, string.Format ("Configuring GDB for '{0}' target...", preferedGdbAbiToolPrefix)), null, null); // // Android++ bundles its own copies of GDB to get round various NDK issues. Search for these. // string androidPlusPlusRoot = Environment.GetEnvironmentVariable ("ANDROID_PLUS_PLUS"); // // Build GDB version permutations. // List<string> gdbToolPermutations = new List<string> (); string [] availableHostArchitectures = new string [] { "x86", "x86_64" }; foreach (string arch in availableHostArchitectures) { if (arch.Contains ("64") && !Environment.Is64BitOperatingSystem) { continue; } string gdbToolFilePattern = string.Format ("{0}-gdb.cmd", preferedGdbAbiToolPrefix); string [] availableVersionPaths = Directory.GetDirectories (Path.Combine (androidPlusPlusRoot, "contrib", "gdb", "bin", arch), "*.*.*", SearchOption.TopDirectoryOnly); foreach (string versionPath in availableVersionPaths) { string [] gdbToolMatches = Directory.GetFiles (versionPath, gdbToolFilePattern, SearchOption.TopDirectoryOnly); foreach (string tool in gdbToolMatches) { gdbToolPermutations.Add (tool); } } } if (gdbToolPermutations.Count == 0) { throw new InvalidOperationException ("Could not locate required 32/64-bit GDB deployments."); } else { // // Pick the oldest GDB version available if running 'Jelly Bean' or below. // bool forceNdkR9dClient = (debugProgram.DebugProcess.NativeProcess.HostDevice.SdkVersion <= AndroidSettings.VersionCode.JELLY_BEAN); if (forceNdkR9dClient) { m_gdbSetup = new GdbSetup (debugProgram.DebugProcess.NativeProcess, gdbToolPermutations [0]); } else { m_gdbSetup = new GdbSetup (debugProgram.DebugProcess.NativeProcess, gdbToolPermutations [gdbToolPermutations.Count - 1]); } // // A symbolic link to 'share' is placed in the architecture directory, provide GDB with that location. // string architecturePath = Path.GetDirectoryName (Path.GetDirectoryName (m_gdbSetup.GdbToolPath)); string pythonGdbScriptsPath = Path.Combine (architecturePath, "share", "gdb"); m_gdbSetup.GdbToolArguments += " --data-directory " + PathUtils.SantiseWindowsPath (pythonGdbScriptsPath); } if (m_gdbSetup == null) { throw new InvalidOperationException ("Could not evaluate a suitable GDB instance. Ensure you have the correct NDK deployment for your system's architecture."); } if (m_launchConfiguration != null) { string launchDirectory; if (m_launchConfiguration.TryGetValue ("LaunchSuspendedDir", out launchDirectory)) { m_gdbSetup.SymbolDirectories.Add (launchDirectory); } } GdbServer = new GdbServer (m_gdbSetup); GdbClient = new GdbClient (m_gdbSetup); GdbClient.OnResultRecord = OnClientResultRecord; GdbClient.OnAsyncRecord = OnClientAsyncRecord; GdbClient.OnStreamRecord = OnClientStreamRecord; GdbClient.Start (); }