Пример #1
0
 LockFile LoadLockFile()
 {
     if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
     {
         LogDebugMessage($"Loading NuGet LockFile: {ProjectAssetFile}");
         var logger = new NuGetLogger((s) => {
             LogDebugMessage("{0}", s);
         });
         return(LockFileUtilities.GetLockFile(ProjectAssetFile, logger));
     }
     return(null);
 }
Пример #2
0
        bool Execute(DirectoryAssemblyResolver resolver)
        {
            LogDebugMessage("ResolveAssemblies Task");
            LogDebugMessage("  ReferenceAssembliesDirectory: {0}", ReferenceAssembliesDirectory);
            LogDebugMessage("  I18nAssemblies: {0}", I18nAssemblies);
            LogDebugMessage("  LinkMode: {0}", LinkMode);
            LogDebugTaskItems("  Assemblies:", Assemblies);
            LogDebugMessage("  ProjectAssetFile: {0}", ProjectAssetFile);
            LogDebugMessage("  NuGetPackageRoot: {0}", NuGetPackageRoot);
            LogDebugMessage("  TargetMoniker: {0}", TargetMoniker);

            foreach (var dir in ReferenceAssembliesDirectory.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
            {
                resolver.SearchDirectories.Add(dir);
            }

            var assemblies = new HashSet <string> ();

            var topAssemblyReferences = new List <AssemblyDefinition> ();
            var logger = new NuGetLogger((s) => {
                LogDebugMessage("{0}", s);
            });

            LockFile lockFile = null;

            if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
            {
                lockFile = LockFileUtilities.GetLockFile(ProjectAssetFile, logger);
            }

            try {
                foreach (var assembly in Assemblies)
                {
                    var assembly_path = Path.GetDirectoryName(assembly.ItemSpec);

                    if (!resolver.SearchDirectories.Contains(assembly_path))
                    {
                        resolver.SearchDirectories.Add(assembly_path);
                    }

                    // Add each user assembly and all referenced assemblies (recursive)
                    var assemblyDef = resolver.Load(assembly.ItemSpec);
                    if (assemblyDef == null)
                    {
                        throw new InvalidOperationException("Failed to load assembly " + assembly.ItemSpec);
                    }
                    if (MonoAndroidHelper.IsReferenceAssembly(assemblyDef))
                    {
                        // Resolve "runtime" library
                        if (lockFile != null)
                        {
                            assemblyDef = ResolveRuntimeAssemblyForReferenceAssembly(lockFile, resolver, assemblyDef.Name);
                        }
                        if (lockFile == null || assemblyDef == null)
                        {
                            LogWarning($"Ignoring {assembly_path} as it is a Reference Assembly");
                            continue;
                        }
                    }
                    topAssemblyReferences.Add(assemblyDef);
                    assemblies.Add(Path.GetFullPath(assemblyDef.MainModule.FullyQualifiedName));
                }
            } catch (Exception ex) {
                LogError("Exception while loading assemblies: {0}", ex);
                return(false);
            }
            try {
                foreach (var assembly in topAssemblyReferences)
                {
                    AddAssemblyReferences(resolver, assemblies, assembly, true);
                }
            } catch (Exception ex) {
                LogError("Exception while loading assemblies: {0}", ex);
                return(false);
            }

            // Add I18N assemblies if needed
            AddI18nAssemblies(resolver, assemblies);

            ResolvedAssemblies = assemblies.Select(a => new TaskItem(a)).ToArray();
            ResolvedSymbols    = assemblies.Select(a => a + ".mdb").Where(a => File.Exists(a)).Select(a => new TaskItem(a)).ToArray();
            ResolvedSymbols    = ResolvedSymbols.Concat(
                assemblies.Select(a => Path.ChangeExtension(a, "pdb"))
                .Where(a => File.Exists(a) && Files.IsPortablePdb(a))
                .Select(a => new TaskItem(a)))
                                 .ToArray();
            ResolvedFrameworkAssemblies    = ResolvedAssemblies.Where(p => MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
            ResolvedUserAssemblies         = ResolvedAssemblies.Where(p => !MonoAndroidHelper.IsFrameworkAssembly(p.ItemSpec, true)).ToArray();
            ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();

            LogDebugTaskItems("  [Output] ResolvedAssemblies:", ResolvedAssemblies);
            LogDebugTaskItems("  [Output] ResolvedUserAssemblies:", ResolvedUserAssemblies);
            LogDebugTaskItems("  [Output] ResolvedFrameworkAssemblies:", ResolvedFrameworkAssemblies);
            LogDebugTaskItems("  [Output] ResolvedDoNotPackageAttributes:", ResolvedDoNotPackageAttributes);

            return(!Log.HasLoggedErrors);
        }
        void Execute(DirectoryAssemblyResolver resolver)
        {
            foreach (var dir in ReferenceAssembliesDirectory.Split(new char[] { ';' }, StringSplitOptions.RemoveEmptyEntries))
            {
                resolver.SearchDirectories.Add(dir);
            }

            var assemblies = new Dictionary <string, string> ();

            var topAssemblyReferences = new List <AssemblyDefinition> ();
            var logger = new NuGetLogger((s) => {
                LogDebugMessage("{0}", s);
            });

            LockFile lockFile = null;

            if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
            {
                lockFile = LockFileUtilities.GetLockFile(ProjectAssetFile, logger);
            }

            try {
                foreach (var assembly in Assemblies)
                {
                    var assembly_path = Path.GetDirectoryName(assembly.ItemSpec);

                    if (!resolver.SearchDirectories.Contains(assembly_path))
                    {
                        resolver.SearchDirectories.Add(assembly_path);
                    }

                    // Add each user assembly and all referenced assemblies (recursive)
                    var assemblyDef = resolver.Load(assembly.ItemSpec);
                    if (assemblyDef == null)
                    {
                        throw new InvalidOperationException("Failed to load assembly " + assembly.ItemSpec);
                    }
                    if (MonoAndroidHelper.IsReferenceAssembly(assemblyDef))
                    {
                        // Resolve "runtime" library
                        var asmFullPath = Path.GetFullPath(assembly.ItemSpec);
                        if (lockFile != null)
                        {
                            assemblyDef = ResolveRuntimeAssemblyForReferenceAssembly(lockFile, resolver, asmFullPath);
                        }
                        if (lockFile == null || assemblyDef == null)
                        {
                            LogCodedWarning("XA0107", asmFullPath, 0, "Ignoring {0} as it is a Reference Assembly", asmFullPath);
                            continue;
                        }
                    }
                    topAssemblyReferences.Add(assemblyDef);
                    assemblies [assemblyDef.Name.Name] = Path.GetFullPath(assemblyDef.MainModule.FileName);
                }
            } catch (Exception ex) {
                LogError("Exception while loading assemblies: {0}", ex);
                return;
            }
            try {
                foreach (var assembly in topAssemblyReferences)
                {
                    AddAssemblyReferences(resolver, assemblies, assembly, null);
                }
            } catch (Exception ex) {
                LogError("Exception while loading assemblies: {0}", ex);
                return;
            }

            // Add I18N assemblies if needed
            AddI18nAssemblies(resolver, assemblies);

            var mainapiLevel = MonoAndroidHelper.SupportedVersions.GetApiLevelFromFrameworkVersion(TargetFrameworkVersion);

            foreach (var item in api_levels.Where(x => mainapiLevel < x.Value))
            {
                var itemOSVersion = MonoAndroidHelper.SupportedVersions.GetFrameworkVersionFromApiLevel(item.Value);
                Log.LogCodedWarning("XA0105", ProjectFile, 0,
                                    "The $(TargetFrameworkVersion) for {0} ({1}) is greater than the $(TargetFrameworkVersion) for your project ({2}). " +
                                    "You need to increase the $(TargetFrameworkVersion) for your project.", Path.GetFileName(item.Key), itemOSVersion, TargetFrameworkVersion);
            }

            var resolvedAssemblies          = new List <ITaskItem> (assemblies.Count);
            var resolvedSymbols             = new List <ITaskItem> (assemblies.Count);
            var resolvedFrameworkAssemblies = new List <ITaskItem> (assemblies.Count);
            var resolvedUserAssemblies      = new List <ITaskItem> (assemblies.Count);

            foreach (var assembly in assemblies.Values)
            {
                var mdb = assembly + ".mdb";
                var pdb = Path.ChangeExtension(assembly, "pdb");
                if (File.Exists(mdb))
                {
                    resolvedSymbols.Add(new TaskItem(mdb));
                }
                if (File.Exists(pdb) && Files.IsPortablePdb(pdb))
                {
                    resolvedSymbols.Add(new TaskItem(pdb));
                }
                var assemblyItem = new TaskItem(assembly);
                resolvedAssemblies.Add(assemblyItem);
                if (MonoAndroidHelper.IsFrameworkAssembly(assembly, checkSdkPath: true))
                {
                    resolvedFrameworkAssemblies.Add(assemblyItem);
                }
                else
                {
                    resolvedUserAssemblies.Add(assemblyItem);
                }
            }
            ResolvedAssemblies             = resolvedAssemblies.ToArray();
            ResolvedSymbols                = resolvedSymbols.ToArray();
            ResolvedFrameworkAssemblies    = resolvedFrameworkAssemblies.ToArray();
            ResolvedUserAssemblies         = resolvedUserAssemblies.ToArray();
            ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();
        }
Пример #4
0
        void Execute(MetadataResolver resolver)
        {
            foreach (var dir in ReferenceAssembliesDirectory.Split(new char [] { ';' }, StringSplitOptions.RemoveEmptyEntries))
            {
                resolver.AddSearchDirectory(dir);
            }

            var assemblies            = new Dictionary <string, ITaskItem> (Assemblies.Length);
            var topAssemblyReferences = new List <string> (Assemblies.Length);
            var logger = new NuGetLogger((s) => {
                LogDebugMessage("{0}", s);
            });

            LockFile lockFile = null;

            if (!string.IsNullOrEmpty(ProjectAssetFile) && File.Exists(ProjectAssetFile))
            {
                lockFile = LockFileUtilities.GetLockFile(ProjectAssetFile, logger);
            }

            try {
                foreach (var assembly in Assemblies)
                {
                    // Add each user assembly and all referenced assemblies (recursive)
                    string resolved_assembly = resolver.Resolve(assembly.ItemSpec);
                    bool   refAssembly       = !string.IsNullOrEmpty(assembly.GetMetadata("NuGetPackageId")) && resolved_assembly.Contains($"{Path.DirectorySeparatorChar}ref{Path.DirectorySeparatorChar}");
                    if (refAssembly || MonoAndroidHelper.IsReferenceAssembly(resolved_assembly))
                    {
                        // Resolve "runtime" library
                        if (lockFile != null)
                        {
                            resolved_assembly = ResolveRuntimeAssemblyForReferenceAssembly(lockFile, assembly.ItemSpec);
                        }
                        if (lockFile == null || resolved_assembly == null)
                        {
                            var file = resolved_assembly ?? assembly.ItemSpec;
                            LogCodedWarning("XA0107", file, 0, Properties.Resources.XA0107_Ignoring, file);
                            continue;
                        }
                    }
                    LogDebugMessage($"Adding {resolved_assembly} to topAssemblyReferences");
                    topAssemblyReferences.Add(resolved_assembly);
                    resolver.AddSearchDirectory(Path.GetDirectoryName(resolved_assembly));
                    var taskItem = new TaskItem(assembly)
                    {
                        ItemSpec = Path.GetFullPath(resolved_assembly),
                    };
                    if (string.IsNullOrEmpty(taskItem.GetMetadata("ReferenceAssembly")))
                    {
                        taskItem.SetMetadata("ReferenceAssembly", taskItem.ItemSpec);
                    }
                    string assemblyName = Path.GetFileNameWithoutExtension(resolved_assembly);
                    assemblies [assemblyName] = taskItem;
                }
            } catch (Exception ex) {
                LogError("Exception while loading assemblies: {0}", ex);
                return;
            }
            try {
                foreach (var assembly in topAssemblyReferences)
                {
                    AddAssemblyReferences(resolver, assemblies, assembly, null);
                }
            } catch (Exception ex) {
                LogError("Exception while loading assemblies: {0}", ex);
                return;
            }

            // Add I18N assemblies if needed
            AddI18nAssemblies(resolver, assemblies);

            var mainapiLevel = MonoAndroidHelper.SupportedVersions.GetApiLevelFromFrameworkVersion(TargetFrameworkVersion);

            foreach (var item in api_levels.Where(x => mainapiLevel < x.Value))
            {
                var itemOSVersion = MonoAndroidHelper.SupportedVersions.GetFrameworkVersionFromApiLevel(item.Value);
                LogCodedWarning("XA0105", ProjectFile, 0,
                                "The $(TargetFrameworkVersion) for {0} ({1}) is greater than the $(TargetFrameworkVersion) for your project ({2}). " +
                                "You need to increase the $(TargetFrameworkVersion) for your project.", Path.GetFileName(item.Key), itemOSVersion, TargetFrameworkVersion);
            }

            var resolvedAssemblies          = new List <ITaskItem> (assemblies.Count);
            var resolvedSymbols             = new List <ITaskItem> (assemblies.Count);
            var resolvedFrameworkAssemblies = new List <ITaskItem> (assemblies.Count);
            var resolvedUserAssemblies      = new List <ITaskItem> (assemblies.Count);

            foreach (var assembly in assemblies.Values)
            {
                var mdb = assembly + ".mdb";
                var pdb = Path.ChangeExtension(assembly.ItemSpec, "pdb");
                if (File.Exists(mdb))
                {
                    resolvedSymbols.Add(new TaskItem(mdb));
                }
                if (File.Exists(pdb) && Files.IsPortablePdb(pdb))
                {
                    resolvedSymbols.Add(new TaskItem(pdb));
                }
                resolvedAssemblies.Add(assembly);
                if (MonoAndroidHelper.IsFrameworkAssembly(assembly.ItemSpec, checkSdkPath: true))
                {
                    resolvedFrameworkAssemblies.Add(assembly);
                }
                else
                {
                    resolvedUserAssemblies.Add(assembly);
                }
            }
            ResolvedAssemblies             = resolvedAssemblies.ToArray();
            ResolvedSymbols                = resolvedSymbols.ToArray();
            ResolvedFrameworkAssemblies    = resolvedFrameworkAssemblies.ToArray();
            ResolvedUserAssemblies         = resolvedUserAssemblies.ToArray();
            ResolvedDoNotPackageAttributes = do_not_package_atts.ToArray();
        }