using System;
|
using System.Collections.Concurrent;
|
using System.Collections.Generic;
|
using System.IO;
|
using System.Linq;
|
using System.Threading;
|
using System.Threading.Tasks;
|
using OpenTap.Package.Ipc;
|
using Tap.Shared;
|
|
namespace OpenTap.Package
|
{
|
/// <summary>
|
/// Represents an OpenTAP installation in a specific directory.
|
/// </summary>
|
public class Installation
|
{
|
static TraceSource log = Log.CreateSource("Installation");
|
|
/// <summary>
|
/// Path to the installation
|
/// </summary>
|
public string Directory { get; }
|
|
/// <summary>
|
/// Get a unique identifier for this OpenTAP installation.
|
/// The identifier is computed from hashing a uniquely generated machine ID combined with the hash of the installation directory.
|
/// </summary>
|
public string Id
|
{
|
get
|
{
|
if(string.IsNullOrWhiteSpace(id))
|
id = $"{MurMurHash3.Hash(GetMachineId()):X8}{MurMurHash3.Hash(Directory):X8}";
|
return id;
|
}
|
}
|
private string id { get; set; }
|
internal static string GetMachineId()
|
{
|
var idPath = Path.Combine(Environment.GetFolderPath(Environment.SpecialFolder.LocalApplicationData, Environment.SpecialFolderOption.Create), "OpenTap", "OpenTapGeneratedId");
|
string id = default(Guid).ToString(); // 00000000-0000-0000-0000-000000000000
|
|
try
|
{
|
if (File.Exists(idPath))
|
{
|
if (Guid.TryParse(File.ReadAllText(idPath), out Guid parsedGuid)) // In the assumable rare case that a user tampers with the OpenTapGeneratedId file.
|
{
|
id = parsedGuid.ToString();
|
return id;
|
}
|
}
|
|
id = Guid.NewGuid().ToString();
|
if (System.IO.Directory.Exists(Path.GetDirectoryName(idPath)) == false)
|
System.IO.Directory.CreateDirectory(Path.GetDirectoryName(idPath));
|
File.WriteAllText(idPath, id);
|
}
|
catch (Exception e)
|
{
|
log.Error("Failed to read machine ID. See debug messages for more information");
|
log.Debug(e);
|
}
|
|
return id;
|
}
|
|
|
/// <summary>
|
/// Initialize an instance of a OpenTAP installation.
|
/// </summary>
|
/// <param name="directory"></param>
|
public Installation(string directory)
|
{
|
this.Directory = directory ?? throw new ArgumentNullException(nameof(directory));
|
}
|
|
/// <summary>
|
/// Check if it is an installation folder that contains packages other than system-wide packages
|
/// </summary>
|
public bool IsInstallationFolder => GetPackages().Any(x => x.IsSystemWide() == false);
|
|
private static Installation current;
|
|
/// <summary>
|
/// Get the installation of the currently running tap process
|
/// </summary>
|
public static Installation Current => current ??= new Installation(ExecutorClient.ExeDir);
|
|
/// <summary> Target installation architecture. This could be anything as 32-bit is supported on 64bit systems.</summary>
|
internal CpuArchitecture Architecture => GetOpenTapPackage()?.Architecture ?? ArchitectureHelper.GuessBaseArchitecture;
|
|
/// <summary> The target installation OS, should be either Windows, MacOS or Linux. </summary>
|
internal string OS
|
{
|
get
|
{
|
if (OperatingSystem.Current == OperatingSystem.Windows)
|
return "Windows";
|
if (OperatingSystem.Current == OperatingSystem.MacOS)
|
return "MacOS";
|
return "Linux";
|
}
|
}
|
|
|
/// <summary>
|
/// Invalidate cached package list. This should only be called if changes have been made to the installation by circumventing OpenTAP APIs.
|
/// </summary>
|
public void Invalidate()
|
{
|
fileMap.Clear();
|
// Force GetPackages() to repopulate packages next time it is called
|
invalidate = true;
|
}
|
|
bool invalidate;
|
readonly ConcurrentDictionary<string, PackageDef> fileMap = new ConcurrentDictionary<string, PackageDef>();
|
|
/// <summary>
|
/// Get the installed package which provides the file specified by the string.
|
/// If multiple packages provide the file the package is chosen arbitrarily.
|
/// </summary>
|
/// <param name="file">An absolute or relative path to the file</param>
|
/// <returns></returns>
|
public PackageDef FindPackageContainingFile(string file)
|
{
|
InvalidateIfChanged();
|
|
try
|
{
|
var invalid = Path.GetInvalidPathChars();
|
if (file.Any(ch => invalid.Contains(ch))) return null;
|
var name = Path.GetFileName(file);
|
invalid = Path.GetInvalidFileNameChars();
|
if (name.Any(ch => invalid.Contains(ch))) return null;
|
// The path API is not 100% consistent. In some circumstances 'GetFullPath' will
|
// still throw even if there are no illegal characters in the filename or path name.
|
_ = Path.GetFullPath(file);
|
}
|
catch
|
{
|
// This means the filename is invalid on some way not covered by Path.GetInvalidPathChars.
|
// This is fine, and it definitely means the file is not contained in a package
|
return null;
|
}
|
|
var installDir = ExecutorClient.ExeDir;
|
|
// Compute the absolute path in order to ensure the file exists, and normalize the path so it matches the format in package.xml files
|
var abs = Path.IsPathRooted(file)
|
? Path.GetFullPath(file) // If the path is rooted, use the full path
|
: Path.GetFullPath(Path.Combine(installDir, file)); // otherwise, append the relative path to the install dir
|
|
// abs must be contained within installDir
|
if (abs.Length <= installDir.Length)
|
return null;
|
|
// Path case sensitivity is file system dependent. Typically Windows and MacOS will be case-insensitive,
|
// and Linux will be case-sensitive, but not always. TODO: check if path file system is case sensitive
|
var stringComparer = OperatingSystem.Current == OperatingSystem.Linux
|
? StringComparison.Ordinal
|
: StringComparison.OrdinalIgnoreCase;
|
// Ensure the file is in a subdirectory of the installation. Otherwise it is not contained in a package.
|
if (!abs.StartsWith(installDir, stringComparer))
|
return null;
|
|
// Compute the relative path and normalize directory separators
|
var relative = abs.Substring(installDir.Length + 1).Replace('\\', '/');
|
|
// Fully initialize fileMap as needed whenever it is cleared
|
if (fileMap.Count == 0)
|
{
|
foreach (var package in GetPackages())
|
{
|
foreach (var packageFile in package.Files)
|
{
|
var fileName = packageFile.FileName.Replace('\\', '/');
|
fileMap.TryAdd(fileName, package);
|
}
|
}
|
}
|
|
if (fileMap.TryGetValue(relative, out var result))
|
return result;
|
return null;
|
}
|
|
/// <summary>
|
/// Get the installed package which provides the type specified by pluginType.
|
/// If multiple packages provide the type the package is chosen arbitrarily.
|
/// </summary>
|
/// <param name="pluginType"></param>
|
/// <returns></returns>
|
public PackageDef FindPackageContainingType(ITypeData pluginType)
|
{
|
var source = TypeData.GetTypeDataSource(pluginType);
|
if (source == null) return null;
|
// sourceFile is normally a .DLL, but may also be other things, e.g .py-file.
|
var sourceFile = source.Location;
|
if (string.IsNullOrWhiteSpace(sourceFile)) return null;
|
|
var assemblyPath = Path.GetFullPath(sourceFile);
|
var installPath = Path.GetFullPath(Directory);
|
|
// The assembly must be rooted in the installation
|
if (assemblyPath.StartsWith(installPath) == false)
|
return null;
|
|
return FindPackageContainingFile(assemblyPath);
|
}
|
|
private Dictionary<string, PackageDef> packageCache;
|
private long previousChangeId = -1;
|
|
// Keeps track of which warnings about duplicate packages has been emitted.
|
static readonly HashSet<string> duplicateLogWarningsEmitted = new HashSet<string>();
|
|
/// <summary>
|
/// Invalidate caches if the installation has changed.
|
/// </summary>
|
private void InvalidateIfChanged()
|
{
|
long changeId = IsolatedPackageAction.GetChangeId(Directory);
|
|
if (changeId != previousChangeId)
|
{
|
Invalidate();
|
previousChangeId = changeId;
|
}
|
}
|
/// <summary>
|
/// Returns package definition list of installed packages in the TAP installation defined in the constructor, and system-wide packages.
|
/// Results are cached, and Invalidate must be called if changes to the installation are made by circumventing OpenTAP APIs.
|
/// </summary>
|
public List<PackageDef> GetPackages() => GetPackagesLookup().Values.ToList();
|
/// <summary>
|
/// Returns package definition list of installed packages in the TAP installation defined in the constructor, and system-wide packages.
|
/// Results are cached, and Invalidate must be called if changes to the installation are made by circumventing OpenTAP APIs.
|
/// </summary>
|
public List<PackageDef> GetPackages(bool validOnly) => GetPackagesLookup().Values.Where(pkg => pkg.IsValid()).ToList();
|
|
/// <summary> Finds an installed package by name. Returns null if the package was not found. </summary>
|
public PackageDef FindPackage(string name) => GetPackagesLookup().TryGetValue(name, out var package) ? package : null;
|
|
/// <summary>
|
/// Returns package definition list of installed packages in the TAP installation defined in the constructor, and system-wide packages.
|
/// Results are cached, and Invalidate must be called if changes to the installation are made by circumventing OpenTAP APIs.
|
/// </summary>
|
/// <returns></returns>
|
Dictionary<string, PackageDef> GetPackagesLookup()
|
{
|
InvalidateIfChanged();
|
|
if (packageCache == null || invalidate)
|
{
|
Dictionary<string, PackageDef> plugins = new Dictionary<string, PackageDef>();
|
List<PackageDef> duplicatePlugins = new List<PackageDef>();
|
List<string> package_files = new List<string>();
|
|
// Add normal package from OpenTAP folder
|
package_files.AddRange(PackageDef.GetPackageMetadataFilesInTapInstallation(Directory));
|
|
string normalizePath(string s)
|
{
|
return Path.GetFullPath(s)
|
.TrimEnd(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar)
|
.ToUpperInvariant();
|
}
|
|
// Add system wide packages
|
if (normalizePath(Directory) != normalizePath(PackageDef.SystemWideInstallationDirectory))
|
package_files.AddRange(PackageDef.GetSystemWidePackages());
|
|
foreach (var file in package_files)
|
{
|
var package = installedPackageMemorizer.Invoke(file);
|
if (package == null) continue;
|
|
#pragma warning disable 618
|
package.Location = file;
|
#pragma warning restore 618
|
package.PackageSource = new InstalledPackageDefSource
|
{
|
Installation = this,
|
PackageDefFilePath = file
|
};
|
|
if (!plugins.ContainsKey(package.Name))
|
{
|
plugins.Add(package.Name, package);
|
}
|
else
|
{
|
duplicatePlugins.Add(package);
|
|
}
|
}
|
|
foreach (var p in duplicatePlugins.GroupBy(p => p.Name))
|
{
|
lock (warningsLock)
|
{
|
if (duplicateLogWarningsEmitted.Add(p.Key))
|
log.Warning(
|
$"Duplicate {p.Key} packages detected. Consider removing some of the duplicate package definitions:\n" +
|
$"{string.Join("\n", p.Append(plugins[p.Key]).Select(x => " - " + ((InstalledPackageDefSource)x.PackageSource).PackageDefFilePath))}");
|
}
|
}
|
|
|
|
invalidate = false;
|
packageCache = plugins;
|
}
|
|
return packageCache;
|
}
|
|
private static object warningsLock = new object();
|
|
|
/// <summary>
|
/// Get a package definition of OpenTAP engine.
|
/// </summary>
|
/// <returns></returns>
|
public PackageDef GetOpenTapPackage()
|
{
|
if (GetPackagesLookup().TryGetValue("OpenTAP", out var opentap))
|
return opentap;
|
return null;
|
}
|
|
|
/// <summary>
|
/// Memorizer which returns null when a cyclic memorizer call is detected.
|
/// This prevents ugly and misleading error messages from occurring during
|
/// calls to Installation.Current.GetPackages() from ITypeDataProvider implementations
|
/// </summary>
|
class IgnoreCyclicCallMemorizer<T1, T2, T3> : Memorizer<T1, T2, T3>
|
{
|
public IgnoreCyclicCallMemorizer(Func<T1, T2> func) : base(null, func)
|
{
|
|
}
|
|
public override T2 OnCyclicCallDetected(T1 key)
|
{
|
return default;
|
}
|
}
|
|
|
static IMemorizer<string, PackageDef> installedPackageMemorizer = new IgnoreCyclicCallMemorizer<string, PackageDef, string>(loadPackageDef)
|
{
|
Validator = file => new FileInfo(file).LastWriteTimeUtc.Ticks
|
};
|
static PackageDef loadPackageDef(string file)
|
{
|
try
|
{
|
using (var f = File.Open(file, FileMode.Open, FileAccess.Read, FileShare.Read))
|
return PackageDef.FromXml(f);
|
}
|
catch (Exception e)
|
{
|
log.Warning("Unable to read package file '{0}'. Moving it to '.broken'", file);
|
log.Debug(e);
|
var brokenfile = file + ".broken";
|
if (File.Exists(brokenfile))
|
File.Delete(brokenfile);
|
File.Move(file, brokenfile);
|
}
|
return null;
|
}
|
|
#region Package Change IPC
|
/// <summary>
|
/// Maintains a running number that increments whenever a plugin is installed.
|
/// </summary>
|
private class ChangeId : SharedState
|
{
|
public ChangeId(string dir) : base(".package_definitions_change_ID", dir)
|
{
|
|
}
|
|
public long GetChangeId()
|
{
|
return Read<long>(0);
|
}
|
|
public void SetChangeId(long value)
|
{
|
Write(0, value);
|
}
|
|
public static async Task WaitForChange()
|
{
|
var changeId = new ChangeId(Path.GetDirectoryName(typeof(SharedState).Assembly.Location));
|
var id = changeId.GetChangeId();
|
while (changeId.GetChangeId() == id)
|
await Task.Delay(500);
|
}
|
|
public static void WaitForChangeBlocking()
|
{
|
var changeId = new ChangeId(Path.GetDirectoryName(typeof(SharedState).Assembly.Location));
|
var id = changeId.GetChangeId();
|
while (changeId.GetChangeId() == id)
|
Thread.Sleep(500);
|
}
|
}
|
|
internal void AnnouncePackageChange()
|
{
|
using (var changeId = new ChangeId(this.Directory))
|
changeId.SetChangeId(changeId.GetChangeId() + 1);
|
}
|
|
private bool IsMonitoringPackageChange = false;
|
private void MonitorPackageChange()
|
{
|
if (!IsMonitoringPackageChange)
|
{
|
IsMonitoringPackageChange = true;
|
TapThread.Start(() =>
|
{
|
while (true)
|
{
|
ChangeId.WaitForChangeBlocking();
|
PackageChanged();
|
}
|
});
|
}
|
}
|
|
private Action PackageChanged;
|
/// <summary>
|
/// Event invoked when a package is installed/uninstalled from this installation.
|
/// </summary>
|
public event Action PackageChangedEvent
|
{
|
add
|
{
|
MonitorPackageChange();
|
PackageChanged += value;
|
}
|
remove
|
{
|
PackageChanged -= value;
|
}
|
}
|
#endregion
|
}
|
}
|
