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;
}
public ResolvedReference ResolvePkgConfigReference(ITaskItem reference, bool specific_version)
{
PackageAssemblyInfo pkg = null;
if (specific_version)
{
pkg = PcCache.GetAssemblyLocation(reference.ItemSpec);
}
else
{
// if not specific version, then just match simple name
string name = reference.ItemSpec;
if (name.IndexOf(',') > 0)
{
name = name.Substring(0, name.IndexOf(','));
}
pkg = PcCache.ResolveAssemblyName(name).FirstOrDefault();
}
if (pkg == null)
{
LogSearchMessage("Considered {0}, but could not find in any pkg-config files.",
reference.ItemSpec);
return(null);
}
ResolvedReference rr = GetResolvedReference(reference, pkg.File, new AssemblyName(pkg.FullName),
false, SearchPath.PkgConfig);
rr.FoundInSearchPathAsString = String.Format("{{PkgConfig}} provided by package named {0}",
pkg.ParentPackage.Name);
return(rr);
}
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 ResolvedReference ResolvePkgConfigReference(ITaskItem reference, bool specific_version = true)
{
var packages = PcCache.GetPackages();
int count = packages.Count();
log.LogMessage("packages count = {0}", count.ToString());
PackageAssemblyInfo pkg = null;
pkg = PcCache.GetAssemblyLocation(reference.ItemSpec);
log.LogMessage("PcCache.GetAssemblyLocation(\"{0}\") returned \"{1}\"", reference.ItemSpec, pkg);
if (pkg == null)
{
log.LogMessage("It's null !!!");
}
if (pkg == null && !specific_version)
{
// if not specific version, then just match simple name
string name = reference.ItemSpec;
if (name.IndexOf(',') > 0)
{
name = name.Substring(0, name.IndexOf(','));
}
pkg = PcCache.ResolveAssemblyName(name).FirstOrDefault();
}
if (pkg == null)
{
log.LogMessage("Considered {0}, but could not find in any pkg-config files.",
reference.ItemSpec);
return(null);
}
AssemblyName aname;
if (!TryGetAssemblyNameFromFullName(pkg.FullName, out aname))
{
return(null);
}
ResolvedReference rr = GetResolvedReference(reference, pkg.File, aname, false, SearchPath.PkgConfig);
rr.FoundInSearchPathAsString = String.Format("{{PkgConfig}} provided by package named {0}",
pkg.ParentPackage.Name);
return(rr);
}
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 AssemblyInfo(PackageAssemblyInfo info)
{
Name = info.Name;
Version = info.Version;
PublicKeyToken = info.PublicKeyToken;
}
internal static dynamic GetCoAppPackageFileDetails(string localPackagePath)
{
dynamic packageData = GetDynamicMSIData(localPackagePath);
if (packageData.CO_PACKAGE == null) {
throw new InvalidPackageException(InvalidReason.NotCoAppMSI, localPackagePath);
}
string name = packageData["ProductName"];
var newrecord = (from rec in packageData.CO_PACKAGE as IEnumerable<dynamic> where rec.Name == name select rec).FirstOrDefault();
if (newrecord == null) {
throw new InvalidPackageException(InvalidReason.MalformedCoAppMSI, localPackagePath);
}
string pkgid = newrecord.package_id;
string arch = newrecord.arch;
UInt64 version = ((string)newrecord.version).VersionStringToUInt64();
string pkt = newrecord.public_key_token;
UInt64 minPolicy = 0;
UInt64 maxPolicy = 0;
if (packageData.CO_BINDING_POLICY != null &&
((IEnumerable<dynamic>)packageData.CO_BINDING_POLICY).Count() == 1) {
var policy = packageData.CO_BINDING_POLICY[0];
minPolicy = ((string)policy.minimum_version).VersionStringToUInt64();
maxPolicy = ((string)policy.maximum_version).VersionStringToUInt64();
}
string licenseText = null;
string licenseUrl = null;
if (packageData.CO_LICENSE != null &&
((IEnumerable<dynamic>)packageData.CO_BINDING_POLICY).Count() == 1)
{
var license = packageData.CO_LICENSE[0];
licenseText = license.license_text;
licenseUrl = license.license_url;
}
var properties = packageData.CO_PACKAGE_PROPERTIES[pkgid];
var publisher = packageData.CO_PUBLISHER[pkt];
dynamic result =
new {
Name = name,
Version = version,
Architecture = arch,
PublicKeyToken = pkt,
packageId = pkgid,
policy_min_version = minPolicy,
policy_max_version = maxPolicy,
dependencies = new List<Package>(),
// type and flavor
roles = new List<Tuple<PackageRole, string>>(),
assemblies = new Dictionary<string, PackageAssemblyInfo>(),
// new cosmetic metadata fields
displayName = properties.display_name,
description = StringExtensions.GunzipFromBase64(properties.description),
publishDate = properties.publish_date,
authorVersion = properties.author_version,
originalLocation = GetURL(packageData.CO_URLS, properties.original_location ),
feedLocation = GetURL(packageData.CO_URLS, properties.feed_location),
icon = properties.icon,
summary = properties.short_description,
publisherName = publisher.name,
publisherUrl = GetURL(packageData.CO_URLS,publisher.location),
publisherEmail = publisher.email,
license = StringExtensions.GunzipFromBase64(licenseText),
licenseUrl = GetURL(packageData.CO_URLS, licenseUrl)
};
if (packageData.CO_DEPENDENCY != null) {
var dependencyPackageIds = from depPkg in (packageData.CO_DEPENDENCY as IEnumerable<dynamic>) select depPkg.dependency_id;
foreach (var pak in
dependencyPackageIds.Select(
eachPackageId =>
(from pkg in (packageData.CO_PACKAGE as IEnumerable<dynamic>)
where eachPackageId == pkg.package_id
select pkg).FirstOrDefault())) {
pkgid = pak.package_id;
name = pak.name;
arch = pak.arch;
version = ((string)pak.version).VersionStringToUInt64();
pkt = pak.public_key_token;
result.dependencies.Add(Registrar.GetPackage(name, version, arch, pkt, pkgid));
}
}
if (packageData.CO_ROLES != null) {
var numOfSharedLibs = 0;
foreach (var record in packageData.CO_ROLES as IEnumerable<dynamic>) {
PackageRole type = Enum.Parse(typeof(PackageRole), record.type.ToString(), true);
if (type == PackageRole.SharedLib )
numOfSharedLibs++;
var role = new Tuple<PackageRole, string>(type, record.flavor);
result.roles.Add(role);
}
if (numOfSharedLibs > 0) {
if (packageData.MsiAssembly != null && packageData.MsiAssemblyName != null) {
var assms = result.assemblies;
var numberOfNonPolicyAssms = 0;
foreach (var record in packageData.MsiAssemblyName as IEnumerable<dynamic>) {
var componentId = record.Component_;
if (!assms.ContainsKey(componentId))
assms[componentId] = new PackageAssemblyInfo();
switch ((string)record.Name) {
case "name":
assms[componentId].Name = record.Value;
break;
case "processorArchitecture":
assms[componentId].Arch = record.Value;
break;
case "type":
var type = record.Value;
if (!type.Contains("policy"))
numberOfNonPolicyAssms++;
assms[componentId].Type = type;
break;
case "version":
assms[componentId].Version = record.Value;
break;
case "publicKeyToken":
assms[componentId].PublicKeyToken = record.Value;
break;
}
}
/*
if (numberOfNonPolicyAssms < numOfSharedLibs) {
// you need to have at least one assembly per sharedlib);
throw new InvalidPackageException(InvalidReason.MalformedCoAppMSI, localPackagePath);
}*/
}
else {
// you have shared libs but no MsiAssembly and/or no MsiAssembly Name. That's what shared libs are.
throw new InvalidPackageException(InvalidReason.MalformedCoAppMSI, localPackagePath);
}
}
}
else {
// you need to have a ROLE TABLE!
throw new InvalidPackageException(InvalidReason.MalformedCoAppMSI, localPackagePath);
}
return result;
}
public AssemblyInfo (PackageAssemblyInfo info)
{
Name = info.Name;
Version = info.Version;
PublicKeyToken = info.PublicKeyToken;
}
