private PythonRpc(IProcessServices procServices, IProcess process) : base(process.StandardInput.BaseStream, process.StandardOutput.BaseStream)
{
_procServices = procServices;
_process = process;
Disconnected += PythonRpc_Disconnected;
StartListening();
}
public PreviewWordCommand(
ITextView textView,
IRInteractiveWorkflowProvider workflowProvider,
IApplicationShell appShell,
IProcessServices pss,
IFileSystem fs) :
base(textView, (int)MdPackageCommandId.icmdPreviewWord, workflowProvider, appShell, pss, fs) { }
public WebBrowserServices(ICoreShell coreShell)
{
_coreShell = coreShell;
_wbs = _coreShell.GetService <IVsWebBrowsingService>(typeof(SVsWebBrowsingService));
_ps = _coreShell.Process();
_settings = _coreShell.GetService <IRToolsSettings>();
}
public PreviewPdfCommand(
ITextView textView,
IRInteractiveWorkflowProvider workflowProvider,
ICoreShell coreShell,
IProcessServices pss,
IFileSystem fs)
: base(textView, (int)MdPackageCommandId.icmdPreviewPdf, workflowProvider, coreShell, pss, fs)
{
}
public PreviewWordCommand(
ITextView textView,
IRInteractiveWorkflowProvider workflowProvider,
IApplicationShell appShell,
IProcessServices pss,
IFileSystem fs) :
base(textView, (int)MdPackageCommandId.icmdPreviewWord, workflowProvider, appShell, pss, fs)
{
}
public RemoteBrokerProcess(string name, string logFolder, IFileSystem fileSystem, IRInstallationService installations, IProcessServices processServices)
{
_name = name;
_logFolder = logFolder;
_fileSystem = fileSystem;
_installations = installations;
_processServices = processServices;
_rhostDirectory = Path.GetDirectoryName(typeof(RHost).Assembly.GetAssemblyPath());
Password = Guid.NewGuid().ToString();
}
public PreviewHtmlCommand(
ITextView textView,
IRInteractiveWorkflowProvider workflowProvider,
IApplicationShell appShell,
IProcessServices pss,
IFileSystem fs,
IWebBrowserServices wbs)
: base(textView, (int)MdPackageCommandId.icmdPreviewHtml,
workflowProvider, appShell, pss, fs) {
_wbs = wbs;
}
private static IProcess CreateRunAsUserProcess(IProcessServices ps, bool quietMode)
{
var psi = new ProcessStartInfo {
FileName = PathConstants.RunAsUserBinPath,
Arguments = quietMode ? "-q" : "",
RedirectStandardError = true,
RedirectStandardInput = true,
RedirectStandardOutput = true
};
return(ps.Start(psi));
}
private static Process CreateRunAsUserProcess(IProcessServices ps, bool quietMode)
{
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = PathConstants.RunAsUserBinPath;
psi.Arguments = quietMode ? "-q" : "";
psi.RedirectStandardError = true;
psi.RedirectStandardInput = true;
psi.RedirectStandardOutput = true;
return(ps.Start(psi));
}
public PreviewHtmlCommand(
ITextView textView,
IRInteractiveWorkflowProvider workflowProvider,
ICoreShell coreShell,
IProcessServices pss,
IFileSystem fs,
IWebBrowserServices wbs)
: base(textView, (int)MdPackageCommandId.icmdPreviewHtml,
workflowProvider, coreShell, pss, fs)
{
_wbs = wbs;
}
public static ICoreServices CreateSubstitute(ILoggingPermissions loggingPermissions = null, IFileSystem fs = null, IRegistry registry = null, IProcessServices ps = null) {
return new CoreServices(
Substitute.For<IApplicationConstants>(),
Substitute.For<ITelemetryService>(),
loggingPermissions,
Substitute.For<ISecurityService>(),
Substitute.For<ITaskService>(),
UIThreadHelper.Instance,
Substitute.For<IActionLog>(),
fs ?? Substitute.For<IFileSystem>(),
registry ?? Substitute.For<IRegistry>(),
ps ?? Substitute.For<IProcessServices>());
}
public static PythonRpc Create(IProcessServices procServices, string exe, params string[] args)
{
var startInfo = new ProcessStartInfo(exe, args.AsQuotedArguments())
{
UseShellExecute = false,
ErrorDialog = false,
CreateNoWindow = true,
RedirectStandardInput = true,
RedirectStandardOutput = true,
};
var process = procServices.Start(startInfo);
return(new PythonRpc(procServices, process));
}
public PreviewCommand(ITextView textView, int id,
IRInteractiveWorkflowProvider workflowProvider,
IApplicationShell appShell,
IProcessServices pss,
IFileSystem fs)
: base(textView, new CommandId[] { new CommandId(MdPackageCommandId.MdCmdSetGuid, id) }, false) {
_workflowProvider = workflowProvider;
AppShell = appShell;
_pss = pss;
_fs = fs;
IEnumerable<Lazy<IMarkdownFlavorPublishHandler>> handlers = AppShell.ExportProvider.GetExports<IMarkdownFlavorPublishHandler>();
foreach (var h in handlers) {
_flavorHandlers[h.Value.Flavor] = h.Value;
}
}
private static Process CreateRLaunchProcess(IProcessServices ps, bool authenticateOnly)
{
// usage:
// Microsoft.R.Host.RunAsUser [-q]
// -q: Quiet
const string rLaunchPath = "/usr/lib/rtvs/Microsoft.R.Host.RunAsUser";
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = rLaunchPath;
psi.Arguments = authenticateOnly ? "" : "-q";
psi.RedirectStandardError = true;
psi.RedirectStandardInput = true;
psi.RedirectStandardOutput = true;
return(ps.Start(psi));
}
protected PreviewCommand(ITextView textView, int id,
IRInteractiveWorkflowVisualProvider workflowProvider, IServiceContainer services)
: base(textView, new CommandId[] { new CommandId(MdPackageCommandId.MdCmdSetGuid, id) }, false)
{
_workflowProvider = workflowProvider;
Services = services;
_fs = services.FileSystem();
_pss = services.Process();
var exp = services.GetService <ExportProvider>();
var handlers = exp.GetExports <IMarkdownFlavorPublishHandler>();
foreach (var h in handlers)
{
_flavorHandlers[h.Value.Flavor] = h.Value;
}
}
public static IProcess RunAsCurrentUser(IProcessServices ps, string hostBinPath, string arguments, string rHomePath, string loadLibPath)
{
var psi = new ProcessStartInfo {
FileName = hostBinPath,
Arguments = arguments,
RedirectStandardError = true,
RedirectStandardInput = true,
RedirectStandardOutput = true,
WorkingDirectory = Environment.GetEnvironmentVariable("PWD")
};
// All other should be same as the broker environment. Only these are set based on interpreters.
// R_HOME is explicitly set on the R-Host.
psi.Environment.Add("R_HOME", rHomePath);
psi.Environment.Add("LD_LIBRARY_PATH", loadLibPath);
return(ps.Start(psi));
}
public static Process AuthenticateAndRunAsUser(ILogger <Session> logger, IProcessServices ps, string username, string password, string profileDir, IEnumerable <string> arguments, IDictionary <string, string> environment)
{
Process proc = CreateRLaunchProcess(ps, false);
using (BinaryWriter writer = new BinaryWriter(proc.StandardInput.BaseStream, Encoding.UTF8, true)) {
var message = new AuthenticateAndRunMessage()
{
Username = username, Password = password, Arguments = arguments, Environment = environment.Select(e => $"{e.Key}={e.Value}")
};
string json = JsonConvert.SerializeObject(message, GetJsonSettings());
var jsonBytes = Encoding.UTF8.GetBytes(json);
writer.Write(jsonBytes.Length);
writer.Write(jsonBytes);
writer.Flush();
}
return(proc);
}
public PreviewCommand(ITextView textView, int id,
IRInteractiveWorkflowProvider workflowProvider,
ICoreShell coreShell,
IProcessServices pss,
IFileSystem fs)
: base(textView, new CommandId[] { new CommandId(MdPackageCommandId.MdCmdSetGuid, id) }, false)
{
_workflowProvider = workflowProvider;
_coreShell = coreShell;
_pss = pss;
_fs = fs;
IEnumerable <Lazy <IMarkdownFlavorPublishHandler> > handlers = _coreShell.ExportProvider.GetExports <IMarkdownFlavorPublishHandler>();
foreach (var h in handlers)
{
_flavorHandlers[h.Value.Flavor] = h.Value;
}
}
private void AddBasicServices(IActionLog log = null
, ILoggingPermissions loggingPermissions = null
, IFileSystem fs = null
, IRegistry registry = null
, IProcessServices ps = null)
{
ServiceManager
.AddService(UIThreadHelper.Instance)
.AddService(log ?? Substitute.For <IActionLog>())
.AddService(new SecurityServiceStub())
.AddService(loggingPermissions ?? Substitute.For <ILoggingPermissions>())
.AddService(fs ?? new WindowsFileSystem())
.AddService(registry ?? new RegistryImpl())
.AddService(ps ?? new ProcessServices())
.AddService(new TestTaskService())
.AddService(new TestUIServices())
.AddService(new TestImageService())
.AddService(new TestPlatformServices());
}
public CoreServices(IApplicationConstants appConstants
, ITelemetryService telemetry
, ITaskService tasks
, IProcessServices processServices
, ILoggingPermissions loggingPermissions
, IMainThread mainThread
, ISecurityService security)
{
LoggingPermissions = loggingPermissions;
Telemetry = telemetry;
Security = security;
Tasks = tasks;
ProcessServices = processServices;
FileSystem = new FileSystem();
MainThread = mainThread;
Log = new Logger(appConstants.ApplicationName, Path.GetTempPath(), LoggingPermissions);
}
public CoreServices(
IApplicationConstants appConstants
, ITelemetryService telemetry
, ILoggingPermissions permissions
, ISecurityService security
, [Import(AllowDefault = true)] IActionLog log = null
, [Import(AllowDefault = true)] IFileSystem fs = null
, [Import(AllowDefault = true)] IRegistry registry = null
, [Import(AllowDefault = true)] IProcessServices ps = null)
{
LoggingServices = new LoggingServices(permissions, appConstants);
_appConstants = appConstants;
_log = log;
Telemetry = telemetry;
Security = security;
ProcessServices = ps ?? new ProcessServices();
Registry = registry ?? new RegistryImpl();
FileSystem = fs ?? new FileSystem();
}
private static Process CreateRLaunchProcess(IProcessServices ps, bool authenticateOnly)
{
// usage:
// Microsoft.R.Host.RunAsUser [-q]
// -q: Quiet
const string rLaunchBinary = "Microsoft.R.Host.RunAsUser";
string brokerDir = Path.GetDirectoryName(typeof(Program).GetTypeInfo().Assembly.Location);
string rLaunchPath = Path.Combine(brokerDir, rLaunchBinary);
ProcessStartInfo psi = new ProcessStartInfo();
psi.FileName = rLaunchPath;
psi.Arguments = authenticateOnly ? "" : "-q";
psi.RedirectStandardError = true;
psi.RedirectStandardInput = true;
psi.RedirectStandardOutput = true;
return(ps.Start(psi));
}
public CoreServices(ITelemetryService telemetry
, ILoggingPermissions permissions
, ISecurityService security
, ITaskService tasks
, IMainThread mainThread
, IActionLog log
, IFileSystem fs
, IProcessServices ps)
{
LoggingPermissions = permissions;
Log = log;
Telemetry = telemetry;
Security = security;
Tasks = tasks;
Process = ps;
FileSystem = fs;
MainThread = mainThread;
}
public static async Task OpenDataCsvApp(IREvaluationResultInfo result, IApplicationShell appShell, IFileSystem fileSystem, IProcessServices processServices) {
await appShell.SwitchToMainThreadAsync();
if (Interlocked.Exchange(ref _busy, 1) > 0) {
return;
}
var workflow = appShell.ExportProvider.GetExportedValue<IRInteractiveWorkflowProvider>().GetOrCreate();
var session = workflow.RSession;
var folder = GetTempCsvFilesFolder();
if (!Directory.Exists(folder)) {
Directory.CreateDirectory(folder);
}
var pss = appShell.ExportProvider.GetExportedValue<IProjectSystemServices>();
var variableName = result.Name ?? _variableNameReplacement;
var csvFileName = MakeCsvFileName(appShell, pss, variableName);
var file = pss.GetUniqueFileName(folder, csvFileName, "csv", appendUnderscore: true);
string currentStatusText;
var statusBar = appShell.GetGlobalService<IVsStatusbar>(typeof(SVsStatusbar));
statusBar.GetText(out currentStatusText);
try {
statusBar.SetText(Resources.Status_WritingCSV);
appShell.ProgressDialog.Show(async (p, ct) => await CreateCsvAndStartProcess(result, session, file, fileSystem, p, ct), Resources.Status_WritingCSV, 100, 500);
if (fileSystem.FileExists(file)) {
processServices.Start(file);
}
} catch (Exception ex) when (ex is Win32Exception || ex is IOException || ex is UnauthorizedAccessException) {
appShell.ShowErrorMessage(string.Format(CultureInfo.InvariantCulture, Resources.Error_CannotOpenCsv, ex.Message));
} finally {
statusBar.SetText(currentStatusText);
}
Interlocked.Exchange(ref _busy, 0);
}
public CoreServices(IApplicationConstants appConstants
, ITelemetryService telemetry
, ILoggingPermissions permissions
, ISecurityService security
, ITaskService tasks
, IMainThread mainThread
, IActionLog log
, IFileSystem fs
, IRegistry registry
, IProcessServices ps) {
LoggingServices = new LoggingServices(permissions, appConstants);
Log = log;
Telemetry = telemetry;
Security = security;
Tasks = tasks;
ProcessServices = ps;
Registry = registry;
FileSystem = fs;
MainThread = mainThread;
}
private void AddBasicServices(IActionLog log = null
, ILoggingPermissions loggingPermissions = null
, IFileSystem fs = null
, IRegistry registry = null
, IProcessServices ps = null)
{
ServiceManager
.AddService(this)
.AddService(UIThreadHelper.Instance.MainThread)
.AddService(log ?? Substitute.For <IActionLog>())
.AddService(new SecurityServiceStub())
.AddService(loggingPermissions ?? Substitute.For <ILoggingPermissions>())
.AddService(fs ?? new WindowsFileSystem())
.AddService <IOutputService, TestOutputService>()
.AddService(registry ?? new RegistryImpl())
.AddService(ps ?? new WindowsProcessServices())
.AddService(UIThreadHelper.Instance.TaskService)
.AddService(new TestUIServices(UIThreadHelper.Instance.ProgressDialog))
.AddService(new TestImageService())
.AddService(new TestPlatformServices())
.AddService(new TestApplication())
.AddService(new TestIdleTimeService());
}
public static async Task OpenDataCsvApp(IREvaluationResultInfo result, ICoreShell shell, IFileSystem fileSystem, IProcessServices processServices)
{
await shell.SwitchToMainThreadAsync();
if (Interlocked.Exchange(ref _busy, 1) > 0)
{
return;
}
var workflow = shell.GetService <IRInteractiveWorkflowProvider>().GetOrCreate();
var session = workflow.RSession;
var folder = GetTempCsvFilesFolder();
if (!Directory.Exists(folder))
{
Directory.CreateDirectory(folder);
}
var pss = shell.GetService <IProjectSystemServices>();
var variableName = result.Name ?? _variableNameReplacement;
var csvFileName = MakeCsvFileName(shell, pss, variableName);
var file = pss.GetUniqueFileName(folder, csvFileName, "csv", appendUnderscore: true);
string currentStatusText;
var statusBar = shell.GetService <IVsStatusbar>(typeof(SVsStatusbar));
statusBar.GetText(out currentStatusText);
try {
statusBar.SetText(Resources.Status_WritingCSV);
shell.ProgressDialog().Show(async(p, ct) => await CreateCsvAndStartProcess(result, session, shell, file, fileSystem, p, ct), Resources.Status_WritingCSV, 100, 500);
if (fileSystem.FileExists(file))
{
processServices.Start(file);
}
} catch (Exception ex) when(ex is Win32Exception || ex is IOException || ex is UnauthorizedAccessException)
{
shell.ShowErrorMessage(string.Format(CultureInfo.InvariantCulture, Resources.Error_CannotOpenCsv, ex.Message));
} finally {
statusBar.SetText(currentStatusText);
}
Interlocked.Exchange(ref _busy, 0);
}
public UnixRHostProcessService(ILogger <Session> sessionLogger, IProcessServices ps)
{
_sessionLogger = sessionLogger;
_ps = ps;
}
public PlatformProcess(IProcessServices ps, Process process)
{
_ps = ps;
_process = process;
}
public static ICoreServices CreateSubstitute(ILoggingPermissions loggingPermissions = null, IFileSystem fs = null, IRegistry registry = null, IProcessServices ps = null)
{
return(new CoreServices(
Substitute.For <ITelemetryService>(),
loggingPermissions,
Substitute.For <ISecurityService>(),
Substitute.For <ITaskService>(),
UIThreadHelper.Instance,
Substitute.For <IActionLog>(),
fs ?? Substitute.For <IFileSystem>(),
registry ?? Substitute.For <IRegistry>(),
ps ?? Substitute.For <IProcessServices>()));
}
public ReportIssueCommand(ICoreServices services)
: base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdReportIssue)
{
_permissions = services.LoggingPermissions;
_pss = services.ProcessServices;
}
public LinuxSystemInfoService(ILogger <ISystemInfoService> logger, IFileSystem fs, IProcessServices ps)
{
_logger = logger;
_fs = fs;
_ps = ps;
}
public static bool AuthenticateUser(ILogger <IAuthenticationService> logger, IProcessServices ps, string username, string password, string allowedGroup, out string profileDir)
{
bool retval = false;
Process proc = null;
string userDir = string.Empty;
try {
proc = CreateRunAsUserProcess(ps, false);
using (BinaryWriter writer = new BinaryWriter(proc.StandardInput.BaseStream, Encoding.UTF8, true))
using (BinaryReader reader = new BinaryReader(proc.StandardOutput.BaseStream, Encoding.UTF8, true)) {
var message = new AuthenticationOnlyMessage()
{
Username = GetUnixUserName(username), Password = password, AllowedGroup = allowedGroup
};
string json = JsonConvert.SerializeObject(message, GetJsonSettings());
var jsonBytes = Encoding.UTF8.GetBytes(json);
writer.Write(jsonBytes.Length);
writer.Write(jsonBytes);
writer.Flush();
proc.WaitForExit(3000);
if (proc.HasExited && proc.ExitCode == 0)
{
int size = reader.ReadInt32();
var bytes = reader.ReadBytes(size);
var arr = JsonConvert.DeserializeObject <JArray>(Encoding.UTF8.GetString(bytes));
if (arr.Count > 1)
{
var respType = arr[0].Value <string>();
switch (respType)
{
case PamInfo:
case PamError:
var pam = arr[1].Value <string>();
logger.LogCritical(Resources.Error_PAMAuthenticationError.FormatInvariant(pam));
break;
case JsonError:
var jerror = arr[1].Value <string>();
logger.LogCritical(Resources.Error_RunAsUserJsonError.FormatInvariant(jerror));
break;
case RtvsResult:
userDir = arr[1].Value <string>();
retval = true;
if (userDir.Length == 0)
{
logger.LogError(Resources.Error_NoProfileDir);
}
break;
case RtvsError:
var resource = arr[1].Value <string>();
logger.LogCritical(Resources.Error_RunAsUserFailed.FormatInvariant(Resources.ResourceManager.GetString(resource)));
break;
}
}
else
{
logger.LogCritical(Resources.Error_InvalidRunAsUserResponse);
}
}
else
{
logger.LogCritical(Resources.Error_AuthFailed, GetRLaunchExitCodeMessage(proc.ExitCode));
}
}
} catch (Exception ex) {
logger.LogCritical(Resources.Error_AuthFailed, ex.Message);
} finally {
if (proc != null && !proc.HasExited)
{
try {
proc.Kill();
} catch (Exception ex) when(!ex.IsCriticalException())
{
}
}
}
profileDir = userDir;
return(retval);
}
public CommandPromptCommand(int id, IProcessServices ps) {
_commandId = id;
_ps = ps;
}
/// <summary>
/// Gets the set of search paths by running the interpreter.
/// </summary>
/// <param name="interpreter">Path to the interpreter.</param>
/// <param name="fs">File system services.</param>
/// <param name="ps">Process services.</param>
/// <param name="cancellationToken">Cancellation token.</param>
/// <returns>A list of search paths for the interpreter.</returns>
public static async Task <List <PythonLibraryPath> > GetSearchPathsFromInterpreterAsync(string interpreter, IFileSystem fs, IProcessServices ps, CancellationToken cancellationToken = default)
{
// sys.path will include the working directory, so we make an empty
// path that we can filter out later
var tempWorkingDir = IOPath.Combine(IOPath.GetTempPath(), IOPath.GetRandomFileName());
fs.CreateDirectory(tempWorkingDir);
if (!InstallPath.TryGetFile("get_search_paths.py", out var srcGetSearchPaths))
{
return(new List <PythonLibraryPath>());
}
var getSearchPaths = IOPath.Combine(tempWorkingDir, PathUtils.GetFileName(srcGetSearchPaths));
File.Copy(srcGetSearchPaths, getSearchPaths);
var startInfo = new ProcessStartInfo(
interpreter,
new[] { "-S", "-E", getSearchPaths }.AsQuotedArguments()
)
{
WorkingDirectory = tempWorkingDir,
UseShellExecute = false,
ErrorDialog = false,
CreateNoWindow = true,
RedirectStandardInput = true,
RedirectStandardOutput = true
};
try {
var output = await ps.ExecuteAndCaptureOutputAsync(startInfo, cancellationToken);
return(output.Split(new[] { Environment.NewLine }, StringSplitOptions.RemoveEmptyEntries).Select(s => {
try {
var p = Parse(s);
if (PathUtils.PathStartsWith(p.Path, tempWorkingDir))
{
return null;
}
return p;
} catch (ArgumentException) {
Debug.Fail("Invalid search path: " + (s ?? "<null>"));
return null;
} catch (FormatException) {
Debug.Fail("Invalid format for search path: " + s);
return null;
}
}).Where(p => p != null).ToList());
} finally {
fs.DeleteDirectory(tempWorkingDir, true);
}
}
/// <summary>
/// Gets the set of search paths for the specified factory.
/// </summary>
public static async Task <IList <PythonLibraryPath> > GetSearchPathsAsync(InterpreterConfiguration config, IFileSystem fs, IProcessServices ps, CancellationToken cancellationToken = default)
{
for (int retries = 5; retries > 0; --retries)
{
try {
return(await GetSearchPathsFromInterpreterAsync(config.InterpreterPath, fs, ps, cancellationToken));
} catch (InvalidOperationException) {
// Failed to get paths
break;
} catch (Exception e) when(e is IOException || e is UnauthorizedAccessException)
{
// Failed to get paths due to IO exception - sleep and then loop
Thread.Sleep(50);
}
}
var ospy = PathUtils.FindFile(fs, config.LibraryPath, "os.py");
var standardLibraryPath = !string.IsNullOrEmpty(ospy) ? IOPath.GetDirectoryName(ospy) : string.Empty;
if (!string.IsNullOrEmpty(standardLibraryPath))
{
return(GetDefaultSearchPaths(fs, standardLibraryPath));
}
return(Array.Empty <PythonLibraryPath>());
}
public WebBrowserServices(IVsWebBrowsingService wbs, IProcessServices ps, IRToolsSettings settings) {
_wbs = wbs;
_ps = ps;
_settings = settings;
}
public OpenContainingFolderCommand(UnconfiguredProject unconfiguredProject, [Import(AllowDefault = true)] IProcessServices ps) {
_unconfiguredProject = unconfiguredProject;
_ps = ps ?? new ProcessServices();
}
public OpenContainingFolderCommand(UnconfiguredProject unconfiguredProject, [Import(AllowDefault = true)] IProcessServices ps)
{
_unconfiguredProject = unconfiguredProject;
_ps = ps ?? new ProcessServices();
}
public ReportIssueCommand(ICoreServices services)
: base(RGuidList.RCmdSetGuid, RPackageCommandId.icmdReportIssue) {
_permissions = services.LoggingServices.Permissions;
_pss = services.ProcessServices;
}