public void ProcessRoutingUpdates(string headerValue)
{
if (string.IsNullOrEmpty(headerValue))
{
throw new ArgumentNullException("headerValue");
}
string[] array = headerValue.Split(new char[]
{
','
});
foreach (string text in array)
{
try
{
IRoutingEntry routingEntry = RoutingEntryHeaderSerializer.Deserialize(text);
if (ServerLocator.IsMailboxServerCacheKey(routingEntry.Key) && routingEntry.Destination.RoutingItemType == RoutingItemType.Server)
{
this.routeRefresherDiagnostics.IncrementTotalMailboxServerCacheUpdateAttempts();
if (this.mailboxServerCacheClient.AddEntry(routingEntry))
{
string value = "MailboxServerCacheUpdate:" + text;
this.routeRefresherDiagnostics.AddGenericInfo(value);
this.routeRefresherDiagnostics.IncrementSuccessfulMailboxServerCacheUpdates();
}
else
{
string value2 = "MailboxServerCacheFailure:" + text;
this.routeRefresherDiagnostics.AddErrorInfo(value2);
}
}
else if (ServerLocator.IsAnchorMailboxCacheKey(routingEntry.Key) && routingEntry.Destination.RoutingItemType == RoutingItemType.DatabaseGuid)
{
this.routeRefresherDiagnostics.IncrementTotalAnchorMailboxCacheUpdateAttempts();
if (this.anchorMailboxCacheClient.AddEntry(routingEntry))
{
string value3 = "AnchorMailboxCacheUpdate:" + text;
this.routeRefresherDiagnostics.AddGenericInfo(value3);
this.routeRefresherDiagnostics.IncrementSuccessfulAnchorMailboxCacheUpdates();
}
else
{
string value4 = "AnchorMailboxCacheFailure:" + text;
this.routeRefresherDiagnostics.AddErrorInfo(value4);
}
}
else
{
string value5 = "UnrecognizedRoutingEntry:" + text;
this.routeRefresherDiagnostics.AddErrorInfo(value5);
}
}
catch (ArgumentException)
{
string value6 = "DeserializationException:" + text;
this.routeRefresherDiagnostics.AddErrorInfo(value6);
}
}
}
public void LogRoutingKeys()
{
if (this.routingKeyLogs.Count == 0)
{
return;
}
StringBuilder stringBuilder = new StringBuilder();
StringBuilder stringBuilder2 = new StringBuilder();
foreach (Tuple <IRoutingKey, string> tuple in this.routingKeyLogs)
{
stringBuilder.Append(RoutingEntryHeaderSerializer.RoutingTypeToString(tuple.Item1.RoutingItemType) + "-" + tuple.Item1.Value + "|");
stringBuilder2.Append(tuple.Item2 + "|");
}
this.logger.LogField(LogKey.AnchorMailbox, stringBuilder.ToString());
this.logger.LogField(LogKey.RoutingHint, stringBuilder2.ToString());
}
internal IEnumerable <string> GetRoutingUpdates(IEnumerable <IRoutingEntry> routingEntries)
{
if (routingEntries == null)
{
throw new ArgumentNullException("routingEntries");
}
List <string> list = new List <string>();
foreach (IRoutingEntry routingEntry in routingEntries)
{
IRoutingLookup lookupForType = this.lookupFactory.GetLookupForType(routingEntry.Key.RoutingItemType);
if (lookupForType != null)
{
IRoutingEntry routingEntry2 = lookupForType.GetRoutingEntry(routingEntry.Key, this.diagnostics);
if (routingEntry2 != null && this.ShouldSendRoutingEntryUpdate(routingEntry, routingEntry2))
{
list.Add(RoutingEntryHeaderSerializer.Serialize(routingEntry2));
}
}
}
return(list);
}
private void OnPostAuthorizeInternal(HttpContextBase context)
{
if (!HttpProxySettings.RouteSelectorEnabled.Value && !RouteSelectorModule.IsTesting)
{
return;
}
if (!RouteSelectorModule.IsTesting)
{
RequestLogger logger = RequestLogger.GetLogger(context);
this.diagnostics = new RouteSelectorDiagnostics(logger);
}
this.diagnostics.SaveRoutingLatency(delegate
{
ServerLocatorReturn serverLocatorReturn = null;
IRoutingKey[] array = (IRoutingKey[])context.Items["RoutingKeys"];
if (array == null)
{
return;
}
if (array.Length == 0)
{
return;
}
serverLocatorReturn = this.serverLocator.LocateServer(array, this.diagnostics);
this.diagnostics.LogLatencies();
this.diagnostics.ProcessLatencyPerfCounters();
if (serverLocatorReturn != null && !string.IsNullOrEmpty(serverLocatorReturn.ServerFqdn))
{
if (!context.Request.IsProxyTestProbeRequest())
{
context.Request.Headers.Add("X-ProxyTargetServer", serverLocatorReturn.ServerFqdn);
context.Request.Headers.Add("X-ProxyTargetServerVersion", (serverLocatorReturn.ServerVersion != null) ? serverLocatorReturn.ServerVersion.ToString() : string.Empty);
}
this.diagnostics.SetTargetServer(serverLocatorReturn.ServerFqdn);
RouteSelectorDiagnostics.UpdateRoutingFailurePerfCounter(serverLocatorReturn.ServerFqdn, false);
if (serverLocatorReturn.RoutingEntries.Count > 0)
{
StringBuilder stringBuilder = new StringBuilder();
bool flag = true;
foreach (IRoutingEntry routingEntry in serverLocatorReturn.RoutingEntries)
{
if (!flag)
{
stringBuilder.Append(",");
}
string value = RoutingEntryHeaderSerializer.Serialize(routingEntry);
stringBuilder.Append(value);
flag = false;
this.diagnostics.AddRoutingEntry(value);
}
context.Request.Headers.Add("X-RoutingEntry", stringBuilder.ToString());
}
int versionNumber = serverLocatorReturn.ServerVersion ?? 0;
ServerVersion serverVersion = new ServerVersion(versionNumber);
string targetServerVersion = string.Format(CultureInfo.InvariantCulture, "{0:d}.{1:d2}.{2:d4}.{3:d3}", new object[]
{
serverVersion.Major,
serverVersion.Minor,
serverVersion.Build,
serverVersion.Revision
});
this.diagnostics.SetTargetServerVersion(targetServerVersion);
return;
}
string value2 = "RouteNotFoundError";
this.diagnostics.AddErrorInfo(value2);
context.Response.StatusCode = 500;
bool wasFailure = true;
foreach (IRoutingKey routingKey in array)
{
if (routingKey.RoutingItemType == RoutingItemType.LiveIdMemberName || routingKey.RoutingItemType == RoutingItemType.Smtp)
{
wasFailure = false;
context.Response.StatusCode = 404;
break;
}
}
RouteSelectorDiagnostics.UpdateRoutingFailurePerfCounter(null, wasFailure);
context.ApplicationInstance.CompleteRequest();
});
}
public void OnBeginRequest(HttpContextBase context)
{
ExWatson.SendReportOnUnhandledException(delegate()
{
RequestDetailsLogger requestDetailsLogger = null;
RoutingUpdateDiagnostics routingUpdateDiagnostics = this.diagnostics as RoutingUpdateDiagnostics;
if (routingUpdateDiagnostics != null)
{
HttpContext context2 = context.ApplicationInstance.Context;
requestDetailsLogger = RequestDetailsLoggerBase <RequestDetailsLogger> .InitializeRequestLogger();
RequestDetailsLoggerBase <RequestDetailsLogger> .SetCurrent(context2, requestDetailsLogger);
requestDetailsLogger.Set(RoutingUpdateModuleMetadata.Protocol, RequestDetailsLogger.ProtocolType.Value);
routingUpdateDiagnostics.Clear();
}
NameValueCollection headers = context.Request.Headers;
List <string> list = new List <string>();
list.AddIfNotNull(headers.Get("X-RoutingEntry"));
if (RoutingUpdateModule.RUMLegacyRoutingEntryEnabled.Value)
{
list.AddIfNotNull(headers.Get("X-LegacyRoutingEntry"));
}
if (list.Count > 0)
{
try
{
foreach (string text in list)
{
string[] source = text.Split(new char[]
{
','
});
IEnumerable <IRoutingEntry> routingEntries = from entry in source
where RoutingEntryHeaderSerializer.IsValidHeaderString(entry)
select RoutingEntryHeaderSerializer.Deserialize(entry);
foreach (string value in this.GetRoutingUpdates(routingEntries))
{
context.Response.Headers.Add("X-RoutingEntryUpdate", value);
}
}
}
catch (Exception ex)
{
requestDetailsLogger.AppendGenericError("Exception", ex.ToString());
throw;
}
}
if (routingUpdateDiagnostics != null && !requestDetailsLogger.IsDisposed)
{
if (routingUpdateDiagnostics.GetTotalLatency() > 0L)
{
routingUpdateDiagnostics.LogLatencies(requestDetailsLogger);
requestDetailsLogger.Commit();
}
else
{
requestDetailsLogger.SkipLogging = true;
}
requestDetailsLogger.Dispose();
}
});
}
IRoutingEntry IRoutingLookup.GetRoutingEntry(IRoutingKey routingKey, IRoutingDiagnostics diagnostics)
{
if (routingKey == null)
{
throw new ArgumentNullException("routingKey");
}
if (diagnostics == null)
{
throw new ArgumentNullException("diagnostics");
}
if (routingKey.RoutingItemType != this.validItemType)
{
string message = string.Format("Routing key type {0} is not supported in {1}", RoutingEntryHeaderSerializer.RoutingTypeToString(routingKey.RoutingItemType), base.GetType());
throw new ArgumentException(message, "routingKey");
}
string sharedCacheKeyFromRoutingKey = this.sharedCache.GetSharedCacheKeyFromRoutingKey(routingKey);
try
{
byte[] bytes;
if (this.sharedCache.TryGet(sharedCacheKeyFromRoutingKey, out bytes, diagnostics))
{
AnchorMailboxCacheEntry anchorMailboxCacheEntry = new AnchorMailboxCacheEntry();
anchorMailboxCacheEntry.FromByteArray(bytes);
if (anchorMailboxCacheEntry.Database != null)
{
DatabaseGuidRoutingDestination destination = new DatabaseGuidRoutingDestination(anchorMailboxCacheEntry.Database.ObjectGuid, anchorMailboxCacheEntry.DomainName, anchorMailboxCacheEntry.Database.PartitionFQDN);
return(new SuccessfulMailboxRoutingEntry(routingKey, destination, DateTime.Now.ToFileTimeUtc()));
}
}
}
catch (SharedCacheException ex)
{
ErrorRoutingDestination destination2 = new ErrorRoutingDestination(ex.Message);
return(new FailedMailboxRoutingEntry(routingKey, destination2, DateTime.UtcNow.ToFileTimeUtc()));
}
return(null);
}
