internal bool ProcessAttachmentsForRevision(RevisionInternal rev, IList<string> ancestry)
{
var revAttachments = rev.GetAttachments();
if (revAttachments == null) {
return true; // no-op: no attachments
}
// Deletions can't have attachments:
if (rev.IsDeleted() || revAttachments.Count == 0) {
var body = rev.GetProperties();
body.Remove("_attachments");
rev.SetProperties(body);
return true;
}
var prevRevId = ancestry != null && ancestry.Count > 0 ? ancestry[0] : null;
int generation = RevisionInternal.GenerationFromRevID(prevRevId) + 1;
IDictionary<string, object> parentAttachments = null;
return rev.MutateAttachments((name, attachInfo) =>
{
AttachmentInternal attachment = null;
try {
attachment = new AttachmentInternal(name, attachInfo);
} catch(CouchbaseLiteException) {
return null;
}
if(attachment.EncodedContent != null) {
// If there's inline attachment data, decode and store it:
BlobKey blobKey = new BlobKey();
if(!Attachments.StoreBlob(attachment.EncodedContent.ToArray(), blobKey)) {
throw new CouchbaseLiteException(
String.Format("Failed to write attachment ' {0}'to disk", name), StatusCode.AttachmentError);
}
attachment.BlobKey = blobKey;
} else if(attachInfo.GetCast<bool>("follows")) {
// "follows" means the uploader provided the attachment in a separate MIME part.
// This means it's already been registered in _pendingAttachmentsByDigest;
// I just need to look it up by its "digest" property and install it into the store:
InstallAttachment(attachment);
} else if(attachInfo.GetCast<bool>("stub")) {
// "stub" on an incoming revision means the attachment is the same as in the parent.
if(parentAttachments == null && prevRevId != null) {
parentAttachments = GetAttachmentsFromDoc(rev.GetDocId(), prevRevId);
if(parentAttachments == null) {
if(Attachments.HasBlobForKey(attachment.BlobKey)) {
// Parent revision's body isn't known (we are probably pulling a rev along
// with its entire history) but it's OK, we have the attachment already
return attachInfo;
}
var ancestorAttachment = FindAttachment(name, attachment.RevPos, rev.GetDocId(), ancestry);
if(ancestorAttachment != null) {
return ancestorAttachment;
}
throw new CouchbaseLiteException(
String.Format("Unable to find 'stub' attachment {0} in history", name), StatusCode.BadAttachment);
}
}
var parentAttachment = parentAttachments == null ? null : parentAttachments.Get(name).AsDictionary<string, object>();
if(parentAttachment == null) {
throw new CouchbaseLiteException(
String.Format("Unable to find 'stub' attachment {0} in history", name), StatusCode.BadAttachment);
}
return parentAttachment;
}
// Set or validate the revpos:
if(attachment.RevPos == 0) {
attachment.RevPos = generation;
} else if(attachment.RevPos > generation) {
throw new CouchbaseLiteException(
String.Format("Attachment specifies revision generation {0} but document is only at revision generation {1}",
attachment.RevPos, generation), StatusCode.BadAttachment);
}
Debug.Assert(attachment.IsValid);
return attachment.AsStubDictionary();
});
}
internal bool ProcessAttachmentsForRevision(RevisionInternal rev, string prevRevId, Status status)
{
if (status == null) {
status = new Status();
}
status.Code = StatusCode.Ok;
var revAttachments = rev.GetAttachments();
if (revAttachments == null) {
return true; // no-op: no attachments
}
// Deletions can't have attachments:
if (rev.IsDeleted() || revAttachments.Count == 0) {
var body = rev.GetProperties();
body.Remove("_attachments");
rev.SetProperties(body);
return true;
}
int generation = RevisionInternal.GenerationFromRevID(prevRevId) + 1;
IDictionary<string, object> parentAttachments = null;
return rev.MutateAttachments((name, attachInfo) =>
{
AttachmentInternal attachment = null;
try {
attachment = new AttachmentInternal(name, attachInfo);
} catch(CouchbaseLiteException e) {
return null;
}
if(attachment.EncodedContent != null) {
// If there's inline attachment data, decode and store it:
BlobKey blobKey = new BlobKey();
if(!Attachments.StoreBlob(attachment.EncodedContent.ToArray(), blobKey)) {
status.Code = StatusCode.AttachmentError;
return null;
}
attachment.BlobKey = blobKey;
} else if(attachInfo.GetCast<bool>("follows")) {
// "follows" means the uploader provided the attachment in a separate MIME part.
// This means it's already been registered in _pendingAttachmentsByDigest;
// I just need to look it up by its "digest" property and install it into the store:
InstallAttachment(attachment, attachInfo);
} else if(attachInfo.GetCast<bool>("stub")) {
// "stub" on an incoming revision means the attachment is the same as in the parent.
if(parentAttachments == null && prevRevId != null) {
parentAttachments = GetAttachmentsFromDoc(rev.GetDocId(), prevRevId, status);
if(parentAttachments == null) {
if(status.Code == StatusCode.Ok || status.Code == StatusCode.NotFound) {
status.Code = StatusCode.BadAttachment;
}
return null;
}
}
var parentAttachment = parentAttachments == null ? null : parentAttachments.Get(name).AsDictionary<string, object>();
if(parentAttachment == null) {
status.Code = StatusCode.BadAttachment;
return null;
}
return parentAttachment;
}
// Set or validate the revpos:
if(attachment.RevPos == 0) {
attachment.RevPos = generation;
} else if(attachment.RevPos >= generation) {
status.Code = StatusCode.BadAttachment;
return null;
}
Debug.Assert(attachment.IsValid);
return attachment.AsStubDictionary();
});
}
internal bool ProcessAttachmentsForRevision(RevisionInternal rev, IList<RevisionID> ancestry)
{
var revAttachments = rev.GetAttachments();
if(revAttachments == null) {
return true; // no-op: no attachments
}
// Deletions can't have attachments:
if(rev.Deleted || revAttachments.Count == 0) {
var body = rev.GetProperties();
body.Remove("_attachments");
rev.SetProperties(body);
return true;
}
var prevRevId = ancestry != null && ancestry.Count > 0 ? ancestry[0] : null;
int generation = rev.Generation;
IDictionary<string, object> parentAttachments = null;
return rev.MutateAttachments((name, attachInfo) =>
{
AttachmentInternal attachment = null;
try {
attachment = new AttachmentInternal(name, attachInfo);
} catch(CouchbaseLiteException) {
Log.To.Database.W(TAG, "Error creating attachment object for '{0}' ('{1}'), " +
"returning null", new SecureLogString(name, LogMessageSensitivity.PotentiallyInsecure),
new SecureLogJsonString(attachInfo, LogMessageSensitivity.PotentiallyInsecure));
return null;
}
if(attachment.EncodedContent != null) {
// If there's inline attachment data, decode and store it:
BlobKey blobKey = new BlobKey();
try {
Attachments.StoreBlob(attachment.EncodedContent.ToArray(), blobKey);
} catch(CouchbaseLiteException) {
Log.To.Database.E(TAG, "Failed to write attachment '{0}' to disk, rethrowing...", name);
throw;
} catch(Exception e) {
throw Misc.CreateExceptionAndLog(Log.To.Database, e, TAG,
"Exception during attachment writing '{0}'",
new SecureLogString(name, LogMessageSensitivity.PotentiallyInsecure));
}
attachment.BlobKey = blobKey;
} else if(attachInfo.GetCast<bool>("follows")) {
// "follows" means the uploader provided the attachment in a separate MIME part.
// This means it's already been registered in _pendingAttachmentsByDigest;
// I just need to look it up by its "digest" property and install it into the store:
InstallAttachment(attachment);
} else if(attachInfo.GetCast<bool>("stub")) {
// "stub" on an incoming revision means the attachment is the same as in the parent.
if(parentAttachments == null && prevRevId != null) {
parentAttachments = GetAttachmentsFromDoc(rev.DocID, prevRevId);
if(parentAttachments == null) {
if(Attachments.HasBlobForKey(attachment.BlobKey)) {
// Parent revision's body isn't known (we are probably pulling a rev along
// with its entire history) but it's OK, we have the attachment already
return attachInfo;
}
var ancestorAttachment = FindAttachment(name, attachment.RevPos, rev.DocID, ancestry);
if(ancestorAttachment != null) {
return ancestorAttachment;
}
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadAttachment, TAG,
"Unable to find 'stub' attachment {0} in history (1)",
new SecureLogString(name, LogMessageSensitivity.PotentiallyInsecure));
}
}
var parentAttachment = parentAttachments == null ? null : parentAttachments.Get(name).AsDictionary<string, object>();
if(parentAttachment == null) {
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadAttachment, TAG,
"Unable to find 'stub' attachment {0} in history (2)",
new SecureLogString(name, LogMessageSensitivity.PotentiallyInsecure));
}
return parentAttachment;
}
// Set or validate the revpos:
if(attachment.RevPos == 0) {
attachment.RevPos = generation;
} else if(attachment.RevPos > generation) {
throw Misc.CreateExceptionAndLog(Log.To.Database, StatusCode.BadAttachment, TAG,
"Attachment specifies revision generation {0} but document is only at revision generation {1}",
attachment.RevPos, generation);
}
Debug.Assert(attachment.IsValid);
return attachment.AsStubDictionary();
});
}