Add serviceable property to lock file

Author: ChengTian

misc/ServicingTestProjects/ServiceableLib1/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Reflection;
+
+[assembly: AssemblyMetadata("Serviceable", "True")]

misc/ServicingTestProjects/ServiceableLib1/Class1.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace ServiceableLib1
+{
+    public class Class1
+    {
+        public Class1()
+        {
+
+        }
+    }
+}

misc/ServicingTestProjects/ServiceableLib1/project.json

@@ -0,0 +1,7 @@
+{
+    "version": "1.0.0",
+
+    "frameworks" : {
+        "dnx451" : {}
+    }
+}

misc/ServicingTestProjects/UnserviceableLib1/AssemblyInfo.cs

@@ -0,0 +1,3 @@
+using System.Reflection;
+
+[assembly: AssemblyMetadata("Serviceable", "False")]

misc/ServicingTestProjects/UnserviceableLib1/Class1.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace UnserviceableLib1
+{
+    public class Class1
+    {
+        public Class1()
+        {
+
+        }
+    }
+}

misc/ServicingTestProjects/UnserviceableLib1/project.json

@@ -0,0 +1,7 @@
+{
+    "version": "1.0.0",
+
+    "frameworks" : {
+        "dnx451" : {}
+    }
+}

misc/ServicingTestProjects/UnserviceableLib2/Class1.cs

@@ -0,0 +1,12 @@
+using System;
+
+namespace UnserviceableLib2
+{
+    public class Class1
+    {
+        public Class1()
+        {
+
+        }
+    }
+}

misc/ServicingTestProjects/UnserviceableLib2/project.json

@@ -0,0 +1,7 @@
+{
+    "version": "1.0.0",
+
+    "frameworks" : {
+        "dnx451" : {}
+    }
+}

src/Microsoft.Framework.PackageManager/Bundle/BundleProject.cs

@@ -390,7 +390,8 @@ private void UpdateLockFile(BundleRoot root)
                         project,
                         package,
                         sha512,
-                        project.GetTargetFrameworks().Select(f => f.FrameworkName)));
+                        project.GetTargetFrameworks().Select(f => f.FrameworkName),
+                        resolver));
                 }
             }
 

src/Microsoft.Framework.PackageManager/Restore/RestoreCommand.cs

@@ -697,7 +697,12 @@ private void WriteLockFile(string projectLockFilePath, Runtime.Project project,
                     }
 
                     var package = packageInfo.Package;
-                    var lockFileLib = LockFileUtils.CreateLockFileLibraryForProject(project, package, sha512, frameworks);
+                    var lockFileLib = LockFileUtils.CreateLockFileLibraryForProject(
+                        project,
+                        package,
+                        sha512,
+                        frameworks,
+                        new DefaultPackagePathResolver(repository.RepositoryRoot));
 
                     lockFile.Libraries.Add(lockFileLib);
                 }

src/Microsoft.Framework.PackageManager/Utils/LockFileUtils.cs

@@ -3,16 +3,22 @@
 using System.Collections.Generic;
 using System.Linq;
 using System.IO;
+using System.Reflection.Metadata;
+using System.Reflection.PortableExecutable;
 using System.Runtime.Versioning;
 using NuGet;
 using Microsoft.Framework.Runtime.DependencyManagement;
-using Microsoft.Framework.Runtime;
 
 namespace Microsoft.Framework.PackageManager.Utils
 {
     internal static class LockFileUtils
     {
-        public static LockFileLibrary CreateLockFileLibraryForProject(Runtime.Project project, IPackage package, SHA512 sha512, IEnumerable<FrameworkName> frameworks)
+        public static LockFileLibrary CreateLockFileLibraryForProject(
+            Runtime.Project project,
+            IPackage package,
+            SHA512 sha512,
+            IEnumerable<FrameworkName> frameworks,
+            IPackagePathResolver resolver)
         {
             var lockFileLib = new LockFileLibrary();
             lockFileLib.Name = package.Id;
@@ -86,6 +92,17 @@ public static LockFileLibrary CreateLockFileLibraryForProject(Runtime.Project pr
                 lockFileLib.FrameworkGroups.Add(group);
             }
 
+            var installPath = resolver.GetInstallPath(package.Id, package.Version);
+            foreach (var assembly in lockFileLib.FrameworkGroups.SelectMany(f => f.RuntimeAssemblies))
+            {
+                var assemblyPath = Path.Combine(installPath, assembly);
+                if (IsAssemblyServiceable(assemblyPath))
+                {
+                    lockFileLib.IsServiceable = true;
+                    break;
+                }
+            }
+
             return lockFileLib;
         }
 
@@ -129,5 +146,102 @@ private static List<string> GetPackageAssemblies(IPackage package, FrameworkName
             return results;
         }
 
+        internal static bool IsAssemblyServiceable(string assemblyPath)
+        {
+            if (!File.Exists(assemblyPath))
+            {
+                return false;
+            }
+
+            using (var stream = File.OpenRead(assemblyPath))
+            using (var peReader = new PEReader(stream))
+            {
+                var mdReader = peReader.GetMetadataReader();
+                var attrs = mdReader.GetAssemblyDefinition().GetCustomAttributes()
+                    .Select(ah => mdReader.GetCustomAttribute(ah));
+
+                foreach (var attr in attrs)
+                {
+                    var ctorHandle = attr.Constructor;
+                    if (ctorHandle.Kind != HandleKind.MemberReference)
+                    {
+                        continue;
+                    }
+
+                    var container = mdReader.GetMemberReference((MemberReferenceHandle)ctorHandle).Parent;
+                    var name = mdReader.GetTypeReference((TypeReferenceHandle)container).Name;
+                    if (!string.Equals(mdReader.GetString(name), "AssemblyMetadataAttribute"))
+                    {
+                        continue;
+                    }
+
+                    var arguments = GetFixedStringArguments(mdReader, attr);
+                    if (arguments.Count == 2 &&
+                        string.Equals(arguments[0], "Serviceable", StringComparison.OrdinalIgnoreCase) &&
+                        string.Equals(arguments[1], "True", StringComparison.OrdinalIgnoreCase))
+                    {
+                        return true;
+                    }
+                }
+            }
+
+            return false;
+        }
+
+        /// <summary>
+        /// Gets the fixed (required) string arguments of a custom attribute.
+        /// Only attributes that have only fixed string arguments.
+        /// </summary>
+        private static List<string> GetFixedStringArguments(MetadataReader reader, CustomAttribute attribute)
+        {
+            // TODO: Nick Guerrera ([email protected]) hacked this method for temporary use.
+            // There is a blob decoder feature in progress but it won't ship in time for our milestone.
+            // Replace this method with the blob decoder feature when later it is availale.
+
+            var signature = reader.GetMemberReference((MemberReferenceHandle)attribute.Constructor).Signature;
+            var signatureReader = reader.GetBlobReader(signature);
+            var valueReader = reader.GetBlobReader(attribute.Value);
+            var arguments = new List<string>();
+
+            var prolog = valueReader.ReadUInt16();
+            if (prolog != 1)
+            {
+                // Invalid custom attribute prolog
+                return arguments;
+            }
+
+            var header = signatureReader.ReadSignatureHeader();
+            if (header.Kind != SignatureKind.Method || header.IsGeneric)
+            {
+                // Invalid custom attribute constructor signature
+                return arguments;
+            }
+
+            int parameterCount;
+            if (!signatureReader.TryReadCompressedInteger(out parameterCount))
+            {
+                // Invalid custom attribute constructor signature
+                return arguments;
+            }
+
+            var returnType = signatureReader.ReadSignatureTypeCode();
+            if (returnType != SignatureTypeCode.Void)
+            {
+                // Invalid custom attribute constructor signature
+                return arguments;
+            }
+
+            for (int i = 0; i < parameterCount; i++)
+            {
+                var signatureTypeCode = signatureReader.ReadSignatureTypeCode();
+                if (signatureTypeCode == SignatureTypeCode.String)
+                {
+                    // Custom attribute constructor must take only strings
+                    arguments.Add(valueReader.ReadSerializedString());
+                }
+            }
+
+            return arguments;
+        }
     }
 }

src/Microsoft.Framework.Runtime/DependencyManagement/LockFileFormat.cs

@@ -14,7 +14,7 @@ namespace Microsoft.Framework.Runtime.DependencyManagement
 {
     public class LockFileFormat
     {
-        public const int Version = -9999;
+        public const int Version = -9998;
         public const string LockFileName = "project.lock.json";
 
         public LockFile Read(string filePath)
@@ -108,6 +108,7 @@ private LockFileLibrary ReadLibrary(string property, JToken json)
             {
                 library.Version = SemanticVersion.Parse(parts[1]);
             }
+            library.IsServiceable = ReadBool(json, "serviceable", defaultValue: false);
             library.Sha = ReadString(json["sha"]);
             library.FrameworkGroups = ReadObject(json["frameworks"] as JObject, ReadFrameworkGroup);
             library.Files = ReadPathArray(json["files"] as JArray, ReadString);
@@ -117,6 +118,7 @@ private LockFileLibrary ReadLibrary(string property, JToken json)
         private JProperty WriteLibrary(LockFileLibrary library)
         {
             var json = new JObject();
+            WriteBool(json, "serviceable", library.IsServiceable);
             json["sha"] = WriteString(library.Sha);
             WriteObject(json, "frameworks", library.FrameworkGroups, WriteFrameworkGroup);
             WritePathArray(json, "files", library.Files, WriteString);

src/Microsoft.Framework.Runtime/DependencyManagement/LockFileLibrary.cs

@@ -14,6 +14,8 @@ public class LockFileLibrary
 
         public SemanticVersion Version { get; set; }
 
+        public bool IsServiceable { get; set; }
+
         public string Sha { get; set; }
 
         public IList<LockFileFrameworkGroup> FrameworkGroups { get; set; } = new List<LockFileFrameworkGroup>();

src/Microsoft.Framework.Runtime/Servicing/Breadcrumbs.cs

@@ -63,8 +63,7 @@ public bool IsPackageServiceable(PackageInfo package)
                 return false;
             }
 
-            // TODO: Figure out what makes a package serviceable
-            return false;
+            return package.LockFileLibrary.IsServiceable;
         }
 
         public void AddBreadcrumb(string packageId, SemanticVersion packageVersion)

test/Microsoft.Framework.PackageManager.FunctionalTests/KpmBundleTests.cs

@@ -1088,6 +1088,7 @@ public void BundleWithNoSourceOptionGeneratesLockFileOnClr(string flavor, string
   },
   ""libraries"": {
     ""NoDependencies/1.0.0"": {
+      ""serviceable"": false,
       ""sha"": ""NUPKG_SHA_VALUE"",
       ""frameworks"": {
         ""DNX,Version=v4.5.1"": {
@@ -1191,6 +1192,7 @@ public void BundleWithNoSourceOptionUpdatesLockFileOnClr(string flavor, string o
   },
   ""libraries"": {
     ""NoDependencies/1.0.0"": {
+      ""serviceable"": false,
       ""sha"": ""NUPKG_SHA_VALUE"",
       ""frameworks"": {
         ""DNX,Version=v4.5.1"": {

test/Microsoft.Framework.PackageManager.Tests/LockFileUtilsFacts.cs

@@ -0,0 +1,39 @@
+// Copyright (c) Microsoft Open Technologies, Inc. All rights reserved.
+// Licensed under the Apache License, Version 2.0. See License.txt in the project root for license information.
+
+using System.IO;
+using Microsoft.Framework.Runtime;
+using Microsoft.Framework.FunctionalTestUtils;
+using Microsoft.Framework.PackageManager.Utils;
+using Xunit;
+
+namespace Microsoft.Framework.PackageManager.Tests
+{
+    public class LockFileUtilsFacts
+    {
+        [Theory]
+        [InlineData("ServiceableLib1", true)]
+        [InlineData("UnserviceableLib1", false)]
+        [InlineData("UnserviceableLib2", false)]
+        public void BuildPackageAndCheckServiceability(string projectName, bool expectedServiceability)
+        {
+            var rootDir = ProjectResolver.ResolveRootDirectory(Directory.GetCurrentDirectory());
+            var projectDir = Path.Combine(rootDir, "misc", "ServicingTestProjects", projectName);
+            const string configuration = "Debug";
+
+            using (var runtimeHomeDir = TestUtils.GetRuntimeHomeDir(flavor: "clr", os: "win", architecture: "x86"))
+            using (var tempDir = new DisposableDir())
+            {
+                var buildOutpuDir = Path.Combine(tempDir, "output");
+
+                KpmTestUtils.ExecKpm(
+                    runtimeHomeDir,
+                    "pack",
+                    $"{projectDir} --out {buildOutpuDir} --configuration {configuration}");
+
+                var assemblyPath = Path.Combine(buildOutpuDir, configuration, "dnx451", $"{projectName}.dll");
+                Assert.Equal(expectedServiceability, LockFileUtils.IsAssemblyServiceable(assemblyPath));
+            }
+        }
+    }
+}

test/Microsoft.Framework.PackageManager.Tests/project.json

@@ -1,6 +1,8 @@
 {
     "dependencies": {
+        "Microsoft.Framework.FunctionalTestUtils": "1.0.0-*",
         "Microsoft.Framework.PackageManager": "1.0.0-*",
+        "Microsoft.Framework.PackageManager.FunctionalTests": "1.0.0-*",
         "Microsoft.Framework.Runtime.Common": "1.0.0-*",
         "xunit.runner.aspnet": "2.0.0-aspnet-*"
     },