public static SyncCookie FromBytes(byte[] cookieData)
{
Exception ex = null;
SyncCookie result = null;
if (!SyncCookie.TryFromBytes(cookieData, out result, out ex))
{
throw ex;
}
return(result);
}
public static QueryFilter GetDeltaFilter(SyncCookie inputCookie)
{
if (inputCookie == null)
{
throw new ArgumentNullException("inputCookie");
}
return(new AndFilter(new QueryFilter[]
{
new ComparisonFilter(ComparisonOperator.GreaterThan, SyncMailboxSchema.UsnChanged, inputCookie.LowWatermark),
new ComparisonFilter(ComparisonOperator.LessThanOrEqual, SyncMailboxSchema.UsnChanged, inputCookie.HighWatermark)
}));
}
private static LocalizedString FormatCookieVerboseString(SyncCookie cookie)
{
if (cookie == null)
{
return(Strings.VerboseSyncTaskNullCookie);
}
string pageCookie = "<null>";
if (cookie.PageCookie != null && cookie.PageCookie.Length > 0)
{
pageCookie = string.Format("{{{0}, ...}}", cookie.PageCookie[0]);
}
return(Strings.VerboseSyncTaskPopulateCookie(cookie.Version, cookie.DomainController, cookie.LowWatermarks.Count, cookie.LowWatermark, cookie.HighWatermarks.Count, cookie.HighWatermark, pageCookie));
}
public static bool TryFromBytes(byte[] cookieData, out SyncCookie cookie, out Exception ex)
{
ex = null;
cookie = null;
if (cookieData == null)
{
ex = new ArgumentNullException("cookieData");
return(false);
}
try
{
string @string = Encoding.UTF8.GetString(cookieData);
string[] array = @string.Split(new string[]
{
SyncCookie.Delimiter
}, StringSplitOptions.None);
if (array.Length < 1)
{
ex = new InvalidCookieException();
return(false);
}
int num = int.Parse(array[0]);
if (num != 1 && num != 2 && num != 3)
{
ex = new CookieVersionUnsupportedException(num);
return(false);
}
if (((num == 1 || num == 2) && array.Length != 5) || (num == 3 && array.Length != 6))
{
ex = new InvalidCookieException();
return(false);
}
Guid guid = new Guid(array[1]);
WatermarkMap watermarkMap = WatermarkMap.Empty;
if (num == 1)
{
long value = long.Parse(array[2]);
watermarkMap.Add(guid, value);
}
else
{
watermarkMap = WatermarkMap.Parse(array[2]);
}
WatermarkMap watermarkMap2 = WatermarkMap.Empty;
if (num == 1)
{
long value2 = long.Parse(array[3]);
watermarkMap2.Add(guid, value2);
}
else
{
watermarkMap2 = WatermarkMap.Parse(array[3]);
}
byte[] pageCookie = null;
if (!string.IsNullOrEmpty(array[4]))
{
pageCookie = Convert.FromBase64String(array[4]);
}
byte[] pageCookie2 = null;
if (num == 3 && !string.IsNullOrEmpty(array[5]))
{
pageCookie2 = Convert.FromBase64String(array[5]);
}
cookie = new SyncCookie(guid, watermarkMap, watermarkMap2, pageCookie, pageCookie2);
}
catch (DecoderFallbackException innerException)
{
ex = new InvalidCookieException(innerException);
return(false);
}
catch (FormatException innerException2)
{
ex = new InvalidCookieException(innerException2);
return(false);
}
catch (OverflowException innerException3)
{
ex = new InvalidCookieException(innerException3);
return(false);
}
return(true);
}
public CookieObjectTriple(int currentPage, T dataObject, SyncCookie cookie)
{
this.CurrentPage = currentPage;
this.DataObject = dataObject;
this.Cookie = cookie;
}
public static bool HandleTaskWritePagedResult <T>(IEnumerable <T> dataObjects, IEnumerable <T> dataObjects2, SyncCookie inputCookie, ref SyncCookie outputCookie, SyncTaskHelper.ParameterlessMethod <bool> isStopping, SyncTaskHelper.OneParameterMethod <bool, IConfigurable> shouldSkipObject, SyncTaskHelper.VoidOneParameterMethod <IConfigurable> writeResult, int pages, Task.TaskVerboseLoggingDelegate writeVerbose, Task.TaskErrorLoggingDelegate writeError, out bool hasOutput) where T : IConfigurable, new()
{
TaskLogger.LogEnter(new object[]
{
dataObjects
});
int num = 1000;
int num2 = 0;
bool flag = true;
bool flag2 = true;
SyncTaskHelper.CookieObjectTriple <T> cookieObjectTriple = null;
int num3 = 1;
ADPagedReader <T> adpagedReader = dataObjects as ADPagedReader <T>;
ADPagedReader <T> adpagedReader2 = dataObjects2 as ADPagedReader <T>;
byte[] pageCookie = null;
byte[] array = null;
byte[] cookie = adpagedReader.Cookie;
byte[] cookie2 = adpagedReader2.Cookie;
byte[] array2 = cookie2;
hasOutput = false;
for (;;)
{
using (IEnumerator <T> enumerator = flag ? dataObjects.GetEnumerator() : dataObjects2.GetEnumerator())
{
bool flag3 = enumerator.MoveNext();
bool flag4 = !flag && ((cookieObjectTriple == null && num2 == 0) || (cookieObjectTriple != null && num2 == num - 1));
if ((adpagedReader.LastRetrievedCount == 0 && adpagedReader.Cookie != null && adpagedReader.Cookie.Length != 0) || (adpagedReader2.LastRetrievedCount == 0 && adpagedReader2.Cookie != null && adpagedReader2.Cookie.Length != 0))
{
return(false);
}
while (!isStopping() && flag3)
{
T t = enumerator.Current;
if (flag)
{
pageCookie = adpagedReader.Cookie;
}
else if (array != adpagedReader2.Cookie)
{
array2 = array;
array = adpagedReader2.Cookie;
}
flag3 = enumerator.MoveNext();
if (!shouldSkipObject(t))
{
hasOutput = true;
if (cookieObjectTriple != null)
{
if (num2 == num - 1 || flag2)
{
outputCookie = cookieObjectTriple.Cookie;
}
else
{
outputCookie = null;
}
writeResult(cookieObjectTriple.DataObject);
flag2 = false;
if (num2 == num - 1)
{
num2 = 0;
num3++;
}
else
{
num2++;
}
if (outputCookie != null)
{
pages--;
if (pages < 0)
{
break;
}
}
}
else
{
pageCookie = cookie;
array = cookie2;
array2 = cookie2;
}
cookieObjectTriple = new SyncTaskHelper.CookieObjectTriple <T>(num3, t, new SyncCookie(inputCookie.DomainController, inputCookie.LowWatermarks, inputCookie.HighWatermarks, pageCookie, flag4 ? array : array2));
}
}
if (pages >= 0)
{
if (!flag && !flag3 && cookieObjectTriple != null && pages >= 0)
{
outputCookie = new SyncCookie(inputCookie.DomainController, inputCookie.HighWatermarks, WatermarkMap.Empty, null, null);
writeResult(cookieObjectTriple.DataObject);
}
else if (flag)
{
flag = false;
continue;
}
}
}
break;
}
TaskLogger.LogExit();
return(true);
}
public static bool HandleTaskWritePagedResult <T>(IEnumerable <T> dataObjects, SyncCookie inputCookie, ref SyncCookie outputCookie, SyncTaskHelper.ParameterlessMethod <bool> isStopping, SyncTaskHelper.OneParameterMethod <bool, IConfigurable> shouldSkipObject, SyncTaskHelper.VoidOneParameterMethod <IConfigurable> writeResult, int pages, Task.TaskVerboseLoggingDelegate writeVerbose, Task.TaskErrorLoggingDelegate writeError, out bool hasOutput) where T : IConfigurable, new()
{
TaskLogger.LogEnter(new object[]
{
dataObjects
});
ADPagedReader <T> adpagedReader = dataObjects as ADPagedReader <T>;
hasOutput = false;
using (IEnumerator <T> enumerator = dataObjects.GetEnumerator())
{
bool flag = true;
SyncTaskHelper.CookieObjectTriple <T> cookieObjectTriple = null;
byte[] cookie = adpagedReader.Cookie;
bool flag2 = enumerator.MoveNext();
if (adpagedReader.LastRetrievedCount == 0 && adpagedReader.Cookie != null && adpagedReader.Cookie.Length != 0)
{
return(false);
}
while (!isStopping() && flag2)
{
T t = enumerator.Current;
byte[] pageCookie = adpagedReader.Cookie;
int pagesReturned = adpagedReader.PagesReturned;
flag2 = enumerator.MoveNext();
if (!shouldSkipObject(t))
{
hasOutput = true;
if (cookieObjectTriple != null)
{
if (cookieObjectTriple.CurrentPage != pagesReturned || flag)
{
outputCookie = cookieObjectTriple.Cookie;
}
else
{
outputCookie = null;
}
writeResult(cookieObjectTriple.DataObject);
if (outputCookie != null)
{
pages--;
if (pages < 0)
{
break;
}
}
flag = false;
}
else
{
pageCookie = cookie;
}
cookieObjectTriple = new SyncTaskHelper.CookieObjectTriple <T>(pagesReturned, t, new SyncCookie(inputCookie.DomainController, inputCookie.LowWatermarks, inputCookie.HighWatermarks, pageCookie));
}
}
if (!flag2 && cookieObjectTriple != null && pages >= 0)
{
outputCookie = new SyncCookie(inputCookie.DomainController, inputCookie.HighWatermarks, WatermarkMap.Empty, null);
writeResult(cookieObjectTriple.DataObject);
}
}
TaskLogger.LogExit();
return(true);
}
public static bool HandleTaskWritePagedResult <T>(IEnumerable <T> dataObjects, SyncCookie inputCookie, ref SyncCookie outputCookie, SyncTaskHelper.ParameterlessMethod <bool> isStopping, SyncTaskHelper.OneParameterMethod <bool, IConfigurable> shouldSkipObject, SyncTaskHelper.VoidOneParameterMethod <IConfigurable> writeResult, int pages, Task.TaskVerboseLoggingDelegate writeVerbose, Task.TaskErrorLoggingDelegate writeError) where T : IConfigurable, new()
{
bool flag;
return(SyncTaskHelper.HandleTaskWritePagedResult <T>(dataObjects, inputCookie, ref outputCookie, isStopping, shouldSkipObject, writeResult, pages, writeVerbose, writeError, out flag));
}
public static SyncCookie ResolveSyncCookie(byte[] cookieData, IDirectorySession session, Task.TaskVerboseLoggingDelegate writeVerbose, Task.TaskErrorLoggingDelegate writeError)
{
if (session == null)
{
throw new ArgumentNullException("session");
}
string text = SyncTaskHelper.GetCurrentServerFromSession(session);
ITopologyConfigurationSession topologyConfigurationSession = DirectorySessionFactory.Default.CreateTopologyConfigurationSession(text, true, ConsistencyMode.IgnoreInvalid, ADSessionSettings.FromRootOrgScopeSet(), 84, "ResolveSyncCookie", "f:\\15.00.1497\\sources\\dev\\Management\\src\\Management\\Common\\recipient\\SyncTaskHelper.cs");
Guid guid = topologyConfigurationSession.GetInvocationIdByFqdn(text);
writeVerbose(Strings.VerboseSyncTaskDomainControllerToUse(text, guid));
if (cookieData == null)
{
writeVerbose(SyncTaskHelper.FormatCookieVerboseString(null));
SyncCookie syncCookie = new SyncCookie(guid, WatermarkMap.Empty, SyncConfiguration.GetReplicationCursors(topologyConfigurationSession), null);
writeVerbose(Strings.VerboseSyncTaskHighestCommittedUSN(text, syncCookie.HighWatermark));
return(syncCookie);
}
SyncCookie syncCookie2 = null;
Exception exception = null;
if (!SyncCookie.TryFromBytes(cookieData, out syncCookie2, out exception))
{
writeError(exception, ErrorCategory.InvalidData, null);
}
writeVerbose(SyncTaskHelper.FormatCookieVerboseString(syncCookie2));
if (syncCookie2.DomainController != guid)
{
writeVerbose(Strings.VerboseSyncTaskDomainControllerMismatch(syncCookie2.DomainController, guid));
ADServer adserver = topologyConfigurationSession.FindDCByFqdn(text);
if (syncCookie2.PageCookie != null)
{
writeVerbose(Strings.VerboseSyncTaskCookieHasPageData(syncCookie2.DomainController, guid));
string text2 = SyncTaskHelper.FindAvailableServerByInvocationId(syncCookie2.DomainController, topologyConfigurationSession, adserver.Site);
if (text2 != null)
{
session.DomainController = text2;
writeVerbose(Strings.VerboseSyncTaskHighestCommittedUSN(text2, syncCookie2.HighWatermark));
return(syncCookie2);
}
writeError(new PageCookieInterruptedException(), ErrorCategory.InvalidData, null);
}
if (!syncCookie2.LowWatermarks.ContainsKey(guid))
{
writeVerbose(Strings.VerboseSyncTaskCookieCurrentWatermarksMissingCurrentDC(syncCookie2.DomainController, guid));
string text3 = SyncTaskHelper.FindAvailableServerByInvocationId(syncCookie2.DomainController, topologyConfigurationSession, adserver.Site);
if (text3 != null)
{
session.DomainController = text3;
topologyConfigurationSession.DomainController = text3;
text = text3;
guid = syncCookie2.DomainController;
}
else
{
writeVerbose(Strings.VerboseSyncTaskCookieOriginatingDCNotAvailable(syncCookie2.DomainController));
Guid guid2;
string text4 = SyncTaskHelper.FindAvailableServerFromWatermarks(syncCookie2.LowWatermarks, topologyConfigurationSession, adserver.Site, out guid2);
if (text4 != null)
{
session.DomainController = text4;
topologyConfigurationSession.DomainController = text4;
text = text4;
guid = guid2;
}
else
{
writeError(new CookieExpiredException(syncCookie2.DomainController, guid), ErrorCategory.InvalidData, null);
}
}
}
}
WatermarkMap lowWatermarks = SyncTaskHelper.FallbackWatermarks(syncCookie2.LowWatermarks, syncCookie2.DomainController, guid);
WatermarkMap highWatermarks = SyncTaskHelper.FallbackWatermarks(syncCookie2.HighWatermarks, syncCookie2.DomainController, guid);
if (syncCookie2.HighWatermark == 0L)
{
syncCookie2 = new SyncCookie(guid, lowWatermarks, SyncConfiguration.GetReplicationCursors(topologyConfigurationSession), null);
}
else
{
syncCookie2 = new SyncCookie(guid, lowWatermarks, highWatermarks, syncCookie2.PageCookie);
}
writeVerbose(Strings.VerboseSyncTaskHighestCommittedUSN(text, syncCookie2.HighWatermark));
return(syncCookie2);
}
