public async Task FetchBinarySizeAsync(cMethodControl pMC, iMessageHandle pMessageHandle, string pPart, cTrace.cContext pParentContext)
{
var lContext = pParentContext.NewMethod(nameof(cSession), nameof(FetchBinarySizeAsync), pMC, pMessageHandle, pPart);
if (mDisposed)
{
throw new ObjectDisposedException(nameof(cSession));
}
if (_ConnectionState != eConnectionState.selected)
{
throw new InvalidOperationException(kInvalidOperationExceptionMessage.NotSelected);
}
if (pMessageHandle == null)
{
throw new ArgumentNullException(nameof(pMessageHandle));
}
if (pPart == null)
{
throw new ArgumentNullException(nameof(pPart));
}
if (!cCommandPartFactory.TryAsAtom(pPart, out var lPart))
{
throw new ArgumentOutOfRangeException(nameof(pPart));
}
using (var lBuilder = new cCommandDetailsBuilder())
{
lBuilder.Add(await mSelectExclusiveAccess.GetBlockAsync(pMC, lContext).ConfigureAwait(false)); // block select
cSelectedMailbox lSelectedMailbox = mMailboxCache.CheckInSelectedMailbox(pMessageHandle);
lBuilder.Add(await mPipeline.GetIdleBlockTokenAsync(pMC, lContext).ConfigureAwait(false)); // stop the pipeline from iding (idle is msnunsafe)
lBuilder.Add(await mMSNUnsafeBlock.GetTokenAsync(pMC, lContext).ConfigureAwait(false)); // wait until all commands that are msnunsafe complete, block all commands that are msnunsafe
// uidvalidity must be captured before the handles are resolved
lBuilder.AddUIDValidity(lSelectedMailbox.MessageCache.UIDValidity);
// resolve the MSN
uint lMSN = lSelectedMailbox.GetMSN(pMessageHandle);
if (lMSN == 0)
{
if (pMessageHandle.Expunged)
{
throw new cMessageExpungedException(pMessageHandle);
}
else
{
throw new ArgumentOutOfRangeException(nameof(pMessageHandle));
}
}
// build command
lBuilder.Add(kFetchCommandPartFetchSpace, new cTextCommandPart(lMSN), kFetchCommandPartSpaceBinarySizeLBracket, lPart, cCommandPart.RBracket);
// go
var lResult = await mPipeline.ExecuteAsync(pMC, lBuilder.EmitCommandDetails(), lContext).ConfigureAwait(false);
if (lResult.ResultType == eCommandResultType.ok)
{
lContext.TraceInformation("fetch binary.size success");
return;
}
if (lResult.ResultType == eCommandResultType.no)
{
throw new cUnsuccessfulCompletionException(lResult.ResponseText, fCapabilities.binary, lContext);
}
throw new cProtocolErrorException(lResult, fCapabilities.binary, lContext);
}
}
private async Task ZFetchCacheItemsAsync(cMethodControl pMC, cMessageHandleList pMessageHandles, cMessageCacheItems pItems, cTrace.cContext pParentContext)
{
var lContext = pParentContext.NewMethod(nameof(cSession), nameof(ZFetchCacheItemsAsync), pMC, pMessageHandles, pItems);
if (mDisposed)
{
throw new ObjectDisposedException(nameof(cSession));
}
if (_ConnectionState != eConnectionState.selected)
{
throw new InvalidOperationException(kInvalidOperationExceptionMessage.NotSelected);
}
if (pMessageHandles == null)
{
throw new ArgumentNullException(nameof(pMessageHandles));
}
if (pItems == null)
{
throw new ArgumentNullException(nameof(pItems));
}
if (pMessageHandles.Count == 0)
{
throw new ArgumentOutOfRangeException(nameof(pMessageHandles));
}
if (pItems.IsEmpty)
{
throw new ArgumentOutOfRangeException(nameof(pItems));
}
using (var lBuilder = new cCommandDetailsBuilder())
{
lBuilder.Add(await mSelectExclusiveAccess.GetBlockAsync(pMC, lContext).ConfigureAwait(false)); // block select
cSelectedMailbox lSelectedMailbox = mMailboxCache.CheckInSelectedMailbox(pMessageHandles);
lBuilder.Add(await mPipeline.GetIdleBlockTokenAsync(pMC, lContext).ConfigureAwait(false)); // stop the pipeline from iding (idle is msnunsafe)
lBuilder.Add(await mMSNUnsafeBlock.GetTokenAsync(pMC, lContext).ConfigureAwait(false)); // wait until all commands that are msnunsafe complete, block all commands that are msnunsafe
// uidvalidity must be captured before the handles are resolved
lBuilder.AddUIDValidity(lSelectedMailbox.MessageCache.UIDValidity);
// resolve MSNs
cUIntList lMSNs = new cUIntList();
foreach (var lMessageHandle in pMessageHandles)
{
var lMSN = lSelectedMailbox.GetMSN(lMessageHandle);
if (lMSN != 0)
{
lMSNs.Add(lMSN);
}
}
if (lMSNs.Count == 0)
{
return;
}
// build command
lBuilder.Add(kFetchCommandPartFetchSpace, new cTextCommandPart(cSequenceSet.FromUInts(lMSNs)), cCommandPart.Space);
lBuilder.Add(pItems, lSelectedMailbox.MessageCache.NoModSeq);
// go
var lResult = await mPipeline.ExecuteAsync(pMC, lBuilder.EmitCommandDetails(), lContext).ConfigureAwait(false);
if (lResult.ResultType == eCommandResultType.ok)
{
lContext.TraceInformation("fetch success");
return;
}
if (lResult.ResultType == eCommandResultType.no)
{
throw new cUnsuccessfulCompletionException(lResult.ResponseText, 0, lContext);
}
throw new cProtocolErrorException(lResult, 0, lContext);
}
}
private async Task ZStoreAsync(cMethodControl pMC, cStoreFeedback pFeedback, eStoreOperation pOperation, cStorableFlags pFlags, ulong?pIfUnchangedSinceModSeq, cTrace.cContext pParentContext)
{
var lContext = pParentContext.NewMethod(nameof(cSession), nameof(ZStoreAsync), pMC, pFeedback, pOperation, pFlags, pIfUnchangedSinceModSeq);
// no validation ... all the parameters have been validated already by the cSession by the time we get here
using (var lBuilder = new cCommandDetailsBuilder())
{
lBuilder.Add(await mSelectExclusiveAccess.GetBlockAsync(pMC, lContext).ConfigureAwait(false)); // block select
cSelectedMailbox lSelectedMailbox = mMailboxCache.CheckInSelectedMailbox(pFeedback);
if (!lSelectedMailbox.SelectedForUpdate)
{
throw new InvalidOperationException(kInvalidOperationExceptionMessage.NotSelectedForUpdate);
}
lBuilder.Add(await mPipeline.GetIdleBlockTokenAsync(pMC, lContext).ConfigureAwait(false)); // stop the pipeline from iding (idle is msnunsafe)
lBuilder.Add(await mMSNUnsafeBlock.GetTokenAsync(pMC, lContext).ConfigureAwait(false)); // wait until all commands that are msnunsafe complete, block all commands that are msnunsafe
// uidvalidity must be captured before the handles are resolved
lBuilder.AddUIDValidity(lSelectedMailbox.MessageCache.UIDValidity);
// collector
cStoreFeedbackCollector lFeedbackCollector = new cStoreFeedbackCollector();
// resolve the handles to MSNs
foreach (var lItem in pFeedback)
{
var lMSN = lSelectedMailbox.GetMSN(lItem.MessageHandle);
if (lMSN != 0)
{
lFeedbackCollector.Add(lMSN, lItem);
}
}
// if no handles were resolved, we are done
if (lFeedbackCollector.Count == 0)
{
return;
}
// build the command
lBuilder.Add(kStoreCommandPartStoreSpace, new cTextCommandPart(cSequenceSet.FromUInts(lFeedbackCollector.UInts)), cCommandPart.Space);
if (pIfUnchangedSinceModSeq != null)
{
lBuilder.Add(kStoreCommandPartLParenUnchangedSinceSpace, new cTextCommandPart(pIfUnchangedSinceModSeq.Value), kStoreCommandPartRParenSpace);
}
lBuilder.Add(pOperation, pFlags);
// add the hook
var lHook = new cCommandHookStore(lFeedbackCollector, null, lSelectedMailbox);
lBuilder.Add(lHook);
// submit the command
var lResult = await mPipeline.ExecuteAsync(pMC, lBuilder.EmitCommandDetails(), lContext).ConfigureAwait(false);
// NOTE: updates may have been done on both OK and NO responses (see rfc 2180/ 7162) so we can't throw on a NO for this command ... NO indicates that some (or all) of the messages have pending deletes
// throw on a bad
if (lResult.ResultType == eCommandResultType.bad)
{
fCapabilities lTryIgnoring;
if (pIfUnchangedSinceModSeq == null)
{
lTryIgnoring = 0;
}
else
{
lTryIgnoring = fCapabilities.condstore;
}
throw new cProtocolErrorException(lResult, lTryIgnoring, lContext);
}
if (lResult.ResultType == eCommandResultType.ok)
{
lContext.TraceInformation("store success");
}
else
{
lContext.TraceInformation("store possible partial success");
}
}
}
private async Task <cBody> ZFetchBodyAsync(cMethodControl pMC, iMessageHandle pMessageHandle, bool pBinary, cSection pSection, uint pOrigin, uint pLength, cTrace.cContext pParentContext)
{
// the caller must have checked that the binary option is compatible with the section (e.g. if binary is true the section can't specify a textpart)
// the length must be greater than zero
var lContext = pParentContext.NewMethod(nameof(cSession), nameof(ZFetchBodyAsync), pMC, pMessageHandle, pBinary, pSection, pOrigin, pLength);
if (mDisposed)
{
throw new ObjectDisposedException(nameof(cSession));
}
if (_ConnectionState != eConnectionState.selected)
{
throw new InvalidOperationException(kInvalidOperationExceptionMessage.NotSelected);
}
if (pMessageHandle == null)
{
throw new ArgumentNullException(nameof(pMessageHandle));
}
if (pSection == null)
{
throw new ArgumentNullException(nameof(pSection));
}
using (var lBuilder = new cCommandDetailsBuilder())
{
lBuilder.Add(await mSelectExclusiveAccess.GetBlockAsync(pMC, lContext).ConfigureAwait(false)); // block select
cSelectedMailbox lSelectedMailbox = mMailboxCache.CheckInSelectedMailbox(pMessageHandle);
lBuilder.Add(await mPipeline.GetIdleBlockTokenAsync(pMC, lContext).ConfigureAwait(false)); // stop the pipeline from iding (idle is msnunsafe)
lBuilder.Add(await mMSNUnsafeBlock.GetTokenAsync(pMC, lContext).ConfigureAwait(false)); // wait until all commands that are msnunsafe complete, block all commands that are msnunsafe
// uidvalidity must be set before the handle is resolved
lBuilder.AddUIDValidity(lSelectedMailbox.MessageCache.UIDValidity);
// resolve the MSN
uint lMSN = lSelectedMailbox.GetMSN(pMessageHandle);
if (lMSN == 0)
{
if (pMessageHandle.Expunged)
{
throw new cMessageExpungedException(pMessageHandle);
}
throw new ArgumentOutOfRangeException(nameof(pMessageHandle));
}
// build command
lBuilder.Add(kFetchCommandPartFetchSpace, new cTextCommandPart(lMSN));
if (pBinary)
{
lBuilder.Add(kFetchCommandPartSpaceBinaryPeekLBracket);
}
else
{
lBuilder.Add(kFetchCommandPartSpaceBodyPeekLBracket);
}
lBuilder.Add(pSection, pOrigin, pLength);
// hook
var lHook = new cCommandHookFetchBodyMSN(pBinary, pSection, pOrigin, lMSN);
lBuilder.Add(lHook);
// go
var lResult = await mPipeline.ExecuteAsync(pMC, lBuilder.EmitCommandDetails(), lContext).ConfigureAwait(false);
if (lResult.ResultType == eCommandResultType.ok)
{
lContext.TraceInformation("fetch body success");
if (lHook.Body == null)
{
throw new cRequestedDataNotReturnedException(lContext);
}
return(lHook.Body);
}
if (lHook.Body != null)
{
lContext.TraceError("received body on a failed fetch body");
}
fCapabilities lTryIgnoring;
if (pBinary)
{
lTryIgnoring = fCapabilities.binary;
}
else
{
lTryIgnoring = 0;
}
if (lResult.ResultType == eCommandResultType.no)
{
throw new cUnsuccessfulCompletionException(lResult.ResponseText, lTryIgnoring, lContext);
}
throw new cProtocolErrorException(lResult, lTryIgnoring, lContext);
}
}
private async Task <cCopyFeedback> ZCopyAsync(cMethodControl pMC, cMessageHandleList pSourceMessageHandles, cMailboxCacheItem pDestinationItem, cTrace.cContext pParentContext)
{
var lContext = pParentContext.NewMethod(nameof(cSession), nameof(ZCopyAsync), pMC, pSourceMessageHandles, pDestinationItem);
using (var lBuilder = new cCommandDetailsBuilder())
{
lBuilder.Add(await mSelectExclusiveAccess.GetBlockAsync(pMC, lContext).ConfigureAwait(false)); // block select
cSelectedMailbox lSelectedMailbox = mMailboxCache.CheckInSelectedMailbox(pSourceMessageHandles);
lBuilder.Add(await mPipeline.GetIdleBlockTokenAsync(pMC, lContext).ConfigureAwait(false)); // stop the pipeline from iding (idle is msnunsafe)
lBuilder.Add(await mMSNUnsafeBlock.GetTokenAsync(pMC, lContext).ConfigureAwait(false)); // wait until all commands that are msnunsafe complete, block all commands that are msnunsafe
// uidvalidity must be captured before the handles are resolved
var lUIDValidity = lSelectedMailbox.MessageCache.UIDValidity;
lBuilder.AddUIDValidity(lUIDValidity);
// resolve the handles to MSNs
cUIntList lMSNs = new cUIntList();
foreach (var lMessageHandle in pSourceMessageHandles)
{
var lMSN = lSelectedMailbox.GetMSN(lMessageHandle);
if (lMSN == 0)
{
if (lMessageHandle.Expunged)
{
throw new cMessageExpungedException(lMessageHandle);
}
else
{
throw new ArgumentOutOfRangeException(nameof(pSourceMessageHandles));
}
}
lMSNs.Add(lMSN);
}
// build the command
lBuilder.Add(kCopyCommandPart, new cTextCommandPart(cSequenceSet.FromUInts(lMSNs)), cCommandPart.Space, pDestinationItem.MailboxNameCommandPart);
// add the hook
var lHook = new cCommandHookCopy(lUIDValidity);
lBuilder.Add(lHook);
// submit the command
var lResult = await mPipeline.ExecuteAsync(pMC, lBuilder.EmitCommandDetails(), lContext).ConfigureAwait(false);
if (lResult.ResultType == eCommandResultType.ok)
{
lContext.TraceInformation("copy success");
return(lHook.Feedback);
}
if (lResult.ResultType == eCommandResultType.no)
{
throw new cUnsuccessfulCompletionException(lResult.ResponseText, 0, lContext);
}
throw new cProtocolErrorException(lResult, 0, lContext);
}
}