/// <summary>
/// Gets the registrys.
/// </summary>
/// <param name="orderParameters">The order parameters.</param>
/// <returns></returns>
public async Task <APIResponse> GetRegistrys(RegistryParameters orderParameters)
{
try
{
var client = httpClientFactory.CreateClient(ECommerceServiceOperation.serviceName);
UriBuilder url = new UriBuilder(servicesConfig.ECommerce + ECommerceServiceOperation.GetRegistry());
url.Query = QueryStringHelper.ConvertToQueryString(orderParameters);
var response = await client.GetAsync(url.ToString());
if (response.IsSuccessStatusCode)
{
var multicode = JsonConvert.DeserializeObject <List <RegistryResponse> >(await response.Content.ReadAsStringAsync());
return(new APIResponse(multicode, HttpStatusCode.OK));
}
return(new APIResponse(response.StatusCode));
}
catch (Exception ex)
{
logger.Error(ex, "Exception in method 'GetMultiDetails()'");
var exMessage = ex.InnerException != null ? ex.InnerException.Message : ex.Message;
return(new APIResponse(exMessage, HttpStatusCode.InternalServerError));
}
}
// Token: 0x06000B87 RID: 2951 RVA: 0x000331AA File Offset: 0x000313AA
private static void LoadRegistryValues()
{
if (RegistryTestHook.s_loadedRegistryValues)
{
return;
}
RegistryParameters.TryGetRegistryParameters("SOFTWARE\\Microsoft\\ExchangeServer\\v15\\Replay\\TestHook", delegate(IRegistryKey key)
{
RegistryTestHook.s_targetServerVersionOverride = (int)key.GetValue("TargetServerVersionOverride", RegistryTestHook.s_targetServerVersionOverride);
RegistryTestHook.s_incReseedDelayInSecs = (int)key.GetValue("IncReseedDelayInSecs", RegistryTestHook.s_incReseedDelayInSecs);
RegistryTestHook.s_safetyNetVersionCheckerOverride = (int)key.GetValue("SafetyNetVersionCheckerOverride", RegistryTestHook.s_safetyNetVersionCheckerOverride);
});
RegistryTestHook.s_loadedRegistryValues = true;
}
public void LoadClusterObjects(IAmCluster cluster)
{
IEnumerable <IAmClusterNode> enumerable = cluster.EnumerateNodes();
try
{
foreach (IAmClusterNode clusNode in enumerable)
{
ClusterNode item = new ClusterNode(clusNode);
this.m_clusterNodes.Add(item);
}
}
finally
{
foreach (IAmClusterNode amClusterNode in enumerable)
{
using (amClusterNode)
{
}
}
}
IEnumerable <AmClusterNetwork> enumerable2 = cluster.EnumerateNetworks();
try
{
foreach (AmClusterNetwork clusNet in enumerable2)
{
ClusterNetwork item2 = new ClusterNetwork(clusNet);
this.m_clusterNets.Add(item2);
}
}
finally
{
foreach (AmClusterNetwork amClusterNetwork in enumerable2)
{
using (amClusterNetwork)
{
}
}
}
int testWithFakeNetwork = RegistryParameters.GetTestWithFakeNetwork();
if (testWithFakeNetwork > 0)
{
this.AddFakeNetworkForTesting(testWithFakeNetwork);
}
this.LinkNicsToNodes();
}
private static void DelayApiIfRequired(string apiName)
{
if (RegistryParameters.IsApiLatencyTestEnabled)
{
int num = 0;
while (!AmSystemManager.Instance.IsShutdown)
{
int apiLatencyInSec = RegistryParameters.GetApiLatencyInSec(apiName);
if (num >= apiLatencyInSec)
{
break;
}
Thread.Sleep(1000);
num++;
}
}
}
public void ReloadRegistryParameters()
{
RegistryParameters.TestLoadRegistryParameters();
}
internal static int Measure(string apiName, string hintStr, TimeSpan maxAllowedLatency, TimeSpan maxAllowedLatencyForTimer, TimerCallback latencyCallback, Func <int> func, out TimeSpan elapsed)
{
ExDateTime now = ExDateTime.Now;
int num = 0;
bool flag = true;
Timer timer = null;
Timer timer2 = null;
try
{
if (latencyCallback != null && maxAllowedLatencyForTimer.TotalSeconds > 0.0)
{
LatencyChecker.LatencyContext latencyContext = new LatencyChecker.LatencyContext(now, apiName, hintStr, maxAllowedLatencyForTimer);
timer = new Timer(latencyCallback, latencyContext, -1, -1);
latencyContext.Timer = timer;
timer.Change(maxAllowedLatencyForTimer, TimeSpan.FromMilliseconds(-1.0));
timer2 = new Timer(new TimerCallback(LatencyChecker.ReportClusApiHangLongLatency), latencyContext, -1, -1);
TimeSpan dueTime = TimeSpan.FromSeconds((double)RegistryParameters.ClusApiHangReportLongLatencyDurationInSec);
timer2.Change(dueTime, TimeSpan.FromMilliseconds(-1.0));
}
if (RegistryParameters.IsApiLatencyTestEnabled)
{
LatencyChecker.DelayApiIfRequired(apiName);
num = RegistryParameters.GetApiSimulatedErrorCode(apiName);
if (num == 0)
{
num = func();
}
else
{
NativeMethods.SetLastError(num);
}
}
else
{
num = func();
}
flag = false;
}
finally
{
if (flag)
{
num = -1;
}
if (timer != null)
{
timer.Change(-1, -1);
timer.Dispose();
}
if (timer2 != null)
{
timer2.Change(-1, -1);
timer2.Dispose();
}
elapsed = ExDateTime.Now - now;
ExTraceGlobals.LatencyCheckerTracer.TraceDebug(0L, "Api={0}, StartTime={1}, Elapsed={2}, Hint={3}, IsUnhandled={4}, RetCode={5}, MaxLatency={6}", new object[]
{
apiName,
now,
elapsed,
hintStr,
flag,
num,
maxAllowedLatency
});
if (elapsed > maxAllowedLatency || (num != 0 && RegistryParameters.GetIsLogApiLatencyFailure()))
{
ReplayCrimsonEvents.OperationTookVeryLongTimeToComplete.Log <string, ExDateTime, TimeSpan, string, bool, int, TimeSpan>(apiName, now, elapsed, hintStr, flag, num, maxAllowedLatency);
}
}
return(num);
}
public async Task<IActionResult> GetRegistrys([FromQuery] RegistryParameters registryParameters)
{
var result = await registryService.GetRegistrys(registryParameters);
return StatusCode((int)result.Code, result.Value);
}
