/// <summary>
/// Verify recursively deleting a node that has a lot of immediate children
/// </summary>
/// <param name="childrenCount">Number of children to create</param>
public async Task TestDeleteNodeWithManyChildren(int childrenCount = 10000)
{
var instrumentation = new TestRecursiveDeleterInstrumentation();
var deleter = new RecursiveDeleter(instrumentation, maxChildrenEnumerationCount: 10);
using (var ringMaster = this.ConnectToRingMaster())
{
string nodePath = $"{TestRecursiveDeleter.TestPrefix}/TestRecursiveDeleteNodeWithManyChildren_{Guid.NewGuid()}";
await ringMaster.Create(nodePath, null, null, CreateMode.Persistent);
for (int i = 0; i < childrenCount; i++)
{
string childPath = $"{nodePath}/Child{i}";
await ringMaster.Create(childPath, null, null, CreateMode.Persistent);
}
int deletedCount = await deleter.Delete(ringMaster, nodePath, CancellationToken.None);
await VerifyRingMasterException(RingMasterException.Code.Nonode, async() => await ringMaster.Exists(nodePath, watcher: null), $"{nodePath} should not exist");
Assert.AreEqual(childrenCount + 1, instrumentation.NodesDeletedCount);
Assert.AreEqual(childrenCount + 1, deletedCount);
Assert.AreEqual(childrenCount + 1, instrumentation.DeleteMultiSucceededOperationsCount);
Assert.AreEqual(1, instrumentation.RecursiveDeleteSucceededCount);
Assert.AreEqual(0, instrumentation.RecursiveDeleteFailedCount);
}
}
/// <summary>
/// Verify that cancellation token is observed.
/// </summary>
public async Task TestCancelDelete()
{
var instrumentation = new TestRecursiveDeleterInstrumentation();
var deleter = new RecursiveDeleter(instrumentation);
using (var ringMaster = this.ConnectToRingMaster())
{
string nodePath = $"{TestRecursiveDeleter.TestPrefix}/TestCancelRecursiveDelete_{Guid.NewGuid()}";
await ringMaster.Create(nodePath, null, null, CreateMode.Persistent);
var cancellationTokenSource = new CancellationTokenSource();
cancellationTokenSource.Cancel();
try
{
Trace.TraceInformation($"Attempting to delete {nodePath}");
await deleter.Delete(ringMaster, nodePath, cancellationTokenSource.Token);
Assert.Fail("Delete should have thrown TaskCanceledException");
}
catch (Exception ex)
{
Trace.TraceInformation($"Exception: {ex}");
}
await ringMaster.Exists(nodePath, watcher : null);
Assert.AreEqual(0, instrumentation.NodesDeletedCount);
Assert.AreEqual(1, instrumentation.RecursiveDeleteFailedCount);
}
}
private void PrepareData(string modelType)
{
var inputConfig = new InputConfiguration();
AssetDirs.CreateAssetDirectory(AssetDirs.TempAssetsDir);
var assetBundleCreator = new AssetBundleCreator(inputConfig.OutputDir);
var modelConverter = new ModelConverter();
Log.Info("Preprocessing started!");
var modelImporter = InitializeModelImporter(modelType, modelConverter, inputConfig.RootDirectory);
bool loadModel = true;
try
{
while (loadModel)
{
modelImporter.GetModelData();
assetBundleCreator.Create(modelImporter);
if (Application.isBatchMode)
{
loadModel = false;
}
else
{
loadModel = EditorUtility.DisplayDialog("", "Do you want to load another model?", "Yes", "No");
}
}
}
finally
{
RecursiveDeleter.DeleteRecursivelyWithSleep(AssetDirs.TempAssetsDir);
Log.Info("Preprocessing finished!");
}
}
/// <summary>
/// Verify that recursively deleting a non existent node fails.
/// </summary>
public async Task TestDeleteNonExistentNode()
{
var instrumentation = new TestRecursiveDeleterInstrumentation();
var deleter = new RecursiveDeleter(instrumentation);
using (var ringMaster = this.ConnectToRingMaster())
{
string nodePath = $"{TestRecursiveDeleter.TestPrefix}/TestRecursiveDeleteNonExistentNode_{Guid.NewGuid()}";
await VerifyRingMasterException(
RingMasterException.Code.Nonode,
async() => await deleter.Delete(ringMaster, nodePath, CancellationToken.None),
$"Delete should not succeed for non-existent node {nodePath}");
Assert.AreEqual(0, instrumentation.NodesDeletedCount);
}
}
/// <summary>
/// Verify that recursively deleting a node that has no children deletes the node.
/// </summary>
public async Task TestDeleteEmptyNode()
{
var instrumentation = new TestRecursiveDeleterInstrumentation();
var deleter = new RecursiveDeleter(instrumentation, maxChildrenEnumerationCount: 10);
using (var ringMaster = this.ConnectToRingMaster())
{
string nodePath = $"{TestRecursiveDeleter.TestPrefix}/TestRecursiveDeleteEmptyNode_{Guid.NewGuid()}";
await ringMaster.Create(nodePath, null, null, CreateMode.Persistent);
int deletedCount = await deleter.Delete(ringMaster, nodePath, CancellationToken.None);
await VerifyRingMasterException(RingMasterException.Code.Nonode, async() => await ringMaster.Exists(nodePath, watcher: null), $"{nodePath} should not exist");
Assert.AreEqual(1, instrumentation.NodesDeletedCount);
Assert.AreEqual(1, deletedCount);
}
}
//Creates appropriate AssetBundle for the model.
private void CreateAssetBundle(AssetBundleBuild[] buildMapArray)
{
Directory.CreateDirectory(outputPath);
BuildPipeline.BuildAssetBundles(outputPath, buildMapArray, BuildAssetBundleOptions.None, BuildTarget.WSAPlayer);
// this is necessary to clear references to this asset
Texture2D texture = AssetDatabase.LoadAssetAtPath <Texture2D>(AssetDirs.TempAssetsDir + "/icon.asset");
UnityEngine.Object.DestroyImmediate(texture, true);
// this is still necessary even after above DestroyImmediate.
AssetDatabase.DeleteAsset(AssetDirs.TempAssetsDir + "/icon.asset");
//Cleaning up an unnecessesary bundle
string folderBundle = Path.Combine(outputPath, Path.GetFileNameWithoutExtension(outputPath));
RecursiveDeleter.DeleteRecursivelyWithSleep(folderBundle);
RecursiveDeleter.DeleteRecursivelyWithSleep(folderBundle + ".manifest");
}
/// <summary>
/// Verify failure to delete a node is handled properly.
/// </summary>
public async Task TestDeleteNodeFailure(int childrenCount = 5)
{
var instrumentation = new TestRecursiveDeleterInstrumentation();
var deleter = new RecursiveDeleter(instrumentation, maxChildrenEnumerationCount: 10);
deleter.MaxDeleteBatchLength = 1;
using (var ringMaster = this.ConnectToRingMaster())
{
string nodePath = $"{TestRecursiveDeleter.TestPrefix}/TestRecursiveDeleteNodeFailure_{Guid.NewGuid()}";
await ringMaster.SetAuth(Digest1Identity);
await ringMaster.Create(nodePath, null, null, CreateMode.Persistent);
await ringMaster.SetAuth(Digest2Identity);
await ringMaster.Create($"{nodePath}/Child0", null, new Acl[] { AllowDigest2, AllowDigest1Read }, CreateMode.Persistent);
await ringMaster.SetAuth(Digest1Identity);
for (int i = 1; i < childrenCount; i++)
{
await ringMaster.Create($"{nodePath}/Child{i}", null, new Acl[] { AllowDigest1 }, CreateMode.Persistent);
}
// We should be able to delete all the child nodes,
// but not the parent node.
await VerifyRingMasterException(RingMasterException.Code.Authfailed, async() => await deleter.Delete(ringMaster, nodePath, CancellationToken.None), $"{nodePath} should not be deleted");
Assert.AreEqual(childrenCount - 1, instrumentation.NodesDeletedCount);
Assert.AreEqual(childrenCount - 1, instrumentation.DeleteMultiSucceededOperationsCount);
Assert.AreEqual(1, instrumentation.DeleteMultiFailedOperationsCount);
Assert.AreEqual(0, instrumentation.RecursiveDeleteSucceededCount);
Assert.AreEqual(1, instrumentation.RecursiveDeleteFailedCount);
}
}
