private static string[] GetSiteLibraryDirs(InstalledPackageInfo package, IEnumerable <string> files, IFileSystem fs)
{
List <string> dirs = new List <string>();
if (package.PackageName.ContainsIgnoreCase("r-base-core"))
{
string localSiteLibrary = "/usr/local/r/site-library";
if (fs.DirectoryExists(localSiteLibrary))
{
dirs.Add(localSiteLibrary);
}
string siteLibrary = GetPath(files, "/R/site-library", "", fs);
if (!string.IsNullOrWhiteSpace(siteLibrary))
{
dirs.Add(siteLibrary);
}
}
string library = GetPath(files, "/R/library/base", "/base", fs);
if (!string.IsNullOrWhiteSpace(library))
{
dirs.Add(library);
}
return(dirs.ToArray());
}
public void ReadInstalledPackagesTest()
{
var fs = new TestFileSystem();
var packages = InstalledPackageInfo.GetPackages(fs);
packages.Count().Should().Be(2183); // number of installed packages in the status file
// Test for MRO
var mro = packages.Where(p => p.PackageName.StartsWithOrdinal("microsoft-r-open-mro"));
mro.Count().Should().Be(1);
var mroFiles = mro.First().GetPackageFiles(fs);
mroFiles.Count().Should().BeGreaterThan(0);
var mroLib = mroFiles.Where(f => f.EndsWithOrdinal("/libR.so"));
mroLib.Count().Should().BeGreaterThan(0);
//Test for CRAN R
var cranR = packages.Where(p => p.PackageName.EqualsOrdinal("r-base-core"));
cranR.Count().Should().Be(1);
var cranRFiles = mro.First().GetPackageFiles(fs);
cranRFiles.Count().Should().BeGreaterThan(0);
var cranRLib = mroFiles.Where(f => f.EndsWithOrdinal("/libR.so"));
cranRLib.Count().Should().BeGreaterThan(0);
}
public override IRInterpreterInfo CreateInfo(string name, string path)
{
var packagesInfo = InstalledPackageInfo.GetPackages(_fileSystem);
var libRsoPath = Path.Combine(path, "lib/libR.so").Replace('\\', '/');
// In linux there is no direct way to get version from binary. So, try and find a package that
// has this file in the package files list.
InstalledPackageInfo package = null;
foreach (var pkg in packagesInfo)
{
var files = pkg.GetPackageFiles(_fileSystem);
if (files.Contains(libRsoPath))
{
package = pkg;
break;
}
}
if (package != null)
{
return(new RLinuxInterpreterInfo(name, package, package.Version, package.GetVersion(), _fileSystem));
}
return(null);
}
public LocalDocker GetLocalDocker()
{
const string dockerPath = "/usr/bin/docker";
var packages = InstalledPackageInfo.GetPackages(_fs);
var dockerPkgs = packages
.Where(pkg => pkg.PackageName.EqualsIgnoreCase(DockerCePackageName) || pkg.PackageName.EqualsIgnoreCase(DockerEePackageName))
.ToList();
if (dockerPkgs.Any())
{
var pkg = dockerPkgs.First();
var files = pkg.GetPackageFiles(_fs).Where(f => f.Equals(dockerPath));
if (files.Any())
{
var docker = new LocalDocker(Path.GetDirectoryName(dockerPath), dockerPath);
if (!_fs.FileExists(docker.DockerCommandPath))
{
throw new ContainerServiceNotInstalledException(Resources.Error_NoDockerCommand.FormatInvariant(docker.DockerCommandPath));
}
return(docker);
}
}
throw new ContainerServiceNotInstalledException(Resources.Error_DockerNotFound.FormatInvariant(DockerCePackageName, DockerEePackageName));
}
public override IEnumerable <IRInterpreterInfo> GetCompatibleEngines()
{
var packagesInfo = InstalledPackageInfo.GetPackages(_fileSystem);
var interpreters = new List <IRInterpreterInfo>();
interpreters.AddRange(GetInstalledMRO(packagesInfo));
interpreters.AddRange(GetInstalledCranR(packagesInfo));
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>
/// Constructor
/// </summary>
/// <param name="name">Name of the R interpreter</param>
/// <param name="corePackage">Instance of the core interpreter package
/// (r-base-core, microsoft-r-open-mro, etc)</param>
/// <param name="fileSystem"></param>
public RLinuxInterpreterInfo(string name, InstalledPackageInfo corePackage, string version, Version parsedVersion, IFileSystem fileSystem) :
base(name, parsedVersion, fileSystem)
{
var files = corePackage.GetPackageFiles(fileSystem);
InstallPath = GetRInstallPath(files, fileSystem);
_packageFullVersion = version;
BinPath = GetRLibPath();
DocPath = GetRDocPath(files, fileSystem);
IncludePath = GetIncludePath(files, fileSystem);
RShareDir = GetRSharePath(files, fileSystem);
SiteLibraryDirs = GetSiteLibraryDirs(corePackage, files, fileSystem);
}
public static RInterpreterInfo CreateFromPackage(InstalledPackageInfo package, string namePrefix, IFileSystem fs)
{
return(new RInterpreterInfo($"{namePrefix} '{package.Version}'", package, package.Version, package.GetVersion(), fs));
}
