public AssemblyMetaData GetAssemblyMetadata(string assemblyPath)
{
var data = new AssemblyMetaData();
var assemblyName = AssemblyName.GetAssemblyName(assemblyPath);
if (assemblyName == null)
{
return data;
}
// For WinRT component, we can only read Full Name.
if (assemblyName.ContentType == AssemblyContentType.WindowsRuntime)
{
data.SetFullName(assemblyName.FullName);
return data;
}
var assembly = Assembly.Load(assemblyName);
if (assembly != null)
{
data.SetFullName(assembly.FullName);
try
{
foreach (var attribute in assembly.GetCustomAttributesData())
{
if (attribute.ConstructorArguments.Count != 1 ||
attribute.ConstructorArguments[0].ArgumentType != typeof(string))
{
continue;
}
string typeName = attribute.Constructor.DeclaringType.Name;
if (typeName == "InternalsVisibleToAttribute")
{
continue;
}
string key = typeName.EndsWith("Attribute", StringComparison.OrdinalIgnoreCase)
? typeName.Substring(0, typeName.Length - 9)
: typeName;
string value = attribute.ConstructorArguments[0].Value.ToString();
if (!String.IsNullOrEmpty(value))
{
data[key] = value;
}
}
}
catch (Exception)
{
// if an exception occurs when loading custom attributes, just ignore
}
}
return data;
}
public AssemblyInfoPatchResult(string fullPath,
string fileBackupPath,
AssemblyVersion oldAssemblyVersion,
AssemblyVersion assemblyVersion,
AssemblyFileVersion oldAssemblyFileVersion,
AssemblyFileVersion assemblyFileVersion,
bool succeeded = true,
AssemblyMetaData oldAssemblyMetadata = null,
AssemblyMetaData newAssemblyMetadata = null)
{
_fullPath = fullPath;
_fileBackupPath = fileBackupPath;
_oldAssemblyVersion = oldAssemblyVersion;
_assemblyVersion = assemblyVersion;
_oldAssemblyFileVersion = oldAssemblyFileVersion;
_assemblyFileVersion = assemblyFileVersion;
_succeeded = succeeded;
_oldAssemblyMetadata = oldAssemblyMetadata;
_newAssemblyMetadata = newAssemblyMetadata;
}
public AssemblyInfoPatchResult(string fullPath,
string fileBackupPath,
AssemblyVersion oldAssemblyVersion,
AssemblyVersion assemblyVersion,
AssemblyFileVersion oldAssemblyFileVersion,
AssemblyFileVersion assemblyFileVersion,
bool succeeded = true,
AssemblyMetaData oldAssemblyMetadata = null,
AssemblyMetaData newAssemblyMetadata = null)
{
_fullPath = fullPath;
_fileBackupPath = fileBackupPath;
_oldAssemblyVersion = oldAssemblyVersion;
_assemblyVersion = assemblyVersion;
_oldAssemblyFileVersion = oldAssemblyFileVersion;
_assemblyFileVersion = assemblyFileVersion;
_succeeded = succeeded;
_oldAssemblyMetadata = oldAssemblyMetadata;
_newAssemblyMetadata = newAssemblyMetadata;
}
/// <summary>
/// From within the temporary AppDomain, use reflection, so the types are known to the anonymous function
/// </summary>
/// <param name="assemblies">A list containing the system path for all the assemblies in the domain</param>
/// <param name="func">The anonymous function</param>
/// <returns>A DataStore object which holds the information return by `func`</returns>
public DataStore Reflect(List<string> assemblies, AssemblyMetaData metaData, Func<Assembly, Type, DataStore> func)
{
var r = new DataStore { Data = new Dictionary<string, Util.CommonObject>() };
foreach (var assemblyPath in assemblies)
{
// check if the assembly is found in the internal dictionaries
if (LoadedAssemblies.ContainsKey(assemblyPath) && Proxies.ContainsKey(assemblyPath))
{
try
{
var result = Proxies[assemblyPath].Reflect(func);
foreach (var item in result.Data)
{
if (!r.Data.ContainsKey(item.Key))
r.Data.Add(item.Key, item.Value);
}
metaData.AssemblySuccess.Add(assemblyPath);
}
catch (FileNotFoundException)
{
//errors here usually occurs when the application is unable to locate an assemblys dependencies or an dependency, dependencies
metaData.AssemblyErrors.Add(assemblyPath);
}
}
}
return r;
}
public Task <ExitCode> ExecuteAsync(
ILogger logger,
IReadOnlyCollection <IVariable> buildVariables,
CancellationToken cancellationToken)
{
bool assemblyVersionPatchingEnabled =
buildVariables.GetBooleanByKey(WellKnownVariables.AssemblyFilePatchingEnabled, true);
if (!assemblyVersionPatchingEnabled)
{
logger.WriteWarning("Assembly version patching is disabled");
return(Task.FromResult(ExitCode.Success));
}
var delegateLogger = new DelegateLogger(
logger.WriteError,
logger.WriteWarning,
logger.Write,
logger.WriteVerbose,
logger.WriteDebug)
{
LogLevel = Sorbus.Core.LogLevel.TryParse(logger.LogLevel.Level)
};
var app = new AssemblyPatcherApp(delegateLogger);
_filePattern = buildVariables.GetVariableValueOrDefault(
WellKnownVariables.AssemblyFilePatchingFilePattern,
"AssemblyInfo.cs");
logger.WriteVerbose($"Using assembly version file pattern '{_filePattern}' to lookup files to patch");
string sourceRoot = buildVariables.Require(WellKnownVariables.SourceRoot).ThrowIfEmptyValue().Value;
IVariable netAssemblyVersionVar =
buildVariables.SingleOrDefault(var => var.Key == WellKnownVariables.NetAssemblyVersion);
string netAssemblyVersion;
if (netAssemblyVersionVar == null || string.IsNullOrWhiteSpace(netAssemblyVersionVar.Value))
{
logger.WriteWarning(
$"The build variable {WellKnownVariables.NetAssemblyVersion} is not defined or empty");
netAssemblyVersion = "0.0.1.0";
logger.WriteWarning($"Using fall-back version {netAssemblyVersion}");
}
else
{
netAssemblyVersion = netAssemblyVersionVar.Value;
}
var assemblyVersion = new Version(netAssemblyVersion);
IVariable netAssemblyFileVersionVar =
buildVariables.SingleOrDefault(var => var.Key == WellKnownVariables.NetAssemblyFileVersion);
string netAssemblyFileVersion;
if (string.IsNullOrWhiteSpace(netAssemblyFileVersionVar?.Value))
{
logger.WriteWarning(
$"The build variable {WellKnownVariables.NetAssemblyFileVersion} is not defined or empty");
netAssemblyFileVersion = "0.0.1.1";
logger.WriteWarning($"Using fall-back version {netAssemblyFileVersion}");
}
else
{
netAssemblyFileVersion = netAssemblyFileVersionVar.Value;
}
var assemblyFileVersion = new Version(netAssemblyFileVersion);
AssemblyMetaData assemblyMetadata = null;
if (buildVariables.GetBooleanByKey(WellKnownVariables.NetAssemblyMetadataEnabled, false))
{
string company = buildVariables.GetVariableValueOrDefault(WellKnownVariables.NetAssemblyCompany, null);
string description =
buildVariables.GetVariableValueOrDefault(WellKnownVariables.NetAssemblyDescription, null);
string configuration =
buildVariables.GetVariableValueOrDefault(WellKnownVariables.NetAssemblyConfiguration, null);
string copyright =
buildVariables.GetVariableValueOrDefault(WellKnownVariables.NetAssemblyCopyright, null);
string product = buildVariables.GetVariableValueOrDefault(WellKnownVariables.NetAssemblyProduct, null);
string trademark =
buildVariables.GetVariableValueOrDefault(WellKnownVariables.NetAssemblyTrademark, null);
assemblyMetadata = new AssemblyMetaData(
description,
configuration,
company,
product,
copyright,
trademark);
}
try
{
logger.WriteVerbose(
$"Patching assembly info files with assembly version {assemblyVersion}, assembly file version {assemblyFileVersion} for directory source root directory '{sourceRoot}'");
var sourceDirectory = new DirectoryInfo(sourceRoot);
PathLookupSpecification defaultPathLookupSpecification = DefaultPaths.DefaultPathLookupSpecification;
IReadOnlyCollection <AssemblyInfoFile> assemblyFiles = sourceDirectory
.GetFilesRecursive(new[] { ".cs" }, defaultPathLookupSpecification, sourceRoot)
.Where(file => file.Name.Equals(_filePattern, StringComparison.InvariantCultureIgnoreCase))
.Select(file => new AssemblyInfoFile(file.FullName))
.ToReadOnlyCollection();
logger.WriteDebug(string.Format(
"Using file pattern '{0}' to find assembly info files. Found these files: [{3}] {1}{2}",
_filePattern,
Environment.NewLine,
string.Join(Environment.NewLine, assemblyFiles.Select(item => " * " + item.FullPath)),
assemblyFiles.Count));
app.Patch(
new AssemblyVersion(assemblyVersion),
new AssemblyFileVersion(assemblyFileVersion),
sourceRoot,
assemblyFiles,
assemblyMetadata);
}
catch (Exception ex)
{
logger.WriteError($"Could not patch assembly infos. {ex}");
return(Task.FromResult(ExitCode.Failure));
}
return(Task.FromResult(ExitCode.Success));
}
