public static List <ConditionalRegistrationLog.ConditionalRegistrationHitMetadata> GetHitsMetadata(string userIdentity = "")
{
List <ConditionalRegistrationLog.ConditionalRegistrationHitMetadata> list = null;
string text = Path.Combine(ConditionalRegistrationLog.LoggingDirectory, userIdentity);
if (!string.IsNullOrEmpty(userIdentity))
{
list = ConditionalRegistrationLog.GetHitsMetadataForUser(text, userIdentity);
}
else
{
DirectoryInfo directoryInfo = new DirectoryInfo(text);
DirectoryInfo[] directories = directoryInfo.GetDirectories();
foreach (DirectoryInfo directoryInfo2 in directories)
{
List <ConditionalRegistrationLog.ConditionalRegistrationHitMetadata> hitsMetadataForUser = ConditionalRegistrationLog.GetHitsMetadataForUser(directoryInfo2.FullName, directoryInfo2.Name);
if (hitsMetadataForUser != null)
{
if (list == null)
{
list = new List <ConditionalRegistrationLog.ConditionalRegistrationHitMetadata>();
}
list.AddRange(hitsMetadataForUser);
}
}
}
return(list);
}
internal void HydrateNonPersistentRegistrations()
{
string conditionalRegistrationsDirectory = ConditionalRegistrationLog.GetConditionalRegistrationsDirectory();
if (!string.IsNullOrEmpty(conditionalRegistrationsDirectory))
{
DirectoryInfo directoryInfo = new DirectoryInfo(conditionalRegistrationsDirectory);
FileInfo[] files = directoryInfo.GetFiles("*.xml");
foreach (FileInfo fileInfo in files)
{
try
{
ConditionalRegistration conditionalRegistration;
using (StreamReader streamReader = fileInfo.OpenText())
{
conditionalRegistration = ConditionalRegistration.DeserializeFromStreamReader(streamReader);
}
if (conditionalRegistration != null)
{
ConditionalRegistrationCache.Singleton.Register(conditionalRegistration);
}
else
{
File.Delete(fileInfo.FullName);
}
}
catch (Exception exception)
{
ConditionalRegistrationLog.LogFailedHydration(new XElement(string.Format("Failed to hydrate registration with cookie:{0}", fileInfo.Name)), exception);
}
}
}
}
private static FileInfo[] GetHits(string cookie, string user)
{
string orCreateLogFilePathForCookie = ConditionalRegistrationLog.GetOrCreateLogFilePathForCookie(user, cookie, false);
DirectoryInfo directoryInfo = new DirectoryInfo(orCreateLogFilePathForCookie);
if (!directoryInfo.Exists)
{
return(null);
}
return(directoryInfo.GetFiles("*.xml", SearchOption.TopDirectoryOnly));
}
public static string Save(ConditionalRegistration registration)
{
string text = Path.Combine(ConditionalRegistrationLog.GetConditionalRegistrationsDirectory(), string.Format("{0}.{1}", registration.Cookie, "xml"));
ExTraceGlobals.DiagnosticHandlersTracer.TraceDebug <string, string>(0L, "[ConditionalRegistrationLog.Save] Logging registration for '{0}' of user '{1}'", registration.Cookie, registration.User);
using (XmlWriter xmlWriter = XmlWriter.Create(text, ConditionalRegistrationLog.writerSettings))
{
XElement xelement = new XElement("ConditionalRegistration");
XElement content = new XElement("Description")
{
Value = registration.Description
};
xelement.Add(content);
XElement content2 = new XElement("CreatedTime")
{
Value = registration.Created.ToString()
};
xelement.Add(content2);
XElement content3 = new XElement("User")
{
Value = registration.User
};
xelement.Add(content3);
XElement content4 = new XElement("Cookie")
{
Value = registration.Cookie
};
xelement.Add(content4);
XElement content5 = new XElement("PropertiesToFetch")
{
Value = registration.OriginalPropertiesToFetch
};
xelement.Add(content5);
XElement content6 = new XElement("Filter")
{
Value = registration.OriginalFilter
};
xelement.Add(content6);
XElement content7 = new XElement("TimeToLive")
{
Value = registration.TimeToLive.ToString()
};
xelement.Add(content7);
XElement content8 = new XElement("MaxHits")
{
Value = registration.MaxHits.ToString()
};
xelement.Add(content8);
xelement.WriteTo(xmlWriter);
xmlWriter.Flush();
}
return(text);
}
// Token: 0x06000904 RID: 2308 RVA: 0x00023B68 File Offset: 0x00021D68
internal void GetRegistrationMetadata(string userIdentity, out List <BaseConditionalRegistration> active, out List <ConditionalRegistrationLog.ConditionalRegistrationHitMetadata> hits)
{
if (string.IsNullOrEmpty(userIdentity))
{
active = this.cache.Values;
hits = ConditionalRegistrationLog.GetHitsMetadata("");
return;
}
active = (from s in this.cache.Values
where s.User == userIdentity
select s).ToList <BaseConditionalRegistration>();
hits = ConditionalRegistrationLog.GetHitsMetadata(userIdentity);
}
static ConditionalRegistrationLog()
{
ConditionalRegistrationLog.LoggingRootPath = Path.Combine(ExchangeSetupContext.LoggingPath, "ConditionalHandlers");
ConditionalRegistrationLog.CreateLogFilePath();
ConditionalRegistrationLog.writerSettings = new XmlWriterSettings();
ConditionalRegistrationLog.writerSettings.CheckCharacters = false;
ConditionalRegistrationLog.writerSettings.CloseOutput = true;
ConditionalRegistrationLog.writerSettings.ConformanceLevel = ConformanceLevel.Fragment;
ConditionalRegistrationLog.writerSettings.Indent = true;
ConditionalRegistrationLog.readerSettings = new XmlReaderSettings();
ConditionalRegistrationLog.readerSettings.CheckCharacters = false;
ConditionalRegistrationLog.readerSettings.ConformanceLevel = ConformanceLevel.Fragment;
ConditionalRegistrationLog.readerSettings.DtdProcessing = DtdProcessing.Prohibit;
}
public static void LogFailedHydration(XElement childNode, Exception exception)
{
if (ConditionalRegistrationLog.OnFailedHydration != null)
{
ConditionalRegistrationLog.OnFailedHydration(childNode, exception);
return;
}
ConditionalRegistrationLog.EventLog.LogEvent(ApplicationLogicEventLogConstants.Tuple_PersistentHandlerRegistrationFailed, null, new object[]
{
childNode.ToString(SaveOptions.None),
ConditionalRegistrationLog.ProtocolName,
exception.ToString()
});
}
// Token: 0x06000901 RID: 2305 RVA: 0x000239C0 File Offset: 0x00021BC0
internal void Register(ConditionalRegistration registration)
{
TimeSpan expiration = (ConditionalRegistrationCache.MaxActiveRegistrationTimeEntry.Value < registration.TimeToLive) ? ConditionalRegistrationCache.MaxActiveRegistrationTimeEntry.Value : registration.TimeToLive;
if (this.cache.TryAddAbsolute(registration.Cookie, registration, expiration))
{
this.UpdateActiveProperties(registration, true);
if (ConditionalRegistrationCache.TESTHOOK_PersistRegistration == null)
{
ConditionalRegistrationLog.Save(registration);
return;
}
ConditionalRegistrationCache.TESTHOOK_PersistRegistration(registration);
}
}
public static void DeleteRegistration(string cookie)
{
string path = Path.Combine(ConditionalRegistrationLog.GetConditionalRegistrationsDirectory(), string.Format("{0}.{1}", cookie, "xml"));
ExTraceGlobals.DiagnosticHandlersTracer.TraceDebug <string>(0L, "[ConditionalRegistrationLog.DeleteRegistration] Deleting registration for '{0}'", cookie);
if (File.Exists(path))
{
try
{
File.Delete(path);
}
catch (Exception ex)
{
ExTraceGlobals.DiagnosticHandlersTracer.TraceDebug <string, string>(0L, "[ConditionalRegistrationLog.DeleteRegistration] failure deleting registration for '{0}'. Exception: {1}", cookie, ex.ToString());
}
}
}
// Token: 0x0600090B RID: 2315 RVA: 0x00023C9C File Offset: 0x00021E9C
private void HandleRemoveRegistration(string key, BaseConditionalRegistration value, RemoveReason reason)
{
ExTraceGlobals.DiagnosticHandlersTracer.TraceDebug <string, RemoveReason, string>((long)this.GetHashCode(), "[ConditionalRegistrationCache.HandleRemoveRegistration] Cookie: {0} was removed for reason {1}. Description: '{2}'", key, reason, value.Description ?? "<NULL>");
if (ConditionalRegistrationCache.TESTHOOK_DeleteRegistration == null)
{
ConditionalRegistrationLog.DeleteRegistration(key);
}
else
{
ConditionalRegistrationCache.TESTHOOK_DeleteRegistration(key);
}
this.UpdateActiveProperties(value, false);
if (value.OnExpired != null)
{
value.OnExpired(value, reason);
}
}
// Token: 0x06000907 RID: 2311 RVA: 0x00023C10 File Offset: 0x00021E10
internal bool Remove(string cookie)
{
if (ConditionalRegistrationCache.TESTHOOK_DeleteRegistration == null)
{
ConditionalRegistrationLog.DeleteRegistration(cookie);
}
else
{
ConditionalRegistrationCache.TESTHOOK_DeleteRegistration(cookie);
}
BaseConditionalRegistration baseConditionalRegistration = this.cache.Remove(cookie.ToString());
if (baseConditionalRegistration != null)
{
this.UpdateActiveProperties(baseConditionalRegistration, false);
}
return(baseConditionalRegistration != null);
}
public static string Save(ConditionalResults hit)
{
string fullPathForCookie = ConditionalRegistrationLog.GetFullPathForCookie(hit.Registration.User.Replace("/", "-"), hit.Registration.Cookie);
ConditionalRegistrationLog.LimitFileCount(fullPathForCookie);
ExTraceGlobals.DiagnosticHandlersTracer.TraceDebug <string, string>(0L, "[ConditionalRegistrationLog.Log] Logging registration results for '{0}' to path '{1}'", hit.Registration.Cookie, fullPathForCookie);
try
{
using (XmlWriter xmlWriter = XmlWriter.Create(fullPathForCookie, ConditionalRegistrationLog.writerSettings))
{
hit.GetXmlResults().WriteTo(xmlWriter);
xmlWriter.Flush();
}
}
catch (Exception arg)
{
ExTraceGlobals.DiagnosticHandlersTracer.TraceDebug <string, Exception>(0L, "[ConditionalRegistrationLog.Log] Caught exception trying to save hit for cookie: {0}. Exception: {1}", hit.Registration.Cookie, arg);
}
return(fullPathForCookie);
}
internal void HydratePersistentHandlers()
{
if (this.Data == null || this.hydrated)
{
return;
}
foreach (XNode xnode in this.Data.DescendantNodes())
{
XElement xelement = xnode as XElement;
if (xelement != null)
{
try
{
PersistentConditionalRegistration persistentRegistration = PersistentConditionalRegistration.CreateFromXml(xelement);
ConditionalRegistrationCache.Singleton.Register(persistentRegistration);
}
catch (Exception exception)
{
ConditionalRegistrationLog.LogFailedHydration(xelement, exception);
}
}
}
this.hydrated = true;
}
public static string GetFullPathForCookie(string userIdentity, string cookie)
{
return(Path.Combine(ConditionalRegistrationLog.GetOrCreateLogFilePathForCookie(userIdentity, cookie, true), string.Format("{0}_{1}.xml", DateTime.UtcNow.ToString("yyyy-MM-dd_HH-mm-ss.fff"), Thread.CurrentThread.ManagedThreadId)));
}
// Token: 0x060008C2 RID: 2242 RVA: 0x00022E68 File Offset: 0x00021068
protected BaseConditionalRegistration(string cookie, string user, string propertiesToFetch, string whereClause)
{
this.User = user;
this.OriginalFilter = whereClause;
this.OriginalPropertiesToFetch = propertiesToFetch;
this.PropertiesToFetch = BaseConditionalRegistration.ParsePropertiesToFetch(propertiesToFetch);
this.QueryFilter = BaseConditionalRegistration.ParseWhereClause(whereClause);
this.Created = (ExDateTime)TimeProvider.UtcNow;
this.Cookie = cookie;
if (BaseConditionalRegistration.GetHitCountForCookie == null)
{
ConditionalRegistrationLog.ConditionalRegistrationHitMetadata hitsForCookie = ConditionalRegistrationLog.GetHitsForCookie(user, cookie);
if (hitsForCookie != null)
{
this.hits = hitsForCookie.HitFiles.Length;
return;
}
}
else
{
this.hits = BaseConditionalRegistration.GetHitCountForCookie();
}
}
// Token: 0x06000905 RID: 2309 RVA: 0x00023BE0 File Offset: 0x00021DE0
internal void GetRegistrationMetadata(string userIdentity, string cookie, out BaseConditionalRegistration reg, out ConditionalRegistrationLog.ConditionalRegistrationHitMetadata hit)
{
reg = this.GetRegistration(cookie);
hit = ConditionalRegistrationLog.GetHitsForCookie(userIdentity, cookie);
}
