public override bool CanDebugCommand (ExecutionCommand command) { NativeExecutionCommand cmd = command as NativeExecutionCommand; if (cmd == null) return false; string file = FindFile (cmd.Command); if (!File.Exists (file)) { // The provided file is not guaranteed to exist. If it doesn't // we assume we can execute it because otherwise the run command // in the IDE will be disabled, and that's not good because that // command will build the project if the exec doesn't yet exist. return true; } file = Path.GetFullPath (file); DateTime currentTime = File.GetLastWriteTime (file); FileData data; if (fileCheckCache.TryGetValue (file, out data)) { if (data.LastCheck == currentTime) return data.IsExe; } data.LastCheck = currentTime; try { data.IsExe = IsExecutable (file); } catch { data.IsExe = false; } fileCheckCache [file] = data; return data.IsExe; }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand c) { var cmd = (DotNetExecutionCommand) c; var runtime = (MonoTargetRuntime)cmd.TargetRuntime; var dsi = new SoftDebuggerStartInfo (runtime.Prefix, runtime.EnvironmentVariables) { Command = cmd.Command, Arguments = cmd.Arguments, WorkingDirectory = cmd.WorkingDirectory, }; string error; dsi.UserAssemblyNames = GetAssemblyNames (cmd.UserAssemblyPaths, out error); dsi.LogMessage = error; foreach (KeyValuePair<string,string> var in cmd.EnvironmentVariables) dsi.EnvironmentVariables [var.Key] = var.Value; var varsCopy = new Dictionary<string, string> (cmd.EnvironmentVariables); dsi.ExternalConsoleLauncher = delegate (System.Diagnostics.ProcessStartInfo info) { IProcessAsyncOperation oper; oper = Runtime.ProcessService.StartConsoleProcess (info.FileName, info.Arguments, info.WorkingDirectory, varsCopy, ExternalConsoleFactory.Instance.CreateConsole (dsi.CloseExternalConsoleOnExit), null); return new ProcessAdapter (oper, Path.GetFileName (info.FileName)); }; return dsi; }
public IProcessAsyncOperation Execute ( ExecutionCommand command, IConsole console) { var cmd = (TizenExecutionCommand) command; var config = cmd.Config; var sdkInfo = TizenSdkInfo.GetSdkInfo (); if (sdkInfo == null) return Finish (false); var project = config.ParentItem as Project; var tpkPath = FindTpkPath (project); if (tpkPath == null) return Finish (false); var sdkBuild = new TizenSdkBuild (config, sdkInfo); if (!sdkBuild.DoNativeInstall (tpkPath, console)) return Finish (false); var tpkId = ExtractTpkId (tpkPath); if (tpkId == null) return Finish (false); var success = sdkBuild.DoNativeRun (tpkId, console); return Finish (success); }
public bool CanExecute (ExecutionCommand command) { var cmd = command as MonoDroidExecutionCommand; if (cmd == null) return false; return true; }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { DotNetExecutionCommand cmd = command as DotNetExecutionCommand; if (cmd != null) { DebuggerStartInfo startInfo = new DebuggerStartInfo (); startInfo.Command = cmd.Command; startInfo.Arguments = cmd.Arguments; startInfo.WorkingDirectory = cmd.WorkingDirectory; if (cmd.EnvironmentVariables.Count > 0) { foreach (KeyValuePair<string, string> val in cmd.EnvironmentVariables) startInfo.EnvironmentVariables[val.Key] = val.Value; } return startInfo; } AspNetExecutionCommand acmd = command as AspNetExecutionCommand; if (acmd != null) { DebuggerStartInfo startInfo = new DebuggerStartInfo (); string xspName = (acmd.ClrVersion == ClrVersion.Net_1_1) ? "xsp" : "xsp2"; string xspPath = acmd.TargetRuntime.GetToolPath (acmd.TargetFramework, xspName); if (!File.Exists (xspPath)) throw new UserException (string.Format ("The \"{0}\" web server cannot be started. Please ensure that it is installed.", xspName), null); startInfo.Command = xspPath; startInfo.Arguments = acmd.XspParameters.GetXspParameters () + " --nonstop"; startInfo.WorkingDirectory = acmd.BaseDirectory; // Set DEVPATH when running on Windows (notice that this has no effect unless // <developmentMode developerInstallation="true" /> is set in xsp2.exe.config startInfo.EnvironmentVariables["DEVPATH"] = Path.GetDirectoryName (xspPath); return startInfo; } throw new NotSupportedException (); }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console) { DotNetExecutionCommand cmd = (DotNetExecutionCommand) command; if (cmd.TargetRuntime == null) cmd.TargetRuntime = Runtime.SystemAssemblyService.DefaultRuntime; return cmd.TargetRuntime.GetExecutionHandler ().Execute (cmd, console); }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { var cmd = (AspNetExecutionCommand) command; var runtime = (MonoTargetRuntime)cmd.TargetRuntime; var startInfo = new SoftDebuggerStartInfo (runtime.Prefix, runtime.EnvironmentVariables) { WorkingDirectory = cmd.BaseDirectory, Arguments = cmd.XspParameters.GetXspParameters ().Trim (), }; var xspName = AspNetExecutionHandler.GetXspName (cmd); FilePath fxDir = GetFxDir (runtime, cmd.ClrVersion); FilePath xspPath = fxDir.Combine (xspName).ChangeExtension (".exe"); //no idea why xsp is sometimes relocated to a "winhack" dir on Windows if (MonoDevelop.Core.PropertyService.IsWindows && !File.Exists (xspPath)) { var winhack = fxDir.Combine ("winhack"); if (Directory.Exists (winhack)) xspPath = winhack.Combine (xspName).ChangeExtension (".exe"); } if (!File.Exists (xspPath)) throw new UserException (GettextCatalog.GetString ( "The \"{0}\" web server cannot be started. Please ensure that it is installed.", xspName), null); startInfo.Command = xspPath; string error; startInfo.UserAssemblyNames = SoftDebuggerEngine.GetAssemblyNames (cmd.UserAssemblyPaths, out error); startInfo.LogMessage = error; return startInfo; }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console) { if (!CanExecute (command)) return null; DebugExecutionHandler h = new DebugExecutionHandler (null); return h.Execute (command, console); }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { var cmd = (AspNetExecutionCommand) command; var runtime = (MonoTargetRuntime)cmd.TargetRuntime; var startInfo = new SoftDebuggerStartInfo (runtime.Prefix, runtime.EnvironmentVariables) { WorkingDirectory = cmd.BaseDirectory, Arguments = cmd.XspParameters.GetXspParameters ().Trim (), }; FilePath prefix = runtime.Prefix; if (MonoDevelop.Core.PropertyService.IsWindows) { startInfo.Command = (cmd.ClrVersion == ClrVersion.Net_1_1) ? prefix.Combine ("lib", "mono", "1.0", "winhack", "xsp.exe") : prefix.Combine ("lib", "mono", "2.0", "winhack", "xsp2.exe"); } else { startInfo.Command = (cmd.ClrVersion == ClrVersion.Net_1_1) ? prefix.Combine ("lib", "mono", "1.0", "xsp.exe") : prefix.Combine ("lib", "mono", "2.0", "xsp2.exe"); } string error; startInfo.UserAssemblyNames = SoftDebuggerEngine.GetAssemblyNames (cmd.UserAssemblyPaths, out error); startInfo.LogMessage = error; return startInfo; }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { AspNetExecutionCommand cmd = (AspNetExecutionCommand) command; MonoDebuggerStartInfo startInfo = MonoDebuggerSessionFactory.CreateDebuggerStartInfo (cmd.TargetRuntime); string xspPath = Path.Combine (startInfo.MonoPrefix, "lib" + Path.DirectorySeparatorChar + "mono" + Path.DirectorySeparatorChar); if (cmd.ClrVersion == ClrVersion.Net_1_1) xspPath += Path.Combine ("1.0","xsp.exe"); else xspPath += Path.Combine ("2.0","xsp2.exe"); startInfo.IsXsp = true; startInfo.UserCodeOnly = true; startInfo.Command = xspPath; startInfo.WorkingDirectory = cmd.BaseDirectory; startInfo.Arguments = cmd.XspParameters.GetXspParameters ().Trim (); string binDir = Path.Combine (cmd.BaseDirectory, "bin"); startInfo.UserModules = new List<string> (); foreach (string file in Directory.GetFiles (binDir)) { if (file.EndsWith (".dll") || file.EndsWith (".exe")) startInfo.UserModules.Add (file); } return startInfo; }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { var cmd = (MoonlightExecutionCommand) command; var msi = new MoonlightDebuggerStartInfo (cmd.AppName, cmd.Url); SoftDebuggerEngine.SetUserAssemblyNames (msi, cmd.UserAssemblyPaths); return msi; }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console) { var cmd = (MonoDroidExecutionCommand) command; int runningProcessId = -1; var launchOp = new ChainedAsyncOperationSequence ( new ChainedAsyncOperation<AdbGetProcessIdOperation> () { Create = () => new AdbGetProcessIdOperation (cmd.Device, cmd.PackageName), Completed = (op) => { if (op.Success) runningProcessId = op.ProcessId; } }, new ChainedAsyncOperation () { Skip = () => runningProcessId <= 0 ? "" : null, Create = () => new AdbShellOperation (cmd.Device, "kill " + runningProcessId) }, new ChainedAsyncOperation () { Create = () => MonoDroidFramework.Toolbox.StartActivity (cmd.Device, cmd.Activity) } ); launchOp.Start (); return new MonoDroidProcess (cmd.Device, cmd.Activity, cmd.PackageName, console.Out.Write, console.Error.Write, launchOp); }
public override DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand c) { var cmd = (DotNetExecutionCommand) c; var runtime = (MonoTargetRuntime)cmd.TargetRuntime; var dsi = new SoftDebuggerStartInfo (runtime.Prefix, runtime.EnvironmentVariables) { Command = cmd.Command, Arguments = cmd.Arguments, WorkingDirectory = cmd.WorkingDirectory, }; SetUserAssemblyNames (dsi, cmd.UserAssemblyPaths); foreach (KeyValuePair<string,string> var in cmd.EnvironmentVariables) dsi.EnvironmentVariables [var.Key] = var.Value; var varsCopy = new Dictionary<string, string> (cmd.EnvironmentVariables); var startArgs = (SoftDebuggerLaunchArgs) dsi.StartArgs; startArgs.ExternalConsoleLauncher = delegate (System.Diagnostics.ProcessStartInfo info) { ProcessAsyncOperation oper; oper = Runtime.ProcessService.StartConsoleProcess (info.FileName, info.Arguments, info.WorkingDirectory, ExternalConsoleFactory.Instance.CreateConsole (dsi.CloseExternalConsoleOnExit), varsCopy); return new ProcessAdapter (oper, Path.GetFileName (info.FileName)); }; startArgs.MonoExecutableFileName = runtime.MonoRuntimeInfo.Force64or32bit.HasValue ? runtime.MonoRuntimeInfo.Force64or32bit.Value ? "mono64" : "mono32" : "mono"; return dsi; }
public DebuggerStartInfo CreateDebuggerStartInfo(ExecutionCommand command) { var cmd = (MonobjcExecutionCommand) command; var startInfo = new MonobjcDebuggerStartInfo(IPAddress.Loopback, 46789, cmd); startInfo.SetUserAssemblies(cmd.UserAssemblyPaths); return startInfo; }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console) { var cmd = (AspNetExecutionCommand) command; var xspPath = GetXspPath (cmd); //if it's a script, use a native execution handler if (xspPath.Extension != ".exe") { //set mono debug mode if project's in debug mode var envVars = cmd.TargetRuntime.GetToolsExecutionEnvironment (cmd.TargetFramework).Variables; if (cmd.DebugMode) { envVars = new Dictionary<string, string> (envVars); envVars ["MONO_OPTIONS"] = "--debug"; } var ncmd = new NativeExecutionCommand ( xspPath, cmd.XspParameters.GetXspParameters () + " --nonstop", cmd.BaseDirectory, envVars); return Runtime.ProcessService.GetDefaultExecutionHandler (ncmd).Execute (ncmd, console); } // Set DEVPATH when running on Windows (notice that this has no effect unless // <developmentMode developerInstallation="true" /> is set in xsp2.exe.config var evars = cmd.TargetRuntime.GetToolsExecutionEnvironment (cmd.TargetFramework).Variables; if (cmd.TargetRuntime is MsNetTargetRuntime) evars["DEVPATH"] = Path.GetDirectoryName (xspPath); var netCmd = new DotNetExecutionCommand ( xspPath, cmd.XspParameters.GetXspParameters () + " --nonstop", cmd.BaseDirectory, evars); netCmd.DebugMode = cmd.DebugMode; return cmd.TargetRuntime.GetExecutionHandler ().Execute (netCmd, console); }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console) { var cmd = (MonoDroidExecutionCommand) command; var launchOp = MonoDroidFramework.Toolbox.StartActivity (cmd.Device, cmd.Activity); return new MonoDroidProcess (cmd.Device, cmd.Activity, cmd.PackageName, console.Out.Write, console.Error.Write, launchOp, false); }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { var cmd = (MonoMacExecutionCommand) command; var startInfo = new MonoMacDebuggerStartInfo (cmd); SoftDebuggerEngine.SetUserAssemblyNames (startInfo, cmd.UserAssemblyPaths); return startInfo; }
public override bool CanDebugCommand(ExecutionCommand cmd) { var processCmd = cmd as ProcessExecutionCommand; if (processCmd == null) return false; return processCmd.Command.StartsWith("XenkoDebug"); }
public bool CanDebugCommand (ExecutionCommand command) { if (PropertyService.IsMac || PropertyService.IsWindows) return false; var cmd = command as MoonlightExecutionCommand; return cmd != null && cmd.Url.StartsWith ("file://"); }
public ExecutionCommand GetTargetCommand () { if (cmd != null) return cmd; SpyHandler sh = new SpyHandler (); runCheckDelegate (sh); return cmd = sh.Command; }
public IProcessAsyncOperation Execute (ExecutionCommand command, IConsole console) { //FIXME: use open -W -n Foo.app, or the launch script? var cmd = (MonoMacExecutionCommand) command; return Runtime.ProcessService.StartConsoleProcess (cmd.LaunchScript, "", //"open", string.Format ( "-W -n \"{0}\"", cmd.AppPath), cmd.AppPath.ParentDirectory, console, null); }
public DebuggerStartInfo CreateDebuggerStartInfo(ExecutionCommand cmd) { var dsi = cmd.CommandString.EndsWith("Client") ? new SoftDebuggerStartInfo(new SoftDebuggerConnectArgs("TestApp", IPAddress.Loopback, 13332)) : new SoftDebuggerStartInfo(new SoftDebuggerListenArgs("TestApp", IPAddress.Any, 13332)); return dsi; }
internal IProcessAsyncOperation InternalExecute (CommandExecutionContext ctx, IExecutionMode mode, ExecutionCommand command, IConsole console) { CustomExecutionMode cmode = ExecutionModeCommandService.ShowParamtersDialog (ctx, mode, null); if (cmode == null) return new CancelledProcessAsyncOperation (); return cmode.Execute (command, console, false, false); }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { var cmd = (MonoMacExecutionCommand) command; var startInfo = new MonoMacDebuggerStartInfo (cmd); startInfo.SetUserAssemblies (cmd.UserAssemblyPaths); return startInfo; }
public bool CanDebugCommand (ExecutionCommand cmd) { var netCmd = cmd as DotNetExecutionCommand; if (netCmd == null) return false; return CanDebugRuntime (netCmd.TargetRuntime); }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { var cmd = (MonoDroidExecutionCommand) command; //var startInfo = new MonoDroidDebuggerStartInfo (MonoDroidSettings.GetDebuggerHostIP (false), cmd); var startInfo = new MonoDroidDebuggerStartInfo (IPAddress.Loopback, cmd); SoftDebuggerEngine.SetUserAssemblyNames (startInfo, cmd.UserAssemblyPaths); return startInfo; }
public bool CanExecute (ExecutionCommand command) { var cmd = command as IPhoneExecutionCommand; if (cmd == null) return false; if (SimulatorTarget != null && (!cmd.Simulator || !SimulatorTarget.Supports (cmd.MinimumOSVersion, cmd.SupportedDevices))) return false; return true; }
public void Customize (ExecutionCommand cmd, object data) { DotNetExecutionCommand command = (DotNetExecutionCommand) cmd; MonoExecutionParameters config = (MonoExecutionParameters) data; string opts; config.GenerateOptions (command.EnvironmentVariables, out opts); command.RuntimeArguments = opts; }
/// <summary> /// Creates the debugger start info. /// </summary> /// <param name = "command">The command.</param> /// <returns></returns> public DebuggerStartInfo CreateDebuggerStartInfo(ExecutionCommand command) { MonobjcExecutionCommand executionCommand = (MonobjcExecutionCommand)command; MonobjcDebuggerStartInfo startInfo = new MonobjcDebuggerStartInfo (executionCommand); SoftDebuggerEngine.SetUserAssemblyNames (startInfo, executionCommand.UserAssemblyPaths); return startInfo; }
public DebuggerStartInfo CreateDebuggerStartInfo (ExecutionCommand command) { var cmd = command as CryEngineExecutionCommand; if (null == cmd){ return null; } var msi = new CryEngineDebuggerStartInfo("CryEngine"); // msi.SetUserAssemblies (null); msi.Arguments = string.Format ("-projectPath \"{0}\"", cmd.ProjectPath); return msi; }
public bool CanExecute(ExecutionCommand command) { return(Runtime.ProcessService.GetDefaultExecutionHandler(command) != null); }
public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console) { IExecutionHandler handler = Runtime.ProcessService.GetDefaultExecutionHandler(command); return(handler.Execute(command, console)); }
public ProcessAsyncOperation Execute(MonoDevelop.Core.Execution.ExecutionCommand command, MonoDevelop.Core.Execution.OperationConsole console) { throw new InvalidOperationException(); }
public virtual bool CanExecute(ExecutionCommand command) { return(command is NativeExecutionCommand); }
public override bool CanExecute(ExecutionCommand command) { return(command is DotNetExecutionCommand); }