public void TestBackupRecord()
{
HSSFWorkbook wb = new HSSFWorkbook();
wb.CreateSheet();
InternalWorkbook workbook = wb.Workbook;
BackupRecord record = workbook.BackupRecord;
Assert.AreEqual(0, record.Backup);
wb.BackupFlag = (true);
Assert.AreEqual(1, record.Backup);
}
public void CreateBackup()
{
try
{
ApplyPolicies();
var backup = new BackupRecord(Guid.NewGuid(), _clock.Now);
_client.Add(backup);
_logger.LogInformation($"Backup created. Id: {backup.Id}. Created at: {backup.Created}");
}
catch (Exception e)
{
_logger.LogError(e, "Backup error.");
throw;
}
}
public IEnumerator <byte[]> GetEnumerator()
{
// NOTE: This recursive iteration creates many iterators as it runs
// this may cause performance issues.
// NOTE: Since the blobs references returned may be being operated on (blobs deleted)
// and this method relies on being able to load the input (parent) blob
// we return the parent blobs last in all recursions
BlobLocation blocation = Blobs.GetBlobLocation(ParentHash);
switch (BlobType)
{
case BlobLocation.BlobType.Simple:
break;
case BlobLocation.BlobType.FileBlob:
break;
default:
byte[] blobdata = BlobData ?? Blobs.RetrieveData(ParentHash);
switch (BlobType)
{
case BlobLocation.BlobType.BackupRecord:
BackupRecord br = BackupRecord.deserialize(blobdata);
if (!BottomUp)
{
yield return(br.MetadataTreeHash); // return 1 immediate reference
}
if (!skipchild)
{
childiterator = new BlobReferenceIterator(Blobs, br.MetadataTreeHash,
BlobLocation.BlobType.MetadataNode, IncludeFiles, BottomUp);
foreach (var refref in childiterator) // recurse on references of that reference
{
yield return(refref);
}
childiterator = null;
}
skipchild = false;
if (BottomUp)
{
yield return(br.MetadataTreeHash); // return 1 immediate reference
}
break;
case BlobLocation.BlobType.MetadataNode:
IEnumerable <byte[]> dirreferences;
IEnumerable <byte[]>?filereferences = null;
byte[] mnodebytes = blobdata;
dirreferences = MetadataNode.GetImmediateChildNodeReferencesWithoutLoad(mnodebytes); // many immediate references
if (IncludeFiles)
{
filereferences = MetadataNode.GetImmediateFileReferencesWithoutLoad(mnodebytes);
foreach (var fref in filereferences)
{
if (!BottomUp)
{
yield return(fref);
}
if (!skipchild)
{
childiterator = new BlobReferenceIterator(Blobs, fref, BlobLocation.BlobType.FileBlob,
IncludeFiles, BottomUp);
foreach (var frefref in childiterator)
{
yield return(frefref);
}
childiterator = null;
}
skipchild = false;
if (BottomUp)
{
yield return(fref);
}
}
}
foreach (var reference in dirreferences) // for each immediate reference
{
if (!BottomUp)
{
yield return(reference); // return immediate reference
}
if (!skipchild)
{
childiterator = new BlobReferenceIterator(Blobs, reference, BlobLocation.BlobType.MetadataNode,
IncludeFiles, BottomUp);
foreach (var refref in childiterator) // recurse on references of that reference
{
yield return(refref);
}
childiterator = null;
}
skipchild = false;
if (BottomUp)
{
yield return(reference); // return immediate reference
}
}
break;
default:
throw new Exception("Unhandled blobtype on dereference");
}
break;
}
if (blocation.BlockHashes != null)
{
foreach (var hash in blocation.BlockHashes)
{
yield return(hash);
}
}
// Run post order action if exists
postOrderAction?.Invoke();
}
public static BackupGeneration GetGeneration(this BackupRecord record, DateTimeOffset currentDate) => GetGeneration(record.Created, currentDate);
public void Add(BackupRecord backup)
{
lock (_lockObject)
_backupRecords.Add(backup);
}
