/// <summary>
/// Prefetch multiple directories in parallel
/// </summary>
/// <param name="Directories">The directories to cache</param>
private static void PrefetchRulesFiles(IEnumerable <DirectoryReference> Directories)
{
ThreadPoolWorkQueue Queue = null;
try
{
foreach (DirectoryReference Directory in Directories)
{
if (!RootFolderToRulesFileCache.ContainsKey(Directory))
{
RulesFileCache Cache = new RulesFileCache();
RootFolderToRulesFileCache[Directory] = Cache;
if (Queue == null)
{
Queue = new ThreadPoolWorkQueue();
}
DirectoryItem DirectoryItem = DirectoryItem.GetItemByDirectoryReference(Directory);
Queue.Enqueue(() => FindAllRulesFilesRecursively(DirectoryItem, Cache, Queue));
}
}
}
finally
{
if (Queue != null)
{
Queue.Dispose();
Queue = null;
}
}
}
/// <summary>
/// Finds all the rules of the given type under a given directory
/// </summary>
/// <param name="Directory">Directory to search</param>
/// <param name="Type">Type of rules to return</param>
/// <returns>List of rules files of the given type</returns>
private static IReadOnlyList <FileReference> FindAllRulesFiles(DirectoryReference Directory, RulesFileType Type)
{
// Check to see if we've already cached source files for this folder
RulesFileCache Cache;
if (!RootFolderToRulesFileCache.TryGetValue(Directory, out Cache))
{
Cache = new RulesFileCache();
using (ThreadPoolWorkQueue Queue = new ThreadPoolWorkQueue())
{
DirectoryItem BaseDirectory = DirectoryItem.GetItemByDirectoryReference(Directory);
Queue.Enqueue(() => FindAllRulesFilesRecursively(BaseDirectory, Cache, Queue));
}
RootFolderToRulesFileCache[Directory] = Cache;
}
// Get the list of files of the type we're looking for
if (Type == RulesCompiler.RulesFileType.Module)
{
return(Cache.ModuleRules);
}
else if (Type == RulesCompiler.RulesFileType.Target)
{
return(Cache.TargetRules);
}
else if (Type == RulesCompiler.RulesFileType.AutomationModule)
{
return(Cache.AutomationModules);
}
else
{
throw new BuildException("Unhandled rules type: {0}", Type);
}
}
/// <summary>
/// Enqueue a directory tree for prefetching
/// </summary>
/// <param name="Directory">Directory to start searching from</param>
public static void QueueDirectoryTree(DirectoryReference Directory)
{
lock (QueuedDirectories)
{
if (QueuedDirectories.Add(Directory))
{
Enqueue(() => ScanDirectoryTree(DirectoryItem.GetItemByDirectoryReference(Directory)));
}
}
}
/// <summary>
/// Enqueue a project directory for prefetching
/// </summary>
/// <param name="ProjectDirectory">The project directory to prefetch</param>
public static void QueueProjectDirectory(DirectoryReference ProjectDirectory)
{
lock (QueuedDirectories)
{
if (QueuedDirectories.Add(ProjectDirectory))
{
Enqueue(() => ScanProjectDirectory(DirectoryItem.GetItemByDirectoryReference(ProjectDirectory)));
}
}
}
/// <summary>
/// Scans a project directory, adding tasks for subdirectories
/// </summary>
/// <param name="ProjectDirectory">The project directory to search</param>
static void ScanProjectDirectory(DirectoryItem ProjectDirectory)
{
foreach (DirectoryReference ExtensionDir in UnrealBuildTool.GetExtensionDirs(UnrealBuildTool.EngineDirectory))
{
DirectoryItem BaseDirectory = DirectoryItem.GetItemByDirectoryReference(ExtensionDir);
BaseDirectory.CacheDirectories();
DirectoryItem BasePluginsDirectory = DirectoryItem.Combine(ProjectDirectory, "Plugins");
Enqueue(() => ScanPluginFolder(BasePluginsDirectory));
DirectoryItem BaseSourceDirectory = DirectoryItem.Combine(ProjectDirectory, "Source");
Enqueue(() => ScanDirectoryTree(BaseSourceDirectory));
}
}
/// <summary>
/// Scans the engine directory, adding tasks for subdirectories
/// </summary>
static void ScanEngineDirectory()
{
DirectoryItem EngineDirectory = DirectoryItem.GetItemByDirectoryReference(UnrealBuildTool.EngineDirectory);
EngineDirectory.CacheDirectories();
DirectoryItem EnginePluginsDirectory = DirectoryItem.Combine(EngineDirectory, "Plugins");
Enqueue(() => ScanPluginFolder(EnginePluginsDirectory));
DirectoryItem EngineRuntimeDirectory = DirectoryItem.GetItemByDirectoryReference(UnrealBuildTool.EngineSourceRuntimeDirectory);
Enqueue(() => ScanDirectoryTree(EngineRuntimeDirectory));
DirectoryItem EngineDeveloperDirectory = DirectoryItem.GetItemByDirectoryReference(UnrealBuildTool.EngineSourceDeveloperDirectory);
Enqueue(() => ScanDirectoryTree(EngineDeveloperDirectory));
DirectoryItem EngineEditorDirectory = DirectoryItem.GetItemByDirectoryReference(UnrealBuildTool.EngineSourceEditorDirectory);
Enqueue(() => ScanDirectoryTree(EngineEditorDirectory));
}
/// <summary>
/// Scans the engine directory, adding tasks for subdirectories
/// </summary>
static void ScanEngineDirectory()
{
foreach (DirectoryReference ExtensionDir in UnrealBuildTool.GetExtensionDirs(UnrealBuildTool.EngineDirectory))
{
DirectoryItem BaseDirectory = DirectoryItem.GetItemByDirectoryReference(ExtensionDir);
BaseDirectory.CacheDirectories();
DirectoryItem BasePluginsDirectory = DirectoryItem.Combine(BaseDirectory, "Plugins");
Enqueue(() => ScanPluginFolder(BasePluginsDirectory));
DirectoryItem BaseSourceDirectory = DirectoryItem.Combine(BaseDirectory, "Source");
BaseSourceDirectory.CacheDirectories();
DirectoryItem BaseSourceRuntimeDirectory = DirectoryItem.Combine(BaseSourceDirectory, "Runtime");
Enqueue(() => ScanDirectoryTree(BaseSourceRuntimeDirectory));
DirectoryItem BaseSourceDeveloperDirectory = DirectoryItem.Combine(BaseSourceDirectory, "Developer");
Enqueue(() => ScanDirectoryTree(BaseSourceDeveloperDirectory));
DirectoryItem BaseSourceEditorDirectory = DirectoryItem.Combine(BaseSourceDirectory, "Editor");
Enqueue(() => ScanDirectoryTree(BaseSourceEditorDirectory));
}
}
/// <summary>
/// Find paths to all the plugins under a given parent directory (recursively)
/// </summary>
/// <param name="ParentDirectory">Parent directory to look in. Plugins will be found in any *subfolders* of this directory.</param>
public static IEnumerable <FileReference> EnumeratePlugins(DirectoryReference ParentDirectory)
{
List <FileReference> FileNames;
if (!PluginFileCache.TryGetValue(ParentDirectory, out FileNames))
{
FileNames = new List <FileReference>();
DirectoryItem ParentDirectoryItem = DirectoryItem.GetItemByDirectoryReference(ParentDirectory);
if (ParentDirectoryItem.Exists)
{
using (ThreadPoolWorkQueue Queue = new ThreadPoolWorkQueue())
{
EnumeratePluginsInternal(ParentDirectoryItem, FileNames, Queue);
}
}
// Sort the filenames to ensure that the plugin order is deterministic; otherwise response files will change with each build.
FileNames = FileNames.OrderBy(x => x.FullName, StringComparer.OrdinalIgnoreCase).ToList();
PluginFileCache.Add(ParentDirectory, FileNames);
}
return(FileNames);
}
/// <summary>
/// Gets a new directory item by combining the existing directory item with the given path fragments
/// </summary>
/// <param name="BaseDirectory">Base directory to append path fragments to</param>
/// <param name="Fragments">The path fragments to append</param>
/// <returns>Directory item corresponding to the combined path</returns>
public static DirectoryItem Combine(DirectoryItem BaseDirectory, params string[] Fragments)
{
return(DirectoryItem.GetItemByDirectoryReference(DirectoryReference.Combine(BaseDirectory.Location, Fragments)));
}
/// <summary>
/// Read a directory item from a binary archive
/// </summary>
/// <param name="Reader">Reader to serialize data from</param>
/// <returns>Instance of the serialized directory item</returns>
public static DirectoryItem ReadDirectoryItem(this BinaryArchiveReader Reader)
{
return(Reader.ReadObjectReference <DirectoryItem>(() => DirectoryItem.GetItemByDirectoryReference(Reader.ReadDirectoryReference())));
}
static public void InvalidateCachedDirectory(DirectoryReference Directory)
{
DirectoryItem.GetItemByDirectoryReference(Directory).ResetCachedInfo();
}
static public IEnumerable <DirectoryReference> EnumerateDirectories(DirectoryReference Directory)
{
return(DirectoryItem.GetItemByDirectoryReference(Directory).EnumerateDirectories().Select(x => x.Location));
}
static public bool DirectoryExists(DirectoryReference Directory)
{
return(DirectoryItem.GetItemByDirectoryReference(Directory).Exists);
}
