/// <summary> /// Retrieves path to the latest (highest version) R installation /// from registry. Typically in the form 'Program Files\R\R-3.2.1' /// Selects highest from compatible versions, not just the highest. /// </summary> public static string GetCompatibleEnginePathFromRegistry(ISupportedRVersionRange svl = null) { svl = svl ?? new SupportedRVersionRange(); string[] installedEngines = GetInstalledEngineVersionsFromRegistry(); string highestVersionName = String.Empty; Version highest = null; foreach (string name in installedEngines) { // Protect from random key name format changes if (!String.IsNullOrEmpty(name)) { string versionString = ExtractVersionString(name); Version v; if (Version.TryParse(versionString, out v) && svl.IsCompatibleVersion(v)) { if (highest != null) { if (v > highest) { highest = v; highestVersionName = name; } } else { highest = v; highestVersionName = name; } } } } return(GetRVersionInstallPathFromRegistry(highestVersionName)); }
private static string TryFindRInProgramFiles(string folder, ISupportedRVersionRange supportedVersions) { string root = Path.GetPathRoot(Environment.GetFolderPath(Environment.SpecialFolder.ProgramFiles)); string baseRFolder = Path.Combine(root + @"Program Files\", folder); List <Version> versions = new List <Version>(); try { IEnumerable <IFileSystemInfo> directories = FileSystem.GetDirectoryInfo(baseRFolder) .EnumerateFileSystemInfos() .Where(x => (x.Attributes & FileAttributes.Directory) != 0); foreach (IFileSystemInfo fsi in directories) { string subFolderName = fsi.FullName.Substring(baseRFolder.Length + 1); Version v = GetRVersionFromFolderName(subFolderName); if (supportedVersions.IsCompatibleVersion(v)) { versions.Add(v); } } } catch (IOException) { // Don't do anything if there is no RRO installed } if (versions.Count > 0) { versions.Sort(); Version highest = versions[versions.Count - 1]; return(Path.Combine(baseRFolder, String.Format(CultureInfo.InvariantCulture, "R-{0}.{1}.{2}", highest.Major, highest.Minor, highest.Build))); } return(string.Empty); }
/// <summary> /// Retrieves path to the installed R engine root folder. /// First tries user settings, then 64-bit registry. /// </summary> public static string GetRInstallPath(string basePath, ISupportedRVersionRange svl = null, ICoreShell coreShell = null) { svl = svl ?? new SupportedRVersionRange(); // First check if Microsoft R Client was just installed. var rClientPath = GetRClientPath(); if (!string.IsNullOrEmpty(rClientPath) && AskUserSwitchToRClient()) { // Get R Client path if (MessageButtons.Yes == coreShell.ShowMessage(Resources.Prompt_MsRClientJustInstalled, MessageButtons.YesNo)) { return(GetRClientPath()); } } if (string.IsNullOrEmpty(basePath) || !FileSystem.DirectoryExists(basePath)) { basePath = GetRPathFromMRS(); if (string.IsNullOrEmpty(basePath)) { basePath = GetCompatibleEnginePathFromRegistry(svl); } } return(basePath); }
public IEnumerable <IRInterpreterInfo> GetCompatibleEngines(ISupportedRVersionRange svl = null) { var interpreters = new List <IRInterpreterInfo>(); interpreters.AddRange(GetInstalledCranR(svl)); return(interpreters); }
public IEnumerable <IRInterpreterInfo> GetCompatibleEngines(ISupportedRVersionRange svl = null) { var packagesInfo = InstalledPackageInfo.GetPackages(_fileSystem); var interpreters = new List <IRInterpreterInfo>(); interpreters.AddRange(GetInstalledMRO(packagesInfo, svl)); interpreters.AddRange(GetInstalledCranR(packagesInfo, svl)); return(interpreters); }
/// <summary> /// Determines if given version falls into the supported range. /// </summary> /// <param name="v"></param> /// <returns></returns> public static bool IsCompatibleVersion(this ISupportedRVersionRange svr, Version v) { var minVersion = new Version(svr.MinMajorVersion, svr.MinMinorVersion); var maxVersion = new Version(svr.MaxMajorVersion, svr.MaxMinorVersion); var verMajorMinor = new Version(v.Major, v.Minor); return(verMajorMinor >= minVersion && verMajorMinor <= maxVersion); }
/// <summary> /// Retrieves path to the all compatible R installations from registry. /// </summary> private IEnumerable<IRInterpreterInfo> GetCompatibleEnginesFromRegistry(ISupportedRVersionRange svr) { svr = svr ?? new SupportedRVersionRange(); var engines = GetInstalledEnginesFromRegistry().Where(e => svr.IsCompatibleVersion(e.Version)); // Remove duplicates (MRC registers under multiple keys) var mrc = engines.FirstOrDefault(e => e.Name.Contains("Microsoft")); if(mrc != null) { var dupes = engines.Where(e => e.InstallPath.EqualsIgnoreCase(mrc.InstallPath)).Except(new IRInterpreterInfo[] { mrc }); engines = engines.Except(dupes); } return engines; }
/// <summary> /// Retrieves path to the installed R engine binaries folder. /// R version is retrieved from settings or, af none is set, /// highest version is retrieved from registry. /// </summary> public static string GetBinariesFolder(string basePath, ISupportedRVersionRange svl, ICoreShell coreShell = null) { string binFolder = null; string installPath = RInstallation.GetRInstallPath(basePath, svl, coreShell); if (!String.IsNullOrEmpty(installPath)) { binFolder = Path.Combine(installPath, @"bin\x64"); } return(binFolder); }
/// <summary> /// Retrieves path to the all compatible R installations from registry. /// </summary> private IEnumerable <IRInterpreterInfo> GetCompatibleEnginesFromRegistry(ISupportedRVersionRange svr) { svr = svr ?? new SupportedRVersionRange(); var engines = GetInstalledEnginesFromRegistry().Where(e => svr.IsCompatibleVersion(e.Version)); // Among duplicates by path take the highest version return (from e in engines group e by e.InstallPath.TrimTrailingSlash() into g select g.OrderByDescending(e => e.Version).First()); }
private IEnumerable <IRInterpreterInfo> GetInstalledCranR(ISupportedRVersionRange svl) { var rFrameworkPath = Path.Combine("/Library/Frameworks/R.framework/Versions"); foreach (var path in _fileSystem.GetDirectories(rFrameworkPath)) { var version = VersionFromPath(path, out var versionString); if (version != null && svl.IsCompatibleVersion(version)) { yield return(new RMacInterpreterInfo("R " + versionString, versionString, version, _fileSystem)); } } }
/// <summary> /// Retrieves path to the installed R engine root folder. /// First tries user settings, then 64-bit registry. /// </summary> public static string GetRInstallPath(string basePath, ISupportedRVersionRange svl = null) { svl = svl ?? new SupportedRVersionRange(); if (string.IsNullOrEmpty(basePath) || !FileSystem.DirectoryExists(basePath)) { basePath = GetRPathFromMRS(); if (string.IsNullOrEmpty(basePath)) { basePath = GetCompatibleEnginePathFromRegistry(svl); } } return(basePath); }
/// <summary> /// Retrieves path to the all compatible R installations from registry. /// </summary> private IEnumerable <IRInterpreterInfo> GetCompatibleEnginesFromRegistry(ISupportedRVersionRange svr) { svr = svr ?? new SupportedRVersionRange(); var engines = GetInstalledEnginesFromRegistry().Where(e => svr.IsCompatibleVersion(e.Version)); // Remove duplicates (MRC registers under multiple keys) var mrc = engines.FirstOrDefault(e => e.Name.Contains("Microsoft")); if (mrc != null) { var dupes = engines.Where(e => e.InstallPath.EqualsIgnoreCase(mrc.InstallPath)).Except(new IRInterpreterInfo[] { mrc }); engines = engines.Except(dupes); } return(engines); }
public bool VerifyInstallation(ISupportedRVersionRange svr = null, IServiceContainer services = null) { var ui = services?.GetService <IUIService>(); if (_isValid.HasValue) { return(_isValid.Value); } _isValid = false; svr = svr ?? new SupportedRVersionRange(); // Normalize path so it points to R root and not to bin or bin\x64 string rDllPath = Path.Combine(BinPath, "R.dll"); string rGraphAppPath = Path.Combine(BinPath, "Rgraphapp.dll"); string rTermPath = Path.Combine(BinPath, "RTerm.exe"); string rScriptPath = Path.Combine(BinPath, "RScript.exe"); string rGuiPath = Path.Combine(BinPath, "RGui.exe"); try { if (_fileSystem.FileExists(rDllPath) && _fileSystem.FileExists(rTermPath) && _fileSystem.FileExists(rScriptPath) && _fileSystem.FileExists(rGraphAppPath) && _fileSystem.FileExists(rGuiPath)) { var fileVersion = GetRVersionFromBinary(_fileSystem, rDllPath); _isValid = IsSameVersion(fileVersion, Version) && svr.IsCompatibleVersion(Version); if (!_isValid.Value) { ui?.ShowMessage( string.Format(CultureInfo.InvariantCulture, Resources.Error_UnsupportedRVersion, Version.Major, Version.Minor, Version.Build, svr.MinMajorVersion, svr.MinMinorVersion, "*", svr.MaxMajorVersion, svr.MaxMinorVersion, "*"), MessageButtons.OK); } } else { ui?.ShowMessage(string.Format(CultureInfo.InvariantCulture, Resources.Error_CannotFindRBinariesFormat, InstallPath), MessageButtons.OK); } } catch (Exception ex) when(ex is IOException || ex is ArgumentException || ex is UnauthorizedAccessException) { ui?.ShowErrorMessage( string.Format(CultureInfo.InvariantCulture, Resources.Error_ExceptionAccessingPath, InstallPath, ex.Message)); } return(_isValid.Value); }
public bool VerifyInstallation(ISupportedRVersionRange svr = null, IServiceContainer services = null) { var ui = services?.GetService <IUIService>(); if (_isValid.HasValue) { return(_isValid.Value); } _isValid = false; svr = svr ?? new SupportedRVersionRange(); string libRPath = Path.Combine(BinPath, "libR.so"); try { if (_fileSystem.DirectoryExists(InstallPath) && _fileSystem.DirectoryExists(BinPath) && _fileSystem.FileExists(libRPath)) { if (Version != null) { _isValid = svr.IsCompatibleVersion(Version); if (!_isValid.Value) { ui?.ShowMessage( Resources.Error_UnsupportedRVersion.FormatInvariant( Version.Major, Version.Minor, Version.Build, svr.MinMajorVersion, svr.MinMinorVersion, "*", svr.MaxMajorVersion, svr.MaxMinorVersion, "*"), MessageButtons.OK); } } else { // In linux there is no direct way to get version from binary. So assume valid version for a user provided // interpreter path. _isValid = true; } } else { ui?.ShowMessage(Resources.Error_CannotFindRBinariesFormat.FormatInvariant(InstallPath), MessageButtons.OK); } } catch (Exception ex) when(ex is IOException || ex is ArgumentException || ex is UnauthorizedAccessException) { ui?.ShowErrorMessage(Resources.Error_ExceptionAccessingPath.FormatInvariant(InstallPath, ex.Message)); } return(_isValid.Value); }
/// <summary> /// Retrieves path to the latest (highest version) R installation /// from registry. Typically in the form 'Program Files\R\R-3.2.1' /// Selects highest from compatible versions, not just the highest. /// </summary> public IEnumerable <IRInterpreterInfo> GetCompatibleEngines(ISupportedRVersionRange svl = null) { var list = new List <IRInterpreterInfo>(); // Get MRC from SQL var mrc = SqlRClientInstallation.GetMicrosoftRClientInfo(_registry, _fileSystem); if (mrc != null) { list.Add(mrc); } var engines = GetCompatibleEnginesFromRegistry(svl); engines = engines.Where(e => e.VerifyInstallation(svl, _fileSystem)) .OrderBy(e => e.Version); if (mrc == null) { // If MRC didn't come with SQL, try finding one in the R engines mrc = engines.FirstOrDefault(e => e.Name.Contains("Microsoft R")); if (mrc != null) { list.Add(mrc); } } if (mrc != null) { // Remove MRC and its duplicates engines = engines.Where(e => !e.InstallPath.PathEquals(mrc.InstallPath)); } list.AddRange(engines); if (list.Count == 0) { var e = TryFindRInProgramFiles(svl); if (e != null) { list.Add(e); } } return(list); }
private IRInterpreterInfo TryFindRInProgramFiles(ISupportedRVersionRange supportedVersions) { // Force 64-bit PF var programFiles = Environment.GetEnvironmentVariable("ProgramW6432"); var baseRFolder = Path.Combine(programFiles, @"R"); var versions = new List <Version>(); try { if (_fileSystem.DirectoryExists(baseRFolder)) { IEnumerable <IFileSystemInfo> directories = _fileSystem.GetDirectoryInfo(baseRFolder) .EnumerateFileSystemInfos() .Where(x => (x.Attributes & FileAttributes.Directory) != 0); foreach (IFileSystemInfo fsi in directories) { string subFolderName = fsi.FullName.Substring(baseRFolder.Length + 1); Version v = GetRVersionFromFolderName(subFolderName); if (supportedVersions.IsCompatibleVersion(v)) { versions.Add(v); } } } } catch (IOException) { // Don't do anything if there is no RRO installed } if (versions.Count > 0) { versions.Sort(); Version highest = versions[versions.Count - 1]; var name = string.Format(CultureInfo.InvariantCulture, "R-{0}.{1}.{2}", highest.Major, highest.Minor, highest.Build); var path = Path.Combine(baseRFolder, name); var ri = CreateInfo(name, path); if (ri.VerifyInstallation(supportedVersions)) { return(ri); } } return(null); }
public static bool VerifyRIsInstalled(ICoreShell coreShell, ISupportedRVersionRange svl, string path, bool showErrors = true) { svl = svl ?? new SupportedRVersionRange(); var data = RInstallation.GetInstallationData(path, svl, coreShell); if (data.Status == RInstallStatus.OK) { return(true); } if (showErrors) { if (ShowMessage(coreShell, data, svl) == MessageButtons.Yes) { var installer = coreShell.ExportProvider.GetExportedValue <IMicrosoftRClientInstaller>(); installer.LaunchRClientSetup(coreShell); } } return(false); }
public IEnumerable <IRInterpreterInfo> GetCompatibleEngines(ISupportedRVersionRange svl = null) { var list = new List <IRInterpreterInfo>(); var engines = GetCompatibleEnginesFromRegistry(svl); engines = engines.Where(e => e.VerifyInstallation(svl)) .OrderBy(e => e.Version); list.AddRange(engines); if (list.Count == 0) { var e = TryFindRInProgramFiles(svl); if (e != null) { list.Add(e); } } return(list); }
public bool VerifyInstallation(ISupportedRVersionRange svr = null, IFileSystem fs = null, ICoreShell coreShell = null) { if (_isValid.HasValue) { return _isValid.Value; } _isValid = false; svr = svr ?? new SupportedRVersionRange(); fs = fs ?? new FileSystem(); // Normalize path so it points to R root and not to bin or bin\x64 string rDllPath = Path.Combine(BinPath, "R.dll"); string rGraphAppPath = Path.Combine(BinPath, "Rgraphapp.dll"); string rTermPath = Path.Combine(BinPath, "RTerm.exe"); string rScriptPath = Path.Combine(BinPath, "RScript.exe"); string rGuiPath = Path.Combine(BinPath, "RGui.exe"); try { if (fs.FileExists(rDllPath) && fs.FileExists(rTermPath) && fs.FileExists(rScriptPath) && fs.FileExists(rGraphAppPath) && fs.FileExists(rGuiPath)) { var fileVersion = GetRVersionFromBinary(fs, rDllPath); _isValid = IsSameVersion(fileVersion, Version) && svr.IsCompatibleVersion(Version); if (!_isValid.Value) { coreShell?.ShowMessage( string.Format(CultureInfo.InvariantCulture, Resources.Error_UnsupportedRVersion, Version.Major, Version.Minor, Version.Build, svr.MinMajorVersion, svr.MinMinorVersion, "*", svr.MaxMajorVersion, svr.MaxMinorVersion, "*"), MessageButtons.OK); } } else { coreShell?.ShowMessage(string.Format(CultureInfo.InvariantCulture, Resources.Error_CannotFindRBinariesFormat, InstallPath), MessageButtons.OK); } } catch (Exception ex) when (ex is IOException || ex is ArgumentException || ex is UnauthorizedAccessException) { coreShell?.ShowErrorMessage( string.Format(CultureInfo.InvariantCulture, Resources.Error_ExceptionAccessingPath, InstallPath, ex.Message)); } return _isValid.Value; }
/// <summary> /// Retrieves path to the latest (highest version) R installation /// from registry. Typically in the form 'Program Files\R\R-3.2.1' /// Selects highest from compatible versions, not just the highest. /// </summary> public IEnumerable<IRInterpreterInfo> GetCompatibleEngines(ISupportedRVersionRange svl = null) { var list = new List<IRInterpreterInfo>(); // Get MRC from SQL var mrc = SqlRClientInstallation.GetMicrosoftRClientInfo(_registry, _fileSystem); if (mrc != null) { list.Add(mrc); } var engines = GetCompatibleEnginesFromRegistry(svl); engines = engines.Where(e => e.VerifyInstallation(svl, _fileSystem)) .OrderBy(e => e.Version); if (mrc == null) { // If MRC didn't come with SQL, try finding one in the R engines mrc = engines.FirstOrDefault(e => e.Name.Contains("Microsoft R")); if (mrc != null) { list.Add(mrc); } } if (mrc != null) { // Remove MRC and its duplicates engines = engines.Where(e => !e.InstallPath.PathEquals(mrc.InstallPath)); } list.AddRange(engines); if (list.Count == 0) { var e = TryFindRInProgramFiles(svl); if (e != null) { list.Add(e); } } return list; }
private IEnumerable <IRInterpreterInfo> GetInstalledMRO(IEnumerable <InstalledPackageInfo> packagesInfo, ISupportedRVersionRange svl) { var selectedPackages = packagesInfo.Where(p => p.PackageName.StartsWithIgnoreCase("microsoft-r-open-mro") && svl.IsCompatibleVersion(p.GetVersion())); foreach (var package in selectedPackages) { yield return(RInterpreterInfo.CreateFromPackage(package, "Microsoft R Open", _fileSystem)); } }
private static MessageButtons ShowMessage(ICoreShell coreShell, RInstallData data, ISupportedRVersionRange svl) { Debug.Assert(data.Status != RInstallStatus.OK); switch (data.Status) { case RInstallStatus.UnsupportedVersion: return(coreShell.ShowMessage( string.Format(CultureInfo.InvariantCulture, Resources.Error_UnsupportedRVersion, data.Version.Major, data.Version.Minor, data.Version.Build, svl.MinMajorVersion, svl.MinMinorVersion, "*", svl.MaxMajorVersion, svl.MaxMinorVersion, "*", Environment.NewLine + Environment.NewLine), MessageButtons.YesNo)); case RInstallStatus.ExceptionAccessingPath: coreShell.ShowErrorMessage( string.Format(CultureInfo.InvariantCulture, Resources.Error_ExceptionAccessingPath, data.Path, data.Exception.Message)); return(MessageButtons.OK); case RInstallStatus.NoRBinaries: return(coreShell.ShowMessage( string.Format(CultureInfo.InvariantCulture, Resources.Error_CannotFindRBinariesFormat, data.Path, Environment.NewLine + Environment.NewLine, Environment.NewLine), MessageButtons.YesNo)); case RInstallStatus.PathNotSpecified: return(coreShell.ShowMessage(string.Format(CultureInfo.InvariantCulture, Resources.Error_UnableToFindR, Environment.NewLine + Environment.NewLine), MessageButtons.YesNo)); } return(MessageButtons.OK); }
public static bool VerifyRIsInstalled(this RInstallation rInstallation, ICoreShell coreShell, ISupportedRVersionRange svl, string path, bool showErrors = true) { svl = svl ?? new SupportedRVersionRange(); var data = rInstallation.GetInstallationData(path, svl); if (data.Status == RInstallStatus.OK) { return(true); } if (showErrors) { if (ShowMessage(coreShell, data, svl) == MessageButtons.Yes) { coreShell.TelemetryService.ReportEvent(TelemetryArea.Configuration, MrcTelemetryEvents.RClientInstallPrompt); var installer = coreShell.ExportProvider.GetExportedValue <IMicrosoftRClientInstaller>(); installer.LaunchRClientSetup(coreShell); } } return(false); }
protected RInstallationService() { var a = Environment.GetEnvironmentVariable("LS_HOST_PROCESS_ARCHITECTURE"); Architecture = string.IsNullOrWhiteSpace(a) ? ArchitectureString.X64 : a; SupportedVersions = new SupportedRVersionRange(3, 2, 4, 9); }
private IEnumerable <IRInterpreterInfo> GetInstalledMRO(IEnumerable <InstalledPackageInfo> packagesInfo, ISupportedRVersionRange svl) { var list = new List <IRInterpreterInfo>(); var selectedPackages = packagesInfo.Where(p => p.PackageName.StartsWithIgnoreCase("microsoft-r-open-mro") && svl.IsCompatibleVersion(p.GetVersion())); foreach (var package in selectedPackages) { var files = package.GetPackageFiles(_fileSystem); string rInstallPath = GetRInstallPath(files, _fileSystem); list.Add(new RInterpreterInfo($"Microsoft R Open '{package.Version}'", rInstallPath, package.Version, package.GetVersion(), _fileSystem)); } return(list); }
private IRInterpreterInfo TryFindRInProgramFiles(ISupportedRVersionRange supportedVersions) { // Force 64-bit PF var programFiles = Environment.GetEnvironmentVariable("ProgramW6432"); var baseRFolder = Path.Combine(programFiles, @"R"); var versions = new List<Version>(); try { if (_fileSystem.DirectoryExists(baseRFolder)) { IEnumerable<IFileSystemInfo> directories = _fileSystem.GetDirectoryInfo(baseRFolder) .EnumerateFileSystemInfos() .Where(x => (x.Attributes & FileAttributes.Directory) != 0); foreach (IFileSystemInfo fsi in directories) { string subFolderName = fsi.FullName.Substring(baseRFolder.Length + 1); Version v = GetRVersionFromFolderName(subFolderName); if (supportedVersions.IsCompatibleVersion(v)) { versions.Add(v); } } } } catch (IOException) { // Don't do anything if there is no RRO installed } if (versions.Count > 0) { versions.Sort(); Version highest = versions[versions.Count - 1]; var name = string.Format(CultureInfo.InvariantCulture, "R-{0}.{1}.{2}", highest.Major, highest.Minor, highest.Build); var path = Path.Combine(baseRFolder, name); var ri = new RInterpreterInfo(name, path); if (ri.VerifyInstallation(supportedVersions)) { return ri; } } return null; }
private IEnumerable <IRInterpreterInfo> GetInstalledCranR(IEnumerable <InstalledPackageInfo> packagesInfo, ISupportedRVersionRange svl) { var list = new List <IRInterpreterInfo>(); var selectedPackages = packagesInfo.Where(p => p.PackageName.EqualsIgnoreCase("r-base-core") && svl.IsCompatibleVersion(p.GetVersion())); foreach (var package in selectedPackages) { var files = package.GetPackageFiles(_fileSystem); string rInstallPath = GetRInstallPath(files, _fileSystem); list.Add(new RInterpreterInfo($"R '{package.Version}'", rInstallPath, package.Version, package.GetVersion(), _fileSystem)); } return(list); }
private IEnumerable <IRInterpreterInfo> GetInstalledCranR(IEnumerable <InstalledPackageInfo> packagesInfo, ISupportedRVersionRange svl) { var selectedPackages = packagesInfo.Where(p => p.PackageName.EqualsIgnoreCase("r-base-core") && svl.IsCompatibleVersion(p.GetVersion())); foreach (var package in selectedPackages) { yield return(RInterpreterInfo.CreateFromPackage(package, "CRAN R", _fileSystem)); } }
/// <summary> /// Tries to determine R installation information. If user-specified path /// is supplied, it is used. If not, registry is used. If nothing is found /// in the registry, makes attempt to find compatible 64-bit installation /// of MRO, RRO or R (in this order) in Program Files folder /// </summary> /// <param name="basePath">Path as specified by the user settings</param> /// <returns></returns> public static RInstallData GetInstallationData( string basePath, ISupportedRVersionRange svl, ICoreShell coreShell = null) { string path = GetRInstallPath(basePath, svl, coreShell); // If nothing is found, look into the file system if (string.IsNullOrEmpty(path)) { foreach (var f in rFolders) { path = TryFindRInProgramFiles(f, svl); if (!string.IsNullOrEmpty(path)) { break; } } } // Still nothing? Fail, caller will typically display an error message. if (string.IsNullOrEmpty(path)) { return(new RInstallData() { Status = RInstallStatus.PathNotSpecified }); } // Now verify if files do exist and are of the correct version. // There may be cases when R was not fully uninstalled or when // version claimed in the registry is not what is really in files. RInstallData data = new RInstallData() { Status = RInstallStatus.OK, Path = path }; // Normalize path so it points to R root and not to bin or bin\x64 path = NormalizeRPath(path); try { string rDirectory = Path.Combine(path, @"bin\x64"); data.BinPath = rDirectory; string rDllPath = Path.Combine(rDirectory, "R.dll"); string rGraphAppPath = Path.Combine(rDirectory, "Rgraphapp.dll"); string rTermPath = Path.Combine(rDirectory, "RTerm.exe"); string rScriptPath = Path.Combine(rDirectory, "RScript.exe"); string rGuiPath = Path.Combine(rDirectory, "RGui.exe"); if (FileSystem.FileExists(rDllPath) && FileSystem.FileExists(rTermPath) && FileSystem.FileExists(rScriptPath) && FileSystem.FileExists(rGraphAppPath) && FileSystem.FileExists(rGuiPath)) { IFileVersionInfo fvi = FileSystem.GetVersionInfo(rDllPath); int minor, revision; GetRVersionPartsFromFileMinorVersion(fvi.FileMinorPart, out minor, out revision); data.Version = new Version(fvi.FileMajorPart, minor, revision); if (!svl.IsCompatibleVersion(data.Version)) { data.Status = RInstallStatus.UnsupportedVersion; } } else { data.Status = RInstallStatus.NoRBinaries; } } catch (ArgumentException aex) { data.Status = RInstallStatus.ExceptionAccessingPath; data.Exception = aex; } catch (IOException ioex) { data.Status = RInstallStatus.ExceptionAccessingPath; data.Exception = ioex; } return(data); }