public void TestTempFileEviction()
{
DefaultDiskStorage storage = GetStorageSupplier(1).Get();
string resourceId1 = "resource1";
IInserter inserter = storage.Insert(resourceId1, null);
FileInfo tempFile = ((DefaultDiskStorage.InserterImpl)inserter)._temporaryFile;
// Make sure that we don't evict a recent temp file
PurgeUnexpectedFiles(storage);
Assert.IsTrue(tempFile.Exists);
// Mark it old, then try eviction again. It should be gone.
try
{
tempFile.LastWriteTime = _clock.Now.Subtract(
TimeSpan.FromMilliseconds(DefaultDiskStorage.TEMP_FILE_LIFETIME_MS + 1000));
}
catch (Exception)
{
throw new IOException("Unable to update timestamp of file: " + tempFile);
}
PurgeUnexpectedFiles(storage);
Assert.IsFalse(tempFile.Exists);
}
public void TestDirectoryIsNotNuked()
{
Assert.AreEqual(0, _directory.ListFiles().Length);
DefaultDiskStorage storage = GetStorageSupplier(1).Get();
string resourceId = "file1";
byte[] CONTENT = Encoding.UTF8.GetBytes("content");
// Create a file so we know version directory really exists
IInserter inserter = storage.Insert(resourceId, null);
WriteToResource(inserter, CONTENT);
inserter.Commit(null);
// Assign some previous date to the "now" used for file creation
long lastModified = _directory.LastWriteTime.Ticks / TimeSpan.TicksPerMillisecond - 1000;
_directory.LastWriteTime = new DateTime(lastModified * TimeSpan.TicksPerMillisecond);
// Check it was changed
Assert.AreEqual(lastModified * TimeSpan.TicksPerMillisecond, _directory.LastWriteTime.Ticks);
// Create again, it shouldn't delete the directory
GetStorageSupplier(1).Get();
_directory.Refresh();
// _directory exists...
Assert.IsTrue(_directory.Exists);
// And it's the same as before
Assert.AreEqual(lastModified * TimeSpan.TicksPerMillisecond, _directory.LastWriteTime.Ticks);
}
public static IInserter GetRootInserter(IInserter inserter)
{
while (inserter is IReturnParentInserter)
{
inserter = (inserter as IReturnParentInserter).GetParentInserter();
}
return(inserter);
}
public static IInserter GetRootInserter(IInserter inserter)
{
while (inserter is IReturnParentInserter)
{
inserter = (inserter as IReturnParentInserter).GetParentInserter();
}
return inserter;
}
protected void Remove(IInserter inserter)
{
foreach (var entry in m_insertersByKey.Where(kvp => kvp.Value == inserter).ToList())
{
m_insertersByKey.Remove(entry);
}
m_insertersInOrderAdded.Remove(inserter);
}
private static FileBinaryResource WriteToStorage(
DefaultDiskStorage storage,
string resourceId,
byte[] value)
{
IInserter inserter = storage.Insert(resourceId, null);
WriteToResource(inserter, value);
return((FileBinaryResource)inserter.Commit(null));
}
/// <summary>
/// Inserts resource into file with key.
/// </summary>
/// <param name="key">Cache key.</param>
/// <param name="callback">
/// Callback that writes to an output stream.
/// </param>
/// <returns>A sequence of bytes.</returns>
public IBinaryResource Insert(ICacheKey key, IWriterCallback callback)
{
// Write to a temp file, then move it into place.
// This allows more parallelism when writing files.
SettableCacheEvent cacheEvent = SettableCacheEvent.Obtain().SetCacheKey(key);
_cacheEventListener.OnWriteAttempt(cacheEvent);
string resourceId;
lock (_lock)
{
// For multiple resource ids associated with the same image,
// we only write one file
resourceId = CacheKeyUtil.GetFirstResourceId(key);
}
cacheEvent.SetResourceId(resourceId);
try
{
// Getting the file is synchronized
IInserter inserter = StartInsert(resourceId, key);
try
{
inserter.WriteData(callback, key);
// Committing the file is synchronized
IBinaryResource resource = EndInsert(inserter, key, resourceId);
cacheEvent.SetItemSize(resource.GetSize())
.SetCacheSize(_cacheStats.Size);
_cacheEventListener.OnWriteSuccess(cacheEvent);
return(resource);
}
finally
{
if (!inserter.CleanUp())
{
Debug.WriteLine("Failed to delete temp file");
}
}
}
catch (IOException ioe)
{
cacheEvent.SetException(ioe);
_cacheEventListener.OnWriteException(cacheEvent);
Debug.WriteLine("Failed inserting a file into the cache");
throw;
}
finally
{
cacheEvent.Recycle();
}
}
private static void WriteToResource(
IInserter inserter,
byte[] content)
{
inserter.WriteData(
new WriterCallbackImpl(
os =>
{
os.Write(content, 0, content.Length);
}),
null);
}
/// <summary>
/// Commits the provided temp file to the cache, renaming it to match
/// the cache's hashing convention.
/// </summary>
private IBinaryResource EndInsert(
IInserter inserter,
ICacheKey key,
string resourceId)
{
lock (_lock)
{
IBinaryResource resource = inserter.Commit(key);
_resourceIndex.Add(resourceId);
_cacheStats.Increment(resource.GetSize(), 1);
return(resource);
}
}
public Table(string name, ISchema schema, int startRowId)
{
SetTableName(name);
mSchema = schema;
Schema.SetTable(this, mSchema);
if (mSchema != null)
{
hasErrors = false;
indexer = GetIndexer(schema);
cache = GetTableCache(startRowId);
validator = GetValidator(schema);
inserter = GetInserter(schema, cache);
}
}
internal static GivenStep Given(Scenario scenario, IInserter inserter)
{
var rootInserter = InserterUtil.GetRootInserter(inserter);
if (!Object.ReferenceEquals(rootInserter, inserter))
{
scenario.Step("Given(IInserter({0})) rootInserter -to-> IInserter({1})", inserter.GetType().Name, rootInserter.GetType().Name);
}
else
{
scenario.Step("Given(IInserter({0}))", rootInserter.GetType().Name);
}
scenario.InjectDependencies(rootInserter);
scenario.InvokeOrFail(rootInserter.Insert);
return(new GivenStep(scenario));
}
private static FileInfo Write(
DefaultDiskStorage storage,
string resourceId,
byte[] content)
{
IInserter inserter = storage.Insert(resourceId, null);
FileInfo file = ((DefaultDiskStorage.InserterImpl)inserter)._temporaryFile;
FileStream fos = file.Create();
try
{
fos.Write(content, 0, content.Length);
}
finally
{
fos.Dispose();
}
return(((FileBinaryResource)inserter.Commit(null)).File);
}
/// <summary>
/// Invoke an inserter
/// </summary>
/// <returns>the next step</returns>
public GivenStep Given(IInserter inserter)
{
return(Givens.Given(this, inserter));
}
/// <summary>
/// Invoke an inserter
/// </summary>
/// <returns>the next step</returns>
public GivenStep Given(IInserter inserter)
{
return(Givens.Given(Scenario, inserter));
}
