public FileResult SourceMap([FromServices] BundleRequestModel bundle)
{
Bundle foundBundle;
if (!_bundleManager.TryGetValue(bundle.FileKey, out foundBundle))
{
//TODO: Throw an exception, this will result in an exception anyways
return(null);
}
//now we need to determine if this bundle has already been created
var compositeFilePath = new FileInfo(_fileSystemHelper.GetCurrentCompositeFilePath(bundle.CacheBuster, bundle.Compression, bundle.FileKey));
//we need to go one level above the composite path into the non-compression named folder since the map request will always be 'none' compression
var mapPath = new FileInfo(Path.Combine(compositeFilePath.Directory.Parent.FullName, compositeFilePath.Name + ".map"));
if (mapPath.Exists)
{
//this should already be processed if this is being requested!
return(File(mapPath.OpenRead(), "application/json"));
}
//TODO: Throw an exception, this will result in an exception anyways
return(null);
}
/// <summary>
/// Handles requests for named bundles
/// </summary>
/// <param name="bundle">The bundle model</param>
/// <returns></returns>
public async Task <IActionResult> Bundle(
[FromServices] BundleRequestModel bundle)
{
if (!_bundleManager.TryGetValue(bundle.FileKey, out Bundle foundBundle))
{
return(NotFound());
}
var bundleOptions = foundBundle.GetBundleOptions(_bundleManager, bundle.Debug);
//now we need to determine if this bundle has already been created
var compositeFilePath = new FileInfo(_fileSystemHelper.GetCurrentCompositeFilePath(bundle.CacheBuster, bundle.Compression, bundle.FileKey));
if (compositeFilePath.Exists)
{
_logger.LogDebug($"Returning bundle '{bundle.FileKey}' from cache");
//this is already processed, return it
return(File(compositeFilePath.OpenRead(), bundle.Mime));
}
//the bundle doesn't exist so we'll go get the files, process them and create the bundle
//TODO: We should probably lock here right?! we don't want multiple threads trying to do this at the same time, we'll need a dictionary of locks to do this effectively
//get the files for the bundle
var files = _fileSetGenerator.GetOrderedFileSet(foundBundle,
_processorFactory.CreateDefault(
//the file type in the bundle will always be the same
foundBundle.Files[0].DependencyType))
.ToArray();
if (files.Length == 0)
{
return(NotFound());
}
using (var bundleContext = new BundleContext(bundle, compositeFilePath))
{
var watch = new Stopwatch();
watch.Start();
_logger.LogDebug($"Processing bundle '{bundle.FileKey}', debug? {bundle.Debug} ...");
//we need to do the minify on the original files
foreach (var file in files)
{
await _preProcessManager.ProcessAndCacheFileAsync(file, bundleOptions, bundleContext);
}
//Get each file path to it's hashed location since that is what the pre-processed file will be saved as
Lazy <IFileInfo> fi;
var filePaths = files.Select(
x => _fileSystemHelper.GetCacheFilePath(x, bundleOptions.FileWatchOptions.Enabled, Path.GetExtension(x.FilePath), bundle.CacheBuster, out fi));
using (var resultStream = await GetCombinedStreamAsync(filePaths, bundleContext))
{
//compress the response (if enabled)
var compressedStream = await Compressor.CompressAsync(
//do not compress anything if it's not enabled in the bundle options
bundleOptions.CompressResult?bundle.Compression : CompressionType.none,
resultStream);
//save the resulting compressed file, if compression is not enabled it will just save the non compressed format
// this persisted file will be used in the CheckNotModifiedAttribute which will short circuit the request and return
// the raw file if it exists for further requests to this path
await CacheCompositeFileAsync(compositeFilePath, compressedStream);
_logger.LogDebug($"Processed bundle '{bundle.FileKey}' in {watch.ElapsedMilliseconds}ms");
//return the stream
return(File(compressedStream, bundle.Mime));
}
}
}