SystemPackage RegisterPackage (SystemPackageInfo pinfo, bool isInternal, PackageAssemblyInfo[] assemblyFiles)
{
//don't allow packages to duplicate framework packages
SystemPackage oldPackage;
if (packagesHash.TryGetValue (pinfo.Name, out oldPackage)) {
if (oldPackage.IsFrameworkPackage)
return oldPackage;
else if (pinfo.IsFrameworkPackage)
ForceUnregisterPackage (oldPackage);
}
SystemPackage p = new SystemPackage ();
List<SystemAssembly> asms = new List<SystemAssembly> ();
foreach (PackageAssemblyInfo asm in assemblyFiles) {
if (pinfo.IsFrameworkPackage || !GetAssembliesFromFullNameInternal (asm.FullName, false).Any (a => a.Package != null && a.Package.IsFrameworkPackage))
asms.Add (AddAssembly (asm.File, new AssemblyInfo (asm), p));
}
p.Initialize (pinfo, asms, isInternal);
packages.Add (p);
packagesHash [pinfo.Name] = p;
NotifyChanged ();
return p;
}
internal void Initialize (SystemPackageInfo info, IEnumerable<SystemAssembly> assemblies, bool isInternal)
{
this.isInternal = isInternal;
this.name = info.Name ?? string.Empty;
this.version = info.Version ?? string.Empty;
this.description = info.Description ?? string.Empty;
this.targetFramework = info.TargetFramework;
this.gacRoot = info.GacRoot;
this.gacPackage = info.IsGacPackage;
IsFrameworkPackage = info.IsFrameworkPackage;
IsCorePackage = info.IsCorePackage;
IsBaseCorePackage = info.IsBaseCorePackage;
this.Requires = info.Requires;
SystemAssembly last = null;
foreach (SystemAssembly asm in assemblies) {
if (asm == null)
continue;
asm.Package = this;
if (this.assemblies == null)
this.assemblies = asm;
else
last.NextSamePackage = asm;
last = asm;
}
}
SystemPackage RegisterPackage (SystemPackageInfo pinfo, bool isInternal, PackageAssemblyInfo[] assemblyFiles)
{
//don't allow packages to duplicate framework package names
//but multiple framework packages (from different versions) may have the same name
SystemPackage oldPackage;
if (packagesHash.TryGetValue (pinfo.Name, out oldPackage)) {
if (pinfo.IsFrameworkPackage) {
if (!oldPackage.IsFrameworkPackage)
ForceUnregisterPackage (oldPackage);
} else if (oldPackage.IsFrameworkPackage) {
return oldPackage;
}
}
SystemPackage p = new SystemPackage ();
List<SystemAssembly> asms = new List<SystemAssembly> ();
foreach (PackageAssemblyInfo asm in assemblyFiles) {
if (pinfo.IsFrameworkPackage || !GetAssembliesFromFullNameInternal (asm.FullName, false).Any (a => a.Package != null && a.Package.IsFrameworkPackage))
asms.Add (AddAssembly (asm.File, new AssemblyInfo (asm), p));
}
p.Initialize (pinfo, asms, isInternal);
packages = packages.Add (p);
packagesHash = packagesHash.SetItem (pinfo.Name, p);
NotifyChanged ();
return p;
}
internal protected SystemPackage RegisterPackage (SystemPackageInfo pinfo, bool isInternal, params string[] assemblyFiles)
{
List<PackageAssemblyInfo> pinfos = new List<PackageAssemblyInfo> (assemblyFiles.Length);
foreach (string afile in assemblyFiles) {
try {
PackageAssemblyInfo pi = new PackageAssemblyInfo ();
pi.File = afile;
pi.Update (SystemAssemblyService.GetAssemblyNameObj (pi.File));
pinfos.Add (pi);
}
catch {
// Ignore
}
}
return RegisterPackage (pinfo, isInternal, pinfos.ToArray ());
}
public SystemPackageInfo GetPackageInfo ()
{
SystemPackageInfo pi = new SystemPackageInfo ();
pi.Name = name;
pi.Version = version;
if (fxVersion != null)
pi.TargetFramework = TargetFrameworkMoniker.Parse (fxVersion);
else if (clrVersion == ClrVersion.Net_1_1)
pi.TargetFramework = TargetFrameworkMoniker.NET_1_1;
else if (clrVersion == ClrVersion.Net_2_0)
pi.TargetFramework = TargetFrameworkMoniker.NET_2_0;
if (hasGacRoot)
pi.GacRoot = Addin.GetFilePath (".");
return pi;
}
public SystemPackageInfo GetPackageInfo ()
{
SystemPackageInfo pi = new SystemPackageInfo ();
pi.Name = name;
pi.Version = version;
if (fxVersion != null)
pi.TargetFramework = fxVersion;
else if (clrVersion == ClrVersion.Net_1_1)
pi.TargetFramework = "1.1";
else if (clrVersion == ClrVersion.Net_2_0)
pi.TargetFramework = "2.0";
if (hasGacRoot)
pi.GacRoot = Addin.GetFilePath (".");
return pi;
}
void OnPackagesChanged(object s, ExtensionNodeEventArgs args)
{
PackageExtensionNode node = (PackageExtensionNode)args.ExtensionNode;
SystemPackageInfo pi = node.GetPackageInfo();
if (args.Change == ExtensionChange.Add)
{
var existing = assemblyContext.GetPackageInternal(pi.Name);
if (existing == null || (!existing.IsFrameworkPackage || pi.IsFrameworkPackage))
{
RegisterPackage(pi, node.Assemblies);
}
}
else
{
SystemPackage p = assemblyContext.GetPackage(pi.Name, pi.Version);
if (p.IsInternalPackage)
{
assemblyContext.UnregisterPackage(pi.Name, pi.Version);
}
}
}
SystemPackage RegisterPackage(SystemPackageInfo pinfo, bool isInternal, PackageAssemblyInfo[] assemblyFiles)
{
//don't allow packages to duplicate framework package names
//but multiple framework packages (from different versions) may have the same name
SystemPackage oldPackage;
if (packagesHash.TryGetValue(pinfo.Name, out oldPackage))
{
if (pinfo.IsFrameworkPackage)
{
if (!oldPackage.IsFrameworkPackage)
{
ForceUnregisterPackage(oldPackage);
}
}
else if (oldPackage.IsFrameworkPackage)
{
return(oldPackage);
}
}
SystemPackage p = new SystemPackage();
List <SystemAssembly> asms = new List <SystemAssembly> ();
foreach (PackageAssemblyInfo asm in assemblyFiles)
{
if (pinfo.IsFrameworkPackage || !GetAssembliesFromFullNameInternal(asm.FullName, false).Any(a => a.Package != null && a.Package.IsFrameworkPackage))
{
asms.Add(AddAssembly(asm.File, new AssemblyInfo(asm), p));
}
}
p.Initialize(pinfo, asms, isInternal);
packages.Add(p);
packagesHash [pinfo.Name] = p;
NotifyChanged();
return(p);
}
internal protected SystemPackage RegisterPackage(SystemPackageInfo pinfo, bool isInternal, params string[] assemblyFiles)
{
List <PackageAssemblyInfo> pinfos = new List <PackageAssemblyInfo> (assemblyFiles.Length);
foreach (string afile in assemblyFiles)
{
if (!SystemAssemblyService.IsManagedAssembly(afile))
{
continue;
}
try {
PackageAssemblyInfo pi = new PackageAssemblyInfo();
pi.File = afile;
pi.Update(SystemAssemblyService.GetAssemblyNameObj(pi.File));
pinfos.Add(pi);
}
catch {
// Ignore
}
}
return(RegisterPackage(pinfo, isInternal, pinfos.ToArray()));
}
/// <summary>
/// Registers a package.
/// </summary>
/// <param name="pinfo">
/// Information about the package.
/// </param>
/// <param name="isInternal">
/// Set to true if this package is provided by an add-in and is not installed in the system.
/// </param>
/// <param name="assemblyFiles">
/// A <see cref="System.String[]"/>
/// </param>
/// <returns>
/// A <see cref="SystemPackage"/>
/// </returns>
public SystemPackage RegisterPackage(SystemPackageInfo pinfo, bool isInternal, params string[] assemblyFiles)
{
EnsureInitialized();
return(assemblyContext.RegisterPackage(pinfo, isInternal, assemblyFiles));
}
/// <summary>
/// Registers a package. It can be used by add-ins to register a package for a set of assemblies
/// they provide.
/// </summary>
/// <param name="pinfo">
/// Information about the package.
/// </param>
/// <param name="assemblyFiles">
/// Assemblies that belong to the package
/// </param>
/// <returns>
/// The registered package
/// </returns>
public SystemPackage RegisterPackage(SystemPackageInfo pinfo, params string[] assemblyFiles)
{
return(RegisterPackage(pinfo, true, assemblyFiles));
}
/// <summary>
/// Registers a package.
/// </summary>
/// <param name="pinfo">
/// Information about the package.
/// </param>
/// <param name="isInternal">
/// Set to true if this package is provided by an add-in and is not installed in the system.
/// </param>
/// <param name="assemblyFiles">
/// The assemblies of the package.
/// </param>
/// <returns>
/// A <see cref="SystemPackage"/>
/// </returns>
public SystemPackage RegisterPackage (SystemPackageInfo pinfo, bool isInternal, params string[] assemblyFiles)
{
EnsureInitialized ();
return assemblyContext.RegisterPackage (pinfo, isInternal, assemblyFiles);
}
/// <summary>
/// Registers a package. It can be used by add-ins to register a package for a set of assemblies
/// they provide.
/// </summary>
/// <param name="pinfo">
/// Information about the package.
/// </param>
/// <param name="assemblyFiles">
/// Assemblies that belong to the package
/// </param>
/// <returns>
/// The registered package
/// </returns>
public SystemPackage RegisterPackage (SystemPackageInfo pinfo, params string[] assemblyFiles)
{
return RegisterPackage (pinfo, true, assemblyFiles);
}
public virtual SystemPackageInfo GetFrameworkPackageInfo (string packageName)
{
SystemPackageInfo info = new SystemPackageInfo ();
info.Name = string.IsNullOrEmpty (packageName) ? runtime.DisplayRuntimeName : packageName;
info.Description = string.IsNullOrEmpty (packageName) ? framework.Name : packageName;
info.IsFrameworkPackage = true;
info.IsCorePackage = true;
info.IsGacPackage = true;
info.Version = framework.Id.Version;
info.TargetFramework = framework.Id;
return info;
}
void AddPackage (string name, string version, string folder, TargetFramework fx)
{
SystemPackageInfo pinfo = new SystemPackageInfo ();
pinfo.Name = name;
pinfo.Description = name;
pinfo.Version = version;
pinfo.TargetFramework = fx != null ? fx.Id : null;
try {
if (Directory.Exists (folder))
RegisterPackage (pinfo, false, Directory.GetFiles (folder, "*.dll"));
}
catch (Exception ex) {
LoggingService.LogError ("Error while scanning assembly folder '" + folder + "'", ex);
}
}
bool RegisterRedistAssemblies (FilePath location)
{
var info = new SystemPackageInfo () {
Name = "moonlight-web-" + fxVersion + "-redist",
Description = "Moonlight " + fxVersion + " Redistributable Assemblies",
Version = pluginVersion,
IsFrameworkPackage = true,
IsGacPackage = false,
IsCorePackage = false,
TargetFramework = framework.Id,
};
var dir = location.Combine (fxVersion + "-redist");
try {
var files = Directory.GetFiles (dir, "*.dll");
runtime.RegisterPackage (info, files);
return true;
} catch (IOException ex) {
LoggingService.LogError ("Could not enumerate redist assemblies from directory '" + dir + "'", ex);
return false;
}
}
void RegisterAssembly (string file)
{
SystemPackageInfo spi = new SystemPackageInfo ();
spi.Name = file;
spi.Description = Path.GetDirectoryName (file);
spi.Version = "";
spi.IsGacPackage = false;
spi.TargetFramework = Runtime.SystemAssemblyService.GetTargetFrameworkForAssembly (Runtime.SystemAssemblyService.CurrentRuntime, file);
SystemPackage sp = RegisterPackage (spi, true, file);
packages.Add (sp);
}
public virtual SystemPackageInfo GetFrameworkPackageInfo (string packageName)
{
string name = !string.IsNullOrEmpty (packageName)? packageName : framework.Name;
SystemPackageInfo info = new SystemPackageInfo ();
info.Name = name;
info.Description = name;
info.IsFrameworkPackage = true;
info.IsCorePackage = true;
info.IsGacPackage = true;
info.Version = framework.Id.Version;
info.TargetFramework = framework.Id;
return info;
}
