private static void ChangeDetectedHandler(ChangeDetectedEventArg arg)
{
using (ChangeLock.Write())
{
/*
* At any point of time there can't be no more than 2 change, corresponding
* to the Config and Resource change type.
*
* New change of the Resource change type will have its affected-resources
* merged into existing change.
*/
var change = Changes.FirstOrDefault(c => c.ChangeType == arg.ChangeType);
if (change == null)
{
if (Log.IsDebugEnabled)
Log.Debug("Change posted. " + arg);
Changes.Add(arg);
}
else if (arg.ChangeType == ChangeType.Resource)
{
foreach (var path in arg.ModifiedResourcePaths)
{
if (!change.ModifiedResourcePaths.Contains(path))
{
change.ModifiedResourcePaths.Add(path);
}
}
if (Log.IsDebugEnabled)
Log.Debug("Change merged. " + change);
}
}
}
private void OnChange(ChangeType changeType, List <string> affectedResources)
{
if (ChangeDetected == null)
{
return;
}
var arg = new ChangeDetectedEventArg(changeType, affectedResources);
ChangeDetected(arg);
}
private static void ApplyChange(ChangeDetectedEventArg change)
{
/*
* We may be dealing with a new setting object not existing
* when the change.ModifiedResourcePaths is created, the code should
* make sure it deals with the latest resource sets only
*/
var settings = ReadSettings();
foreach (var set in settings.ResourceSets)
{
if (!set.IsAutoVersion)
{
continue;
}
var modifiedResources = set.Where(
r => change.ModifiedResourcePaths.Any(
path => path.Equals(r.Path, StringComparison.OrdinalIgnoreCase)))
.ToList();
// Clear the content cache before recomputing the hash
modifiedResources.ForEach(r => r.RemoveInCache());
/*
* ComputeHash() must be kept out of the ConfigLock and ChangeLock in case
* it makes HTTP request to local dynamic resources which happen to
* require reading settings (i.e. invoke GetSettings()) and result in a
* deadlock.
*
* This type of lock-smart approach has an issue:
* - T1 finishes computing a hash
* - T2 picks up new change and finishes cimputing another hash
* - T2 save the hash
* - T1 save the hash -> this is the old hash
* But this shouldn't be a big deal because the only problem with it is
* when the app restarts and the new hash is recomputed, which is different
* from the hash in the client's browser cache and thus force the browser
* to make new request to the server.
*/
set.Hash = set.ComputeHash();
}
}
private static void ChangeDetectedHandler(ChangeDetectedEventArg arg)
{
using (ChangeLock.Write())
{
/*
* At any point of time there can't be no more than 2 change, corresponding
* to the Config and Resource change type.
*
* New change of the Resource change type will have its affected-resources
* merged into existing change.
*/
var change = Changes.FirstOrDefault(c => c.ChangeType == arg.ChangeType);
if (change == null)
{
if (Log.IsDebugEnabled)
{
Log.Debug("Change posted. " + arg);
}
Changes.Add(arg);
}
else if (arg.ChangeType == ChangeType.Resource)
{
foreach (var path in arg.ModifiedResourcePaths)
{
if (!change.ModifiedResourcePaths.Contains(path))
{
change.ModifiedResourcePaths.Add(path);
}
}
if (Log.IsDebugEnabled)
{
Log.Debug("Change merged. " + change);
}
}
}
}
public ChangeDetectedEventArg(ChangeDetectedEventArg other)
{
ChangeType = other.ChangeType;
ModifiedResourcePaths = new List <string>(other.ModifiedResourcePaths);
}
private static void ApplyChange(ChangeDetectedEventArg change)
{
/*
* We may be dealing with a new setting object not existing
* when the change.ModifiedResourcePaths is created, the code should
* make sure it deals with the latest resource sets only
*/
var settings = ReadSettings();
foreach (var set in settings.ResourceSets)
{
if (!set.IsAutoVersion)
continue;
var modifiedResources = set.Where(
r => change.ModifiedResourcePaths.Any(
path => path.Equals(r.Path, StringComparison.OrdinalIgnoreCase)))
.ToList();
// Clear the content cache before recomputing the hash
modifiedResources.ForEach(r => r.RemoveInCache());
/*
* ComputeHash() must be kept out of the ConfigLock and ChangeLock in case
* it makes HTTP request to local dynamic resources which happen to
* require reading settings (i.e. invoke GetSettings()) and result in a
* deadlock.
*
* This type of lock-smart approach has an issue:
* - T1 finishes computing a hash
* - T2 picks up new change and finishes cimputing another hash
* - T2 save the hash
* - T1 save the hash -> this is the old hash
* But this shouldn't be a big deal because the only problem with it is
* when the app restarts and the new hash is recomputed, which is different
* from the hash in the client's browser cache and thus force the browser
* to make new request to the server.
*/
set.Hash = set.ComputeHash();
}
}
public ChangeDetectedEventArg(ChangeDetectedEventArg other)
{
ChangeType = other.ChangeType;
ModifiedResourcePaths = new List<string>(other.ModifiedResourcePaths);
}
private void OnChange(ChangeType changeType, List<string> affectedResources)
{
if (ChangeDetected == null)
return;
var arg = new ChangeDetectedEventArg(changeType, affectedResources);
ChangeDetected(arg);
}
