Example #1
0
        Task StartRemoteProcess()
        {
            return(Task.Run(() => {
                var cmd = Runtime.ProcessService.CreateCommand(exePath);
                cmd.Arguments = ((IPEndPoint)listener.LocalEndpoint).Port + " " + DebugMode;
                if (!string.IsNullOrEmpty(workingDirectory))
                {
                    cmd.WorkingDirectory = workingDirectory;
                }

                if (environmentVariables != null)
                {
                    foreach (var env in environmentVariables)
                    {
                        cmd.EnvironmentVariables [env.Key] = env.Value;
                    }
                }

                // Explicitly propagate the PATH var to the process. It ensures that tools required
                // to run XS are also in the PATH for remote processes.
                cmd.EnvironmentVariables ["PATH"] = Environment.GetEnvironmentVariable("PATH");
                cmd.ProcessExecutionArchitecture = ProcessExecutionArchitecture;
                process = executionHandler.Execute(cmd, console);
                process.Task.ContinueWith(t => ProcessExited(), mainCancelSource.Token);
            }));
        }
Example #2
0
 Task StartRemoteProcess()
 {
     return(Task.Run(() => {
         var cmd = Runtime.ProcessService.CreateCommand(exePath);
         cmd.Arguments = ((IPEndPoint)listener.LocalEndpoint).Port + " " + DebugMode;
         process = executionHandler.Execute(cmd, console);
         process.Task.ContinueWith(t => ProcessExited());
     }));
 }
Example #3
0
        protected override void DoExecute(IProgressMonitor monitor,
                                          ExecutionContext context)
        {
            CProjectConfiguration conf = (CProjectConfiguration)ActiveConfiguration;
            string   command           = conf.Output;
            string   args     = conf.CommandLineParameters;
            string   dir      = Path.GetFullPath(conf.OutputDirectory);
            string   platform = "Native";
            bool     pause    = conf.PauseConsoleOutput;
            IConsole console;

            if (conf.CompileTarget != CBinding.CompileTarget.Bin)
            {
                IdeApp.Services.MessageService.ShowMessage("Compile target is not an executable!");
                return;
            }

            monitor.Log.WriteLine("Running project...");

            if (conf.ExternalConsole)
            {
                console = context.ExternalConsoleFactory.CreateConsole(!pause);
            }
            else
            {
                console = context.ConsoleFactory.CreateConsole(!pause);
            }

            AggregatedOperationMonitor operationMonitor = new AggregatedOperationMonitor(monitor);

            try {
                IExecutionHandler handler = context.ExecutionHandlerFactory.CreateExecutionHandler(platform);

                if (handler == null)
                {
                    monitor.ReportError("Cannot execute \"" + command + "\". The selected execution mode is not supported in the " + platform + " platform.", null);
                    return;
                }

                IProcessAsyncOperation op = handler.Execute(Path.Combine(dir, command), args, dir, console);

                operationMonitor.AddOperation(op);
                op.WaitForCompleted();

                monitor.Log.WriteLine("The operation exited with code: {0}", op.ExitCode);
            } catch (Exception ex) {
                monitor.ReportError("Cannot execute \"" + command + "\"", ex);
            } finally {
                operationMonitor.Dispose();
                console.Dispose();
            }
        }
Example #4
0
        public void Start()
        {
            lock (this)
            {
                if (starting)
                {
                    return;
                }
                starting = true;
                exitRequestEvent.Reset();

                RemotingService.RegisterRemotingChannel();

                BinaryFormatter bf   = new BinaryFormatter();
                ObjRef          oref = RemotingServices.Marshal(this);
                MemoryStream    ms   = new MemoryStream();
                bf.Serialize(ms, oref);
                string sref    = Convert.ToBase64String(ms.ToArray());
                string tmpFile = null;

                if (executionHandlerFactory == null)
                {
                    executionHandlerFactory = Runtime.SystemAssemblyService.CurrentRuntime.GetExecutionHandler();
                }

                try {
                    string location = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
                    location = Path.Combine(location, "mdhost.exe");

                    ProcessHostConsole cons = new ProcessHostConsole();
                    tmpFile = Path.GetTempFileName();
                    File.WriteAllText(tmpFile, sref + "\n" + Process.GetCurrentProcess().Id + "\n");
                    string arguments           = string.Format("{0} \"{1}\"", id, tmpFile);
                    DotNetExecutionCommand cmd = new DotNetExecutionCommand(location, arguments, AppDomain.CurrentDomain.BaseDirectory);
                    cmd.DebugMode = isDebugMode;
                    process       = executionHandlerFactory.Execute(cmd, cons);
                    Counters.ExternalHostProcesses++;

                    process.Completed += ProcessExited;
                } catch (Exception ex) {
                    if (tmpFile != null)
                    {
                        try {
                            File.Delete(tmpFile);
                        } catch {
                        }
                    }
                    LoggingService.LogError(ex.ToString());
                    throw;
                }
            }
        }
        Task StartRemoteProcess()
        {
            return(Task.Run(() => {
                var cmd = Runtime.ProcessService.CreateCommand(exePath);
                cmd.Arguments = ((IPEndPoint)listener.LocalEndpoint).Port + " " + DebugMode;

                // Explicitly propagate the PATH var to the process. It ensures that tools required
                // to run XS are also in the PATH for remote processes.
                cmd.EnvironmentVariables ["PATH"] = Environment.GetEnvironmentVariable("PATH");

                process = executionHandler.Execute(cmd, console);
                process.Task.ContinueWith(t => ProcessExited());
            }));
        }
        public static IAsyncOperation ProfileProcess(IProfiler profiler, Process process)
        {
            if (IdeApp.ProjectOperations.CurrentRunOperation != null &&
                !IdeApp.ProjectOperations.CurrentRunOperation.IsCompleted)
            {
                return(IdeApp.ProjectOperations.CurrentRunOperation);
            }

            SwitchWorkbenchContext(ProfileWorkbenchContext);

            string                 workingDir = ProfilingService.GetProcessDirectory(process.Id);
            IExecutionHandler      handler    = profiler.GetProcessExecutionHandlerFactory(process);
            DotNetExecutionCommand cmd        = new DotNetExecutionCommand();

            cmd.WorkingDirectory = workingDir;
            return(handler.Execute(cmd, null /*context.ConsoleFactory.CreateConsole (true)*/));
        }
Example #7
0
        public void Start(IList <string> userAssemblyPaths = null)
        {
            lock (this) {
                if (starting)
                {
                    return;
                }
                starting = true;
                exitRequestEvent.Reset();

                RemotingService.RegisterRemotingChannel();

                BinaryFormatter bf   = new BinaryFormatter();
                ObjRef          oref = RemotingServices.Marshal(this);
                MemoryStream    ms   = new MemoryStream();
                bf.Serialize(ms, oref);
                string sref    = Convert.ToBase64String(ms.ToArray());
                string tmpFile = null;

                if (executionHandlerFactory == null)
                {
                    executionHandlerFactory = Runtime.SystemAssemblyService.CurrentRuntime.GetExecutionHandler();
                }

                try {
                    string location = Path.GetDirectoryName(System.Reflection.Assembly.GetExecutingAssembly().Location);
                    location = Path.Combine(location, "mdhost.exe");

                    tmpFile = Path.GetTempFileName();
                    StreamWriter sw = new StreamWriter(tmpFile);
                    sw.WriteLine(sref);
                    sw.WriteLine(Process.GetCurrentProcess().Id);
                    sw.WriteLine(Runtime.SystemAssemblyService.CurrentRuntime.RuntimeId);

                    // Explicitly load Mono.Addins since the target runtime may not have it installed
                    sw.WriteLine(2);
                    sw.WriteLine(typeof(AddinManager).Assembly.Location);
                    sw.WriteLine(typeof(Mono.Addins.Setup.SetupService).Assembly.Location);
                    sw.Close();

                    string arguments           = string.Format("{0} \"{1}\"", id, tmpFile);
                    DotNetExecutionCommand cmd = new DotNetExecutionCommand(location, arguments, AppDomain.CurrentDomain.BaseDirectory);
                    if (userAssemblyPaths != null)
                    {
                        cmd.UserAssemblyPaths = userAssemblyPaths;
                    }
                    cmd.DebugMode = isDebugMode;
                    ProcessHostConsole cons = new ProcessHostConsole();
                    process = executionHandlerFactory.Execute(cmd, cons);
                    Counters.ExternalHostProcesses++;

                    process.Completed += ProcessExited;
                } catch (Exception ex) {
                    if (tmpFile != null)
                    {
                        try {
                            File.Delete(tmpFile);
                        } catch {
                        }
                    }
                    LoggingService.LogError(ex.ToString());
                    throw;
                }
            }
        }
        public ProcessAsyncOperation Execute(ExecutionCommand command, OperationConsole console)
        {
            IExecutionHandler handler = Runtime.ProcessService.GetDefaultExecutionHandler(command);

            return(handler.Execute(command, console));
        }