void AddDependenciesFirst(LibraryProject lib, List <LibraryProject> list, HashSet <LibraryProject> added, HashSet <LibraryProject> dirty)
{
if (added.Contains(lib))
{
return;
}
added.Add(lib);
// Only build dirty packages to avoid doing too much work
if (!dirty.Contains(lib))
{
return;
}
foreach (var e in lib.References)
{
foreach (var dependency in _libMap.GetList(e))
{
AddDependenciesFirst(dependency, list, added, dirty);
}
}
list.Add(lib);
}
LibraryProject(LibraryProject lib, string versionDir)
{
Project = lib.Project;
PackageDirectory = lib.PackageDirectory;
VersionDirectory = versionDir;
CacheDirectory = Path.Combine(VersionDirectory, ".uno");
ConfigFile = Path.Combine(CacheDirectory, "config");
PackageFile = Path.Combine(CacheDirectory, "package");
}
string GetBuildDirectory(Project project, out bool isUpToDate)
{
var original = project.GetOutputDirectory(Configuration, _target);
var info = new BuildFile(original);
if (!info.Exists)
{
try
{
var upper = project.FullPath.ToUpperInvariant();
foreach (var source in _libBuilder.GetSourceDirectories(project.Config))
{
if (upper.StartsWith(source.ToUpperInvariant()))
{
var lib = new LibraryProject(project, source);
if (!lib.Exists ||
lib.Configuration != Configuration)
{
goto RETURN_ORIGINAL;
}
var time = lib.LastBuildTime;
if (File.GetLastWriteTime(project.FullPath) >= time)
{
goto RETURN_ORIGINAL;
}
var root = project.RootDirectory;
foreach (var file in project.AllFiles)
{
if (File.GetLastWriteTime(Path.Combine(root, file.NativePath)) >= time)
{
goto RETURN_ORIGINAL;
}
}
// Found up-to-date build
isUpToDate = true;
return(lib.VersionDirectory);
}
}
}
catch (Exception e)
{
Log.Trace(e);
Log.Warning("GetBuildDirectory() failed: " + e.Message);
}
}
RETURN_ORIGINAL:
isUpToDate = false;
return(original);
}
void Build(LibraryProject lib, PackageCache packageCache, List <LibraryProject> failed)
{
var buildLog = Log.GetQuieterLog(SilentBuild);
if (Clean)
{
new ProjectCleaner(buildLog).Clean(lib.Project);
_disk.DeleteDirectory(lib.PackageDirectory);
}
else if (Directory.Exists(lib.PackageDirectory))
{
// Remove old versions
foreach (var dir in Directory.EnumerateDirectories(lib.PackageDirectory))
{
if (dir != lib.VersionDirectory)
{
_disk.DeleteDirectory(dir, true);
}
}
_disk.DeleteDirectory(Path.Combine(lib.CacheDirectory));
}
var fail = TryGetFailedReference(lib, failed);
if (fail != null)
{
Log.Message("Skipping because " + fail.Quote() + " failed to build");
failed.Add(lib);
return;
}
var result = new ProjectBuilder(
buildLog,
_target,
new BuildOptions
{
Configuration = GetConfiguration(lib),
OutputDirectory = lib.VersionDirectory,
PackageCache = packageCache,
Force = true
})
.Build(lib.Project);
if (result.ErrorCount > 0)
{
failed.Add(lib);
}
}
LibraryProject TryGetFailedReference(LibraryProject lib, List <LibraryProject> failed)
{
if (failed.Count > 0)
{
foreach (var e in lib.References)
{
foreach (var dependency in _libMap.GetList(e))
{
if (failed.Contains(dependency))
{
return(dependency);
}
}
}
}
return(null);
}
public bool TryGetExistingBuild(out LibraryProject existing)
{
existing = null;
if (!Directory.Exists(PackageDirectory))
{
return(false);
}
var versions = Directory.EnumerateDirectories(PackageDirectory).ToArray();
if (versions.Length != 1)
{
return(false);
}
existing = new LibraryProject(this, versions[0]);
return(true);
}
bool HasDirtyDependency(LibraryProject lib)
{
try
{
foreach (var e in lib.References)
{
if (_dirty.Contains(e))
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty reference: " + e);
return(true);
}
}
}
catch (Exception e)
{
Log.Event(IOEvent.Build, lib.Project.Name, "exception: " + e.Message);
return(true);
}
return(false);
}
BuildConfiguration GetConfiguration(LibraryProject lib)
{
if (Configuration != null)
{
return(Configuration.Value);
}
try
{
if (File.Exists(lib.ConfigFile))
{
return(lib.Configuration);
}
}
catch (Exception e)
{
Log.Trace(e);
Log.Warning(lib.ConfigFile.ToRelativePath() + ": " + e.Message);
}
return(BuildConfiguration.Debug);
}
bool IsDirty(LibraryProject lib)
{
try
{
// Marked by command-line & EnumerateDirty()
if (_dirty.Contains(lib.ToUpperInvariant()))
{
return(true);
}
if (!File.Exists(lib.PackageFile))
{
Log.Event(IOEvent.Build, lib.Project.Name, "package not found");
return(true);
}
if (Directory.EnumerateDirectories(lib.PackageDirectory).Count() > 1)
{
Log.Event(IOEvent.Build, lib.Project.Name, "old version(s) found");
return(true);
}
if (Configuration != null && (
!File.Exists(lib.ConfigFile) ||
File.ReadAllText(lib.ConfigFile).Trim() != Configuration.ToString()
))
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty config");
return(true);
}
if (File.GetLastWriteTime(lib.Project.FullPath) > lib.LastBuildTime)
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty project");
return(true);
}
foreach (var e in lib.Project.GetFlattenedItems())
{
var file = Path.Combine(lib.Project.RootDirectory, e.Value);
if (File.Exists(file) && File.GetLastWriteTime(file) > lib.LastBuildTime)
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty file: " + e.Value);
return(true);
}
}
// Don't waste time on dependencies in express mode
if (Express)
{
return(false);
}
foreach (var e in lib.References)
{
foreach (var dependency in _libMap.GetList(e))
{
if (dependency.LastBuildTime > lib.LastBuildTime)
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty dependency: " + dependency.Project.Name);
Log.UltraVerbose("dependency: " + dependency.LastBuildTime + ", lib: " + lib.LastBuildTime);
return(true);
}
}
}
}
catch (Exception e)
{
Log.Event(IOEvent.Build, lib.Project.Name, "exception: " + e.Message);
return(true);
}
return(false);
}
bool IsDirty(LibraryProject lib)
{
try
{
// Marked by command-line & EnumerateDirty()
if (_dirty.Contains(lib.ToUpperInvariant()))
{
return(true);
}
// Check if a build with a different version number exists, possibly
// the project is already built using 'uno doctor --version=X.Y.Z'.
LibraryProject existing;
if (string.IsNullOrEmpty(Version) && lib.TryGetExistingBuild(out existing))
{
// Test the existing build and maybe we don't need to built it again.
lib = existing;
}
if (!File.Exists(lib.PackageFile))
{
Log.Event(IOEvent.Build, lib.Project.Name, "package not found");
return(true);
}
if (Directory.EnumerateDirectories(lib.PackageDirectory).Count() > 1)
{
Log.Event(IOEvent.Build, lib.Project.Name, "old version(s) found");
return(true);
}
if (Configuration != null && (
!File.Exists(lib.ConfigFile) ||
File.ReadAllText(lib.ConfigFile).Trim() != Configuration.ToString()
))
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty config");
return(true);
}
if (File.GetLastWriteTime(lib.Project.FullPath) > lib.LastBuildTime)
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty project");
return(true);
}
foreach (var e in lib.Project.GetFlattenedItems())
{
var file = Path.Combine(lib.Project.RootDirectory, e.Value);
if (File.Exists(file) && File.GetLastWriteTime(file) > lib.LastBuildTime)
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty file: " + e.Value);
return(true);
}
}
// Don't waste time on dependencies in express mode
if (Express)
{
return(false);
}
foreach (var e in lib.References)
{
foreach (var dependency in _libMap.GetList(e))
{
if (dependency.LastBuildTime > lib.LastBuildTime)
{
Log.Event(IOEvent.Build, lib.Project.Name, "dirty dependency: " + dependency.Project.Name);
Log.UltraVerbose("dependency: " + dependency.LastBuildTime + ", lib: " + lib.LastBuildTime);
return(true);
}
}
}
}
catch (Exception e)
{
Log.Event(IOEvent.Build, lib.Project.Name, "exception: " + e.Message);
return(true);
}
return(false);
}
