/// <summary>
/// Extracts the package to the specified <see cref="DirectoryMap"/>
/// </summary>
/// <param name="directory"></param>
/// <param name="args"></param>
public void ExtractTo(DirectoryMap directory, TurtleExtractArgs args)
{
if (directory == null)
{
throw new ArgumentNullException("directory");
}
else if (args == null)
{
throw new ArgumentNullException("args");
}
ExtractFiles(args, delegate(ExtractorEventArgs e)
{
PackFile file = e.PackFile;
DirectoryMapFile dmf = directory.GetFile(file.RelativePath);
if ((dmf == null) || !dmf.Unmodified() || !QQnCryptoHelpers.HashComparer.Equals(dmf.FileHash, file.FileHash))
{
using (Stream s = directory.CreateFile(file.RelativePath, file.FileHash, file.FileSize))
{
QQnPath.CopyStream(e.Stream, s);
}
}
else
{
directory.UnscheduleDelete(file.RelativePath); // Make sure it stays
}
});
}
/// <summary>
/// Extracts the package to the specified directory
/// </summary>
/// <param name="directory">The directory.</param>
/// <param name="args">The args.</param>
public void ExtractTo(string directory, TurtleExtractArgs args)
{
if (string.IsNullOrEmpty(directory))
{
throw new ArgumentNullException("directory");
}
else if (args == null)
{
throw new ArgumentNullException("args");
}
if (args.UseDirectoryMap)
{
using (DirectoryMap dm = DirectoryMap.Get(directory))
{
ExtractTo(dm, args);
}
return;
}
ExtractFiles(args, delegate(ExtractorEventArgs e)
{
using (Stream s = File.Create(QQnPath.Combine(directory, e.PackFile.RelativePath)))
{
QQnPath.CopyStream(e.Stream, s);
}
});
}
/// <summary>
/// Gets log file with the specified name
/// </summary>
/// <param name="name">The name of the project or the name of the logfile</param>
/// <returns></returns>
public TBLogFile Get(string name)
{
if (string.IsNullOrEmpty(name))
{
throw new ArgumentNullException("name");
}
name = QQnPath.EnsureExtension(name, ".tbLog");
if (ContainsKey(name))
{
return(this[name]);
}
if (!string.IsNullOrEmpty(_logPath))
{
name = QQnPath.Combine(_logPath, name);
}
TBLogFile logFile = TBLogFile.Load(name);
Add(name, logFile);
return(logFile);
}
public void CreateZipAndTpz()
{
using (ZipFile zf = ZipFile.Create(QQnPath.Combine(TmpPath, "TestZip.zip")))
{
AddSomeFiles(zf);
}
AssuredStreamCreateArgs assuredArgs = new AssuredStreamCreateArgs();
assuredArgs.StrongNameKey = StrongNameKey.LoadFrom(SnkFile);
assuredArgs.FileType = "TPZ-Test";
MultipleStreamCreateArgs mutlArgs = new MultipleStreamCreateArgs();
mutlArgs.VerificationMode = VerificationMode.Full;
using (FileStream fileStream = File.Create(QQnPath.Combine(TmpPath, "TestTpz.zip")))
using (AssuredStream assuredStream = new AssuredStream(fileStream, assuredArgs))
using (MultipleStreamWriter msw = new MultipleStreamWriter(assuredStream, mutlArgs))
{
using (Stream s = msw.CreateStream())
{
s.WriteByte(255);
}
using (Stream s = msw.CreateStream())
using (ZipFile zf = ZipFile.Create(s))
{
AddSomeFiles(zf);
}
}
}
public void EnsureRelativePath()
{
Assert.That(QQnPath.EnsureRelativePath("c:\\tools", "c:/tools/t.txt"), Is.EqualTo("t.txt"));
Assert.That(QQnPath.EnsureRelativePath("c:\\tools", "c:/t.txt"), Is.EqualTo("..\\t.txt"));
Assert.That(QQnPath.EnsureRelativePath("c:\\tools", "t.txt"), Is.EqualTo("t.txt"));
Assert.That(QQnPath.EnsureRelativePath("c:\\tools", "\\banaan\\t.txt"), Is.EqualTo("..\\banaan\\t.txt"));
string currentDisk = Path.GetPathRoot(Environment.CurrentDirectory);
string otherDisk;
if (string.Equals(currentDisk, "z:\\", StringComparison.OrdinalIgnoreCase))
{
otherDisk = "z:\\";
}
else
{
otherDisk = "c:\\";
}
Assert.That(Path.Combine(otherDisk + "tools", "\\t.txt"), Is.EqualTo("\\t.txt"), "Path.Combine works like .Net 2.0");
Assert.That(Path.GetFullPath(Path.Combine(otherDisk + "tools", "\\t.txt")), Is.EqualTo(currentDisk + "t.txt"), "Path.Combine works like .Net 2.0");
Assert.That(QQnPath.Combine(otherDisk + "tools", "\\t.txt"), Is.EqualTo(otherDisk + "t.txt"), "QQnPath combines always relative");
Assert.That(QQnPath.NormalizePath("c:\\", false), Is.EqualTo("c:\\"));
}
/// <summary>
/// Gets the framework path which best matches the specified version
/// </summary>
/// <param name="frameworkVersion">The framework version.</param>
/// <returns></returns>
public static DirectoryInfo GetFrameworkDirectory(Version frameworkVersion)
{
if (frameworkVersion == null)
{
throw new ArgumentNullException("frameworkVersion");
}
string runtimeDir = QQnPath.NormalizePath(RuntimeEnvironment.GetRuntimeDirectory());
string frameworkDir = Path.GetDirectoryName(runtimeDir);
DirectoryInfo dir = new DirectoryInfo(frameworkDir);
if (!dir.Exists)
{
return(null);
}
if (frameworkVersion.Major == 4 && frameworkVersion.Minor == 5)
{
frameworkVersion = new Version(4, 0);
}
DirectoryInfo[] dirs = dir.GetDirectories("v*.*", SearchOption.TopDirectoryOnly);
int start = 2;
if (frameworkVersion.Build >= 0)
{
start = 4;
}
else if (frameworkVersion.Revision >= 0)
{
start = 3;
}
for (int i = start; i >= 2; i--)
{
string name = "v" + frameworkVersion.ToString(i);
foreach (DirectoryInfo d in dirs)
{
if (string.Equals(d.Name, name, StringComparison.InvariantCultureIgnoreCase))
{
return(d);
}
}
name += ".";
foreach (DirectoryInfo d in dirs)
{
if (d.Name.StartsWith(name, StringComparison.InvariantCultureIgnoreCase))
{
return(d);
}
}
}
return(null);
}
public void GetToolsDirectory_40_ReturnsDirectory()
{
DirectoryInfo dir = BuildTools.GetBuildToolsDirectory(new Version("4.0"));
Assert.That(dir.Name, Is.EqualTo("v4.0.30319"));
Assert.That(File.Exists(QQnPath.Combine(dir.FullName, "msbuild.exe")), "MSBuild exists");
}
private void OnExternalProjectFinished(object sender, ExternalProjectFinishedEventArgs e)
{
if (_solution == null)
{
return; // Shortcut
}
ExternalProject ep;
if (_solution.ExternalProjects.TryGetValue(e.ProjectFile, out ep))
{
ep.ProjectFinished(_solution);
return;
}
// VC Uses temporary project files; look for the real file
string dir = Path.GetDirectoryName(e.ProjectFile);
string file = Path.GetFileNameWithoutExtension(e.ProjectFile);
string ext = Path.GetExtension(e.ProjectFile);
string ext2 = Path.GetExtension(file);
if (!string.IsNullOrEmpty(ext2) && ext2.StartsWith(".tmp_", StringComparison.OrdinalIgnoreCase))
{
// PROJECT.tmp_Win32_Release.VCPROJ -> PROJECT.VCPROJ
string realProject = QQnPath.Combine(dir, Path.GetFileNameWithoutExtension(file) + ext);
// Try in memory first, as this is always faster than on disk
if (_solution.ExternalProjects.TryGetValue(realProject, out ep) && File.Exists(realProject))
{
ep.ProjectFinished(_solution);
}
}
}
/// <summary>
/// Tries to get the generated metadata item.
/// </summary>
/// <param name="metaDataName">Name of the meta data.</param>
/// <param name="value">The value.</param>
/// <returns></returns>
bool TryTransformMetaData(string metaDataName, out string value)
{
int n;
switch (metaDataName)
{
case "FullPath":
value = FullPath;
return(true);
case "RootDir":
value = Path.GetPathRoot(QQnPath.Combine(_project.ProjectPath, Include));
return(true);
case "Filename":
value = Filename;
return(true);
case "Extension":
value = Extension;
return(true);
case "RelativeDir":
n = Include.LastIndexOfAny(new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
value = (n >= 0) ? Include.Substring(0, n + 1) : "";
return(true);
case "Directory":
value = QQnPath.Combine(_project.ProjectPath, Include);
n = value.LastIndexOfAny(new char[] { Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar });
value = (n >= 0) ? Include.Substring(0, n + 1) : "";
value = value.Substring(Path.GetPathRoot(value).Length);
return(true);
case "RecursiveDir":
value = "";
return(true);
case "Identity":
value = Include;
return(true);
case "ModifiedTime":
value = new DirectoryInfo(QQnPath.Combine(_project.ProjectPath, Include)).LastWriteTime.ToString("u");
return(true);
case "CreatedTime":
value = new DirectoryInfo(QQnPath.Combine(_project.ProjectPath, Include)).CreationTime.ToString("u");
return(true);
case "AccessedTime":
value = new DirectoryInfo(QQnPath.Combine(_project.ProjectPath, Include)).LastAccessTime.ToString("u");
return(true);
default:
value = null;
return(false);
}
}
public void BuildExternal()
{
ProcessStartInfo psi = new ProcessStartInfo(MSBuild, string.Format("/nologo \"{0}\" /v:q /p:Configuration={1} \"/logger:MSBuildLogger,{2};OutputDir={3};Indent=true\"", Solution, OtherConfiguration, Logger, LoggerPath));
psi.UseShellExecute = false;
psi.RedirectStandardOutput = true;
psi.RedirectStandardError = true;
psi.CreateNoWindow = true;
using (Process p = Process.Start(psi))
{
p.WaitForExit();
string output = p.StandardOutput.ReadToEnd();
string err = p.StandardError.ReadToEnd();
Assert.That(err, Is.EqualTo(""), "MSBuild gave no error");
//Assert.That(output, Is.EqualTo(""), "MSBuild gave no output");
Assert.That(p.ExitCode, Is.EqualTo(0), "MSBuild ran successfully");
}
Assert.That(File.Exists(QQnPath.Combine(LoggerPath, "QQn.TurtleMSBuild.tbLog")), Is.True, "Logfile created");
XPathDocument doc = new XPathDocument(QQnPath.Combine(LoggerPath, "QQn.TurtleMSBuild.tbLog"));
XPathNavigator nav = doc.CreateNavigator();
XmlNamespaceManager nsMgr = new XmlNamespaceManager(nav.NameTable);
nsMgr.AddNamespace("tb", "http://schemas.qqn.nl/2007/TurtleBuild/BuildResult");
Assert.That(nav.SelectSingleNode("/tb:TurtleBuildData/tb:Configuration", nsMgr).GetAttribute("outputPath", ""), Is.Not.EqualTo(""), "outputPath is set");
//doc.CreateNavigator().SelectSingleNode("
TBLogFile file = TBLogFile.Load(QQnPath.Combine(LoggerPath, "QQn.TurtleMSBuild.tbLog"));
Assert.That(file, Is.Not.Null);
Assert.That(file.Configurations.Count, Is.GreaterThanOrEqualTo(1), "Configurations available");
Assert.That(file.Configurations[0].ProjectOutput.Items.Count, Is.GreaterThan(1));
Assert.That(file.Configurations[0].ProjectOutput.Items[0].Container, Is.SameAs(file.Configurations[0].ProjectOutput), "Container is set");
Assert.That(file.Configurations[0].Target.DebugSrc, Is.Not.Null);
using (StringWriter sw = new StringWriter())
{
using (XmlWriter xw = new XmlTextWriter(sw))
{
xw.WriteStartDocument();
xw.WriteStartElement("TurtleBuild", "q:q");
QQn.TurtleUtils.Tokens.Tokenizer.TryWriteXml(new XmlTextWriter(sw), file);
xw.WriteEndDocument();
}
string text = sw.ToString();
Assert.That(text.Length, Is.GreaterThan(100));
}
}
/// <summary>
/// Normalizes the directory.
/// </summary>
/// <param name="value">The value.</param>
/// <returns></returns>
protected static string NormalizeDirectory(string value)
{
if (value == null)
{
throw new ArgumentNullException("value");
}
return(QQnPath.NormalizeUnixPath(value, true));
}
public void CopyResources()
{
Uri uri = new Uri(typeof(AssemblyUtils).Assembly.CodeBase);
string file = uri.LocalPath;
string tmpFile = QQnPath.Combine(Path.GetTempPath(), Path.GetFileName(file));
File.Copy(file, tmpFile, true);
Assert.That(AssemblyUtils.RefreshVersionInfoFromAttributes(tmpFile, Path.GetFullPath("..\\..\\..\\..\\Libraries\\QQn.TurtleBuildUtils\\QQn.TurtleBuildUtils.snk"), null));
}
public void CalculatePackage(bool useProjectReferences)
{
string logFile = QQnPath.Combine(LoggerPath, "QQn.TurtleMSBuild.tbLog");
if (!File.Exists(logFile))
{
BuildInternal();
}
TBLogCache logCollection = new TBLogCache(LoggerPath);
logCollection.LoadAll();
PackageArgs args = new PackageArgs();
args.LogCache = logCollection;
args.BuildRoot = Path.GetDirectoryName(Solution);
args.UseProjectDependencies = useProjectReferences;
args.ProjectsToPackage.AddRange(logCollection.KeysAsFullPaths);
PackageList newPackages;
Assert.That(Packager.TryCreatePackages(args, out newPackages), "Created packages");
Assert.That(newPackages.Count, Is.EqualTo(args.ProjectsToPackage.Count), "All projects packaged");
if (Directory.Exists("f:\\extractor"))
{
Directory.Delete("f:\\extractor", true);
}
if (Directory.Exists("f:\\extractor2"))
{
Directory.Delete("f:\\extractor2", true);
}
if (!Directory.Exists("f:\\extractor"))
{
Directory.CreateDirectory("f:\\extractor");
}
if (!Directory.Exists("f:\\extractor2"))
{
Directory.CreateDirectory("f:\\extractor2");
}
foreach (TPack p in newPackages)
{
p.ExtractTo("f:\\extractor");
}
foreach (TPack p in newPackages)
{
p.ExtractTo("f:\\extractor2", true);
}
}
public BuildOrigin(TBLogFile logFile)
{
if (logFile == null)
{
throw new ArgumentNullException("logFile");
}
_log = logFile;
_projectFile = QQnPath.Combine(logFile.ProjectPath, logFile.Project.File);
}
/// <summary>
/// Tries to create packages from the specified logfiles; walking dependencies if needed.
/// </summary>
/// <param name="args">The args.</param>
/// <param name="newPackages">The new packages.</param>
/// <returns></returns>
public static bool TryCreatePackages(PackageArgs args, out PackageList newPackages)
{
if (args == null)
{
throw new ArgumentNullException("args");
}
PackageState state = new PackageState(args);
state.LoadExternalOrigins();
state.CreateBuildOrigins();
state.AddRequirements();
state.CalculateDependencies();
newPackages = new PackageList();
List <TBLogFile> filesToRun = new List <TBLogFile>(state.Logs);
while (filesToRun.Count > 0)
{
int n = 0;
for (int i = 0; i < filesToRun.Count; i++)
{
TBLogFile file = filesToRun[i];
if (state.CanPackage(file))
{
filesToRun.RemoveAt(i--);
string target = QQnPath.Combine(args.OutputDir, file.Project.Name + ".tpZip");
FileInfo targetInfo = new FileInfo(target);
TPack pack;
if (targetInfo.Exists && targetInfo.LastWriteTime > file.GetLastWriteTime())
{
pack = TPack.OpenFrom(target, VerificationMode.None);
state.SetOriginPack(file, pack.Pack);
}
else
{
pack = TPack.Create(target, state.CreateDefinition(file));
}
newPackages.Add(target, pack);
n++;
}
}
if (n == 0)
{
break; // Can't package anything
}
}
return(true);
}
/// <summary>
/// Adds the file.
/// </summary>
/// <param name="name">The name.</param>
/// <param name="include">The include.</param>
/// <param name="baseDirectory">The base directory.</param>
/// <returns></returns>
public TagItem AddFile(string name, string include, string baseDirectory)
{
baseDirectory = Path.GetFullPath(baseDirectory);
include = QQnPath.EnsureRelativePath(baseDirectory, include);
TagItem item = new TagItem(name, include);
item.Keys.Add("FileOrigin", baseDirectory);
Add(item);
return(item);
}
public void VerifyTrueName()
{
foreach (Environment.SpecialFolder sv in Enum.GetValues(typeof(Environment.SpecialFolder)))
{
string path = Environment.GetFolderPath(sv);
if (string.IsNullOrEmpty(path))
{
continue;
}
Assert.That(QQnPath.GetTruePath(path.ToUpperInvariant()), Is.Not.Null);
}
}
/// <summary>
/// Updates the version info in the file header from the attributes defined on the assembly.
/// </summary>
/// <param name="assemblyFile">The assembly.</param>
/// <param name="keyFile">The key file.</param>
/// <param name="keyContainer">The key container.</param>
/// <returns></returns>
public static bool RefreshVersionInfoFromAttributes(string assemblyFile, string keyFile, string keyContainer)
{
if (string.IsNullOrEmpty(assemblyFile))
{
throw new ArgumentNullException("assemblyFile");
}
if (!File.Exists(assemblyFile))
{
throw new FileNotFoundException("File to update not found", assemblyFile);
}
else if (!string.IsNullOrEmpty(keyFile) && !File.Exists(keyFile))
{
throw new FileNotFoundException("Keyfile not found", keyFile);
}
string tmpDir = QQnPath.Combine(Path.GetTempPath(), Guid.NewGuid().ToString());
Directory.CreateDirectory(tmpDir);
try
{
string tmpName = QQnPath.Combine(tmpDir, Path.GetFileNameWithoutExtension(assemblyFile) + ".dll");
Assembly myAssembly = typeof(AssemblyUtils).Assembly;
AppDomainSetup setup = new AppDomainSetup();
setup.ApplicationName = "TB-AttributeRefresher";
setup.ApplicationBase = Path.GetDirectoryName(new Uri(myAssembly.CodeBase).LocalPath);
setup.AppDomainInitializer = new AppDomainInitializer(OnRefreshVersionInfo);
setup.AppDomainInitializerArguments = new string[] { assemblyFile, tmpDir, tmpName };
AppDomain dom = AppDomain.CreateDomain("AttributeRefresher", myAssembly.Evidence, setup);
AppDomain.Unload(dom); // Remove locks
if (!File.Exists(tmpName))
{
return(false);
}
return(CopyFileVersionInfo(tmpName, assemblyFile, keyFile, keyContainer));
}
finally
{
if (Directory.Exists(tmpDir))
{
Directory.Delete(tmpDir, true);
}
}
}
/// <summary>
/// Ensures the specified key is relative
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
protected virtual string EnsureRelative(string key)
{
if (string.IsNullOrEmpty(key))
{
throw new ArgumentNullException("key");
}
if (string.IsNullOrEmpty(BaseDirectory))
{
return(Path.GetFullPath(key));
}
else
{
return(QQnPath.EnsureRelativePath(BaseDirectory, key));
}
}
public virtual void PostParseBuildResult()
{
if (string.IsNullOrEmpty(TargetPath) || string.IsNullOrEmpty(ProjectPath))
{
return;
}
if ((DebugSrc == null) || (DebugId == null))
{
string targetFile = GetFullPath(TargetPath);
if (QQnPath.IsAssemblyFile(targetFile) && File.Exists(targetFile))
{
DebugReference reference = AssemblyUtils.GetDebugReference(targetFile);
if (reference != null)
{
string pdbSrc = EnsureRelativePath(QQnPath.Combine(ProjectPath, Path.GetDirectoryName(TargetPath), reference.PdbFile));
FileInfo pdbTarget = new FileInfo(Path.GetFullPath(QQnPath.Combine(ProjectPath, Path.GetDirectoryName(TargetPath), Path.GetFileName(pdbSrc))));
if (pdbTarget.Exists)
{
FileInfo pdbFrom = new FileInfo(GetFullPath(pdbSrc));
if (!pdbFrom.Exists || ((pdbFrom.Length == pdbTarget.Length) && (pdbFrom.LastWriteTime == pdbTarget.LastWriteTime)))
{
pdbSrc = EnsureRelativePath(pdbTarget.FullName);
}
}
DebugSrc = pdbSrc;
DebugId = reference.DebugId;
}
else
{
string pdbFile = Path.ChangeExtension(targetFile, ".pdb");
if (ProjectOutput.ContainsKey(pdbFile) && File.Exists(pdbFile))
{
pdbFile = EnsureRelativePath(pdbFile);
DebugSrc = pdbFile;
}
}
}
}
}
public void WriteTBLog()
{
if (TargetName == null)
{
return;
}
string outDir = OutputPath;
outDir = Parameters.OutputPath ?? GetFullPath(OutputPath);
if (!Directory.Exists(outDir))
{
Directory.CreateDirectory(outDir);
}
string atPath = QQnPath.Combine(outDir, ProjectName + ".tbLog");
if (File.Exists(atPath))
{
try
{
using (FileStream fs = File.OpenRead(atPath))
{
_previousLog = new XPathDocument(fs);
}
}
catch
{
_previousLog = null;
}
}
using (StreamWriter sw = new StreamWriter(atPath, false, Encoding.UTF8))
{
XmlWriterSettings xs = new XmlWriterSettings();
xs.Indent = Parameters.Indent;
using (XmlWriter xw = XmlWriter.Create(sw, xs))
{
WriteTBLog(xw, xs.Indent);
}
}
}
/// <summary>
/// Calculates the target.
/// </summary>
/// <param name="pi">The pi.</param>
/// <returns></returns>
protected string CalculateTarget(ITaskItem pi)
{
string target = pi.GetMetadata("TargetPath");
if (!string.IsNullOrEmpty(target))
{
return(QQnPath.Combine(OutputPath, target));
}
string destinationSubDirectory = pi.GetMetadata("DestinationSubDirectory");
string filename = Path.GetFileName(pi.ItemSpec);
if (!string.IsNullOrEmpty(destinationSubDirectory))
{
return(QQnPath.Combine(OutputPath, destinationSubDirectory, filename));
}
else
{
return(QQnPath.Combine(OutputPath, filename));
}
}
/// <summary>
/// Creates the specified package
/// </summary>
/// <param name="fileName">Name of the file.</param>
/// <param name="definition">The definition.</param>
/// <returns></returns>
public static TPack Create(string fileName, Pack definition)
{
if (fileName == null)
{
throw new ArgumentNullException("fileName");
}
else if (definition == null)
{
throw new ArgumentNullException("definition");
}
AssuredStreamCreateArgs args = new AssuredStreamCreateArgs();
if (definition.StrongNameKey != null)
{
args.StrongNameKey = definition.StrongNameKey;
}
SortedFileList added = new SortedFileList();
added.BaseDirectory = "c:\\" + Guid.NewGuid();
foreach (PackContainer container in definition.Containers)
{
foreach (PackFile file in container.Files)
{
if (!QQnPath.IsRelativeSubPath(file.StreamName) || added.Contains(file.StreamName))
{
string name = Path.GetFileNameWithoutExtension(file.StreamName);
string ext = Path.GetExtension(file.StreamName);
string attempt = "_/" + name + ext;
int n = 0;
do
{
if (!added.Contains(attempt))
{
file.StreamName = attempt;
break;
}
attempt = string.Format("_/{0}.{1}.{2}", name, n++, ext);
}while (true);
}
if (file.StreamName.Contains("\\"))
{
file.StreamName = file.StreamName.Replace('\\', '/');
}
}
}
args.FileType = PackageFileType;
MultipleStreamCreateArgs msca = new MultipleStreamCreateArgs();
msca.MaximumNumberOfStreams = 4;
msca.VerificationMode = VerificationMode.None;
using (FileStream fs = File.Create(fileName, 32768))
using (AssuredStream assurance = new AssuredStream(fs, args))
using (MultipleStreamWriter msw = new MultipleStreamWriter(assurance, msca))
{
MultipleStreamArgs msa = new MultipleStreamArgs();
msa.StreamType = 0x10;
msa.Assured = true;
msa.GZipped = true;
using (XmlWriter xw = new XmlTextWriter(msw.CreateStream(msa), Encoding.UTF8))
{
xw.WriteStartDocument();
xw.WriteStartElement("TurtlePackage", "http://schemas.qqn.nl/2007/TurtlePackage");
Tokenizer.TryWriteXml(xw, definition);
xw.WriteEndDocument();
}
msa = new MultipleStreamArgs();
msa.StreamType = 0x11;
using (XmlWriter xw = new XmlTextWriter(msw.CreateStream(msa), Encoding.UTF8))
{
// TODO: Write tblog file
}
// Last stream: We add a zip file
msa = new MultipleStreamArgs();
msa.StreamType = ZipFileId; // Defined
msa.Assured = false; // Use the whole file assurance for the zip
msa.GZipped = false; // Don't compress again
using (Stream ms = msw.CreateStream(msa))
using (ZipFile zipFile = ZipFile.Create(ms))
{
zipFile.BeginUpdate();
zipFile.UseZip64 = UseZip64.Dynamic;
SetName setName = new SetName();
zipFile.NameTransform = setName;
foreach (PackContainer container in definition.Containers)
{
foreach (PackFile file in container.Files)
{
setName.NextName = file.StreamName;
Debug.Assert(File.Exists(file.FullName));
zipFile.Add(file.FullName);
}
}
zipFile.CommitUpdate();
}
}
return(TPack.OpenFrom(fileName, VerificationMode.None));
}
public void MakePackage()
{
string logFile = QQnPath.Combine(LoggerPath, "QQn.TurtleMSBuild.tbLog");
if (!File.Exists(logFile))
{
BuildInternal();
}
TBLogFile log = TBLogFile.Load(logFile);
Assert.That(!string.IsNullOrEmpty(log.Project.Name));
DebugReference reference = null;
foreach (TBLogItem item in log.Configurations[0].ProjectOutput.Items)
{
if (!item.IsShared && !item.IsCopy)
{
switch (Path.GetExtension(item.Src).ToUpperInvariant())
{
case ".PDB":
case ".DLL":
if (reference == null)
{
reference = AssemblyUtils.GetDebugReference(item.FullSrc);
Assert.That(reference, Is.Not.Null);
Assert.That(reference.PdbFile, Is.Not.Null);
}
else
{
DebugReference dr = AssemblyUtils.GetDebugReference(item.FullSrc);
Assert.That(dr, Is.Not.Null);
// Path does not have to equal; the pdb information contains the sourcepath (obj directory for c# code)
Assert.That(Path.GetFileName(dr.PdbFile), Is.EqualTo(Path.GetFileName(reference.PdbFile)));
Assert.That(dr.DebugId, Is.EqualTo(reference.DebugId));
}
break;
}
}
}
Pack pack = null;
Assert.That(PackUtils.TryCreatePack(log, out pack));
string path = QQnPath.Combine(PackagePath, "QQn.TurtleMSBuild.tpZip");
TPack tp = TPack.Create(path, pack);
using (TPack pkg = TPack.OpenFrom(path, VerificationMode.Full))
using (DirectoryMap dm = DirectoryMap.Get(ExtractPath))
{
Assert.That(pkg, Is.Not.Null);
pkg.ExtractTo(dm);
}
using (TPack pkg = TPack.OpenFrom(path, VerificationMode.Full))
{
Assert.That(pkg, Is.Not.Null);
pkg.ExtractTo(ExtractPath);
}
}
private static string GenerateAttributeAssembly(Assembly assembly, string outputDirectory)
{
AssemblyName srcName = new AssemblyName(assembly.FullName);
if (srcName == null || string.IsNullOrEmpty(srcName.Name))
{
return(null);
}
try
{
// Prepare dynamic assembly for resources
AssemblyName asmName = new AssemblyName(srcName.FullName);
asmName.Name = "Tmp." + srcName.Name;
// Only create an on-disk assembly. We never have to execute anything
AssemblyBuilder newAssembly = AppDomain.CurrentDomain.DefineDynamicAssembly(asmName, AssemblyBuilderAccess.ReflectionOnly, outputDirectory);
string tmpFile = srcName.Name + ".dll";
newAssembly.DefineDynamicModule(asmName.Name, tmpFile);
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve += new ResolveEventHandler(OnReflectionOnlyAssemblyResolve);
try
{
Assembly mscorlib = Assembly.ReflectionOnlyLoad(typeof(int).Assembly.FullName);
Assembly system = Assembly.ReflectionOnlyLoad(typeof(Uri).Assembly.FullName);
bool hasInformationalVersion = false;
bool hasVersion = false;
foreach (CustomAttributeData attr in CustomAttributeData.GetCustomAttributes(assembly))
{
if ((attr.NamedArguments.Count > 0) || (attr.Constructor == null))
{
// We don't use named arguments at this time; not needed for the version resources
continue;
}
Type type = attr.Constructor.ReflectedType;
if (type.Assembly != mscorlib && type.Assembly != system)
{
continue;
}
if (type.Assembly == mscorlib)
{
switch (type.Name)
{
case "System.Reflection.AssemblyInformationalVersionAttribute":
hasInformationalVersion = true;
break;
case "System.Reflection.AssemblyVersionAttribute":
hasVersion = true;
break;
}
}
List <object> values = new List <object>();
foreach (CustomAttributeTypedArgument arg in attr.ConstructorArguments)
{
values.Add(arg.Value);
}
CustomAttributeBuilder cb = new CustomAttributeBuilder(attr.Constructor, values.ToArray());
newAssembly.SetCustomAttribute(cb);
}
if (!hasVersion)
{
newAssembly.SetCustomAttribute(
new CustomAttributeBuilder(typeof(AssemblyVersionAttribute).GetConstructor(new Type[] { typeof(String) }),
new object[] { srcName.Version.ToString() }));
}
if (!hasInformationalVersion)
{
newAssembly.SetCustomAttribute(
new CustomAttributeBuilder(typeof(AssemblyInformationalVersionAttribute).GetConstructor(new Type[] { typeof(String) }),
new object[] { srcName.Version.ToString() }));
}
newAssembly.SetCustomAttribute(
new CustomAttributeBuilder(typeof(AssemblyCultureAttribute).GetConstructor(new Type[] { typeof(String) }),
new object[] { "" }));
}
finally
{
AppDomain.CurrentDomain.ReflectionOnlyAssemblyResolve -= new ResolveEventHandler(OnReflectionOnlyAssemblyResolve);
}
newAssembly.DefineVersionInfoResource();
newAssembly.Save(tmpFile);
return(QQnPath.Combine(outputDirectory, tmpFile));
}
catch (FileLoadException)
{
return(null);
}
catch (IOException)
{
return(null);
}
}
/// <summary>
/// Makes a relative path from the path
/// </summary>
/// <param name="include">The include.</param>
/// <returns></returns>
public string EnsureRelativePath(string include)
{
return(QQnPath.EnsureRelativePath(ProjectPath, include));
}
public string GetFullPath(string include)
{
return(Path.GetFullPath(QQnPath.Combine(ProjectPath, include)));
}
public override void ApplyProjectDependencies(PackageState state)
{
if (!state.DontUseProjectDependencies) // Allow disabling for testing
{
// Add an initial set of dependencies directly from the project files
foreach (TBLogConfiguration config in LogFile.Configurations)
{
foreach (TBLogItem project in config.References.Projects)
{
string src = QQnPath.NormalizePath(project.FullSrc);
foreach (Origin o in state.Origins)
{
BuildOrigin bo = o as BuildOrigin;
if (bo == null)
{
continue;
}
if (QQnPath.Equals(bo.ProjectFile, src) && !Dependencies.ContainsKey(o))
{
EnsureDependency(o, DependencyType.LinkedTo);
}
}
}
}
}
foreach (TBLogItem item in LogFile.AllProjectOutput)
{
FileData fd = state.Files[item.FullSrc];
if (!string.IsNullOrEmpty(fd.CopiedFrom))
{
FileData src;
if (state.Files.TryGetValue(fd.CopiedFrom, out src))
{
if (src.Origin != this)
{
EnsureDependency(src.Origin, item.IsCopy ? DependencyType.Required : DependencyType.LinkedTo);
}
}
}
}
foreach (TBLogItem item in LogFile.AllContents)
{
FileData fd = state.Files[item.FullSrc];
if (!string.IsNullOrEmpty(fd.CopiedFrom))
{
FileData src;
if (state.Files.TryGetValue(fd.CopiedFrom, out src))
{
if (src.Origin != this)
{
EnsureDependency(src.Origin, DependencyType.Required);
}
}
}
}
}
public Pack CreateDefinition(TBLogFile file)
{
BuildOrigin myOrigin = null;
foreach (BuildOrigin bo in BuildOrigins)
{
if (bo.LogFile == file)
{
myOrigin = bo;
break;
}
}
Pack p = new Pack();
TBLogConfiguration config = file.Configurations[0];
TBLogTarget target = config.Target;
TBLogAssembly asm = config.Assembly;
if (!string.IsNullOrEmpty(target.KeySrc))
{
p.StrongNameKey = StrongNameKey.LoadFrom(QQnPath.Combine(file.ProjectPath, target.KeySrc));
}
else if (!string.IsNullOrEmpty(target.KeyContainer))
{
p.StrongNameKey = StrongNameKey.LoadFromContainer(target.KeyContainer, false);
}
if (asm != null && !string.IsNullOrEmpty(asm.AssemblyName))
{
AssemblyName name = new AssemblyName(asm.AssemblyName);
p.Version = name.Version;
}
PackContainer po = p.Containers.AddItem("#ProjectOutput");
po.ContainerDir = config.OutputPath;
po.BaseDir = QQnPath.Combine(file.ProjectPath);
foreach (TBLogItem item in file.AllProjectOutput)
{
if (item.IsShared)
{
continue;
}
PackFile pf = po.Files.AddItem(QQnPath.EnsureRelativePath(po.BaseDir, item.FullSrc));
pf.StreamName = item.Src;
}
PackContainer ct = p.Containers.AddItem("#Content");
ct.ContainerDir = "";
po.BaseDir = file.ProjectPath;
foreach (TBLogItem item in file.AllContents)
{
if (item.IsShared)
{
continue;
}
PackFile pf = po.Files.AddItem(QQnPath.EnsureRelativePath(po.BaseDir, item.FullSrc));
}
myOrigin.Pack = p;
return(p);
}
/// <summary>
/// Ensures the specified key is relative
/// </summary>
/// <param name="key">The key.</param>
/// <returns></returns>
protected override string EnsureRelative(string key)
{
return(QQnPath.EnsureExtension(base.EnsureRelative(key), ".tbLog"));
}
