Asp.Net MVC Bundling, best way to detect missing file - asp.net-mvc

Question

I've just chased a bug that was due to a missing javascript file, it was failing silently.
The minified version of the file was present but not the full version, a link isn't rendered on the client (which I was expecting) but I don't get an exception either. I'd like to know if the file isn't present.
(just to be clear, the bundle didn't try to included the minified version, it tried to include the full version, but the minified version was present in the script directory)
Do I have to write something custom to detect this or does MVC have anything built in to report this?
thanks

Answer 1

I came up to using the following extension methods for Bundle:
public static class BundleHelper
{
[Conditional("DEBUG")] // remove this attribute to validate bundles in production too
private static void CheckExistence(string virtualPath)
{
int i = virtualPath.LastIndexOf('/');
string path = HostingEnvironment.MapPath(virtualPath.Substring(0, i));
string fileName = virtualPath.Substring(i + 1);
bool found = Directory.Exists(path);
if (found)
{
if (fileName.Contains("{version}"))
{
var re = new Regex(fileName.Replace(".", #"\.").Replace("{version}", #"(\d+(?:\.\d+){1,3})"));
fileName = fileName.Replace("{version}", "*");
found = Directory.EnumerateFiles(path, fileName).FirstOrDefault(file => re.IsMatch(file)) != null;
}
else // fileName may contain '*'
found = Directory.EnumerateFiles(path, fileName).FirstOrDefault() != null;
}
if (!found)
throw new ApplicationException(String.Format("Bundle resource '{0}' not found", virtualPath));
}
public static Bundle IncludeExisting(this Bundle bundle, params string[] virtualPaths)
{
foreach (string virtualPath in virtualPaths)
CheckExistence(virtualPath);
return bundle.Include(virtualPaths);
}
public static Bundle IncludeExisting(this Bundle bundle, string virtualPath, params IItemTransform[] transforms)
{
CheckExistence(virtualPath);
return bundle.Include(virtualPath, transforms);
}
}
This way you don't have to call your helper method PreCheck() explicitly. It also supports ASP.NET's wildcards {version} and *:
bundles.Add(new ScriptBundle("~/test")
.IncludeExisting("~/Scripts/jquery/jquery-{version}.js")
.IncludeExisting("~/Scripts/lib*")
.IncludeExisting("~/Scripts/model.js")
);

Answer 2

I can't believe this "anti-pattern" exists! If you see no errors, there are no errors!
Anyway, I like the solution above. Another would be to output the link / script even if it is missing when BundleTable.EnableOptimizations is false -- this is a very obvious thing to try when debugging, and then it will be obvious in the various inspectors / debuggers on browsers which file is missing. This seemed like such an obvious thing for debugging thing that I spent hours without realizing there were missing files. The other way, silently ignoring missing parts of the bundle, is so wrong that it reinforced my horrible debugging session.
Well, this won't bite me twice -- trauma endures.

Answer 3

Another way using BundleTable.VirtualPathProvider wrapper:
public class VirtualPathProviderExt : VirtualPathProvider
{
private readonly VirtualPathProvider _provider;
public VirtualPathProviderExt(VirtualPathProvider provider)
{
_provider = provider;
}
public override string CombineVirtualPaths(string basePath, string relativePath)
{
return _provider.CombineVirtualPaths(basePath, relativePath);
}
public override ObjRef CreateObjRef(Type requestedType)
{
return _provider.CreateObjRef(requestedType);
}
public override bool DirectoryExists(string virtualDir)
{
return _provider.DirectoryExists(virtualDir);
}
public override bool Equals(object obj)
{
return _provider.Equals(obj);
}
private static readonly Regex _ignorePathsRegex = new Regex(#"\.debug\.\w+$|^~/bundle.config$", RegexOptions.IgnoreCase | RegexOptions.Compiled);
public override bool FileExists(string virtualPath)
{
var result = _provider.FileExists(virtualPath);
if (!result && !_ignorePathsRegex.IsMatch(virtualPath))
{
Logger.Instance.Log(RecType.Error, "Bundle file not found: " + virtualPath);
}
return result;
}
public override CacheDependency GetCacheDependency(string virtualPath, IEnumerable virtualPathDependencies, DateTime utcStart)
{
return _provider.GetCacheDependency(virtualPath, virtualPathDependencies, utcStart);
}
public override string GetCacheKey(string virtualPath)
{
return _provider.GetCacheKey(virtualPath);
}
public override VirtualDirectory GetDirectory(string virtualDir)
{
return _provider.GetDirectory(virtualDir);
}
public override VirtualFile GetFile(string virtualPath)
{
return _provider.GetFile(virtualPath);
}
public override string GetFileHash(string virtualPath, IEnumerable virtualPathDependencies)
{
return _provider.GetFileHash(virtualPath, virtualPathDependencies);
}
public override int GetHashCode()
{
return _provider.GetHashCode();
}
public override object InitializeLifetimeService()
{
return _provider.InitializeLifetimeService();
}
public override string ToString()
{
return _provider.ToString();
}
}
Bundle helper:
public static class BundleHelpers
{
public static void InitBundles()
{
if (!(BundleTable.VirtualPathProvider is VirtualPathProviderExt))
{
BundleTable.VirtualPathProvider = new VirtualPathProviderExt(BundleTable.VirtualPathProvider);
}
}
}
And run BundleHelpers.InitBundles() in BundleConfig.cs:
public class BundleConfig
{
public static void RegisterBundles(BundleCollection bundles)
{
BundleHelpers.InitBundles();
...

Answer 4

I changed the code a bit. Instead of throwing an error it will not add any bundle file. this is required if you are using same common bundle config for multiple projects
public static class BundleHelper
{
private static bool CheckExistence(string virtualPath)
{
int i = virtualPath.LastIndexOf('/');
string path = HostingEnvironment.MapPath(virtualPath.Substring(0, i));
string fileName = virtualPath.Substring(i + 1);
bool found = Directory.Exists(path);
if (found)
{
if (fileName.Contains("{version}"))
{
var re = new Regex(fileName.Replace(".", #"\.").Replace("{version}", #"(\d+(?:\.\d+){1,3})"));
fileName = fileName.Replace("{version}", "*");
found = Directory.EnumerateFiles(path, fileName).Where(file => re.IsMatch(file)).FirstOrDefault() != null;
}
else // fileName may contain '*'
found = Directory.EnumerateFiles(path, fileName).FirstOrDefault() != null;
}
return found;
//if (!found)
//throw new ApplicationException(String.Format("Bundle resource '{0}' not found", virtualPath));
}
public static Bundle IncludeExisting(this Bundle bundle, params string[] virtualPaths)
{
foreach (string virtualPath in virtualPaths)
if (CheckExistence(virtualPath))
{
bundle.Include(virtualPath);
}
return bundle;
}
public static Bundle IncludeExisting(this Bundle bundle, string virtualPath, params IItemTransform[] transforms)
{
if (CheckExistence(virtualPath))
bundle.Include(virtualPath, transforms);
return bundle;
}
}