// Token: 0x06000714 RID: 1812 RVA: 0x00015830 File Offset: 0x00013A30 internal void CompleteBuilding() { try { Monitor.Enter(this.lockObject); ExAssert.RetailAssert(this.state == SessionDataCacheState.Building || this.state == SessionDataCacheState.Obsolete, "Ready building session data in an invalid state: " + this.state); if (this.state == SessionDataCacheState.Obsolete) { this.InternalDispose(true); } else { this.lastSessionDataBuildEndTime = ExDateTime.Now; this.state = SessionDataCacheState.Ready; this.signalEvent.Set(); Timer staleTimer = null; staleTimer = new Timer(delegate(object param0) { this.Dispose(); DisposeGuard.DisposeIfPresent(staleTimer); }, null, SessionDataCache.FreshnessTime, Timeout.InfiniteTimeSpan); } } finally { if (Monitor.IsEntered(this.lockObject)) { Monitor.Exit(this.lockObject); } ExTraceGlobals.SessionDataHandlerTracer.TraceDebug((long)this.GetHashCode(), string.Format("[SessionDataCache] Ready building session data cache. StartTime = {0}, EndTime = {1}, state = {2}", this.lastSessionDataBuildStartTime.ToString(), this.lastSessionDataBuildEndTime.ToString(), this.state)); OwaSingleCounters.SessionDataCacheBuildsCompleted.Increment(); } }
// Token: 0x06001C0A RID: 7178 RVA: 0x0006DE44 File Offset: 0x0006C044 private static void AggregationContextRemoved(string key, object value, CacheItemRemovedReason reason) { if (reason == CacheItemRemovedReason.Expired) { ExTraceGlobals.CoreTracer.TraceWarning(0L, "an aggregation context expired before being revalidated!"); DisposeGuard.DisposeIfPresent(value as IDisposable); } }
// Token: 0x06000717 RID: 1815 RVA: 0x00015B98 File Offset: 0x00013D98 protected override void InternalDispose(bool disposing) { if (disposing) { lock (this.lockObject) { if (this.state != SessionDataCacheState.Building) { DisposeGuard.DisposeIfPresent(this.outputStream); } this.state = SessionDataCacheState.Obsolete; } } }
// Token: 0x06001C09 RID: 7177 RVA: 0x0006DD6C File Offset: 0x0006BF6C protected override ValidateAggregatedConfigurationResponse InternalExecute() { ValidateAggregatedConfigurationResponse report = new ValidateAggregatedConfigurationResponse(); bool flag = false; object obj = ValidateAggregatedConfiguration.RemoveFromValidationCache(base.MailboxIdentityMailboxSession); bool flag2 = obj is bool && (bool)obj; UserConfigurationManager.IAggregationContext aggregationContext = obj as UserConfigurationManager.IAggregationContext; try { if (flag2) { flag = true; ExTraceGlobals.SessionDataHandlerTracer.TraceDebug((long)this.GetHashCode(), "ValidateAggregatedConfiguration was invoked and the aggregator was recently validated."); } else if (aggregationContext != null) { aggregationContext.Validate(base.MailboxIdentityMailboxSession, delegate(IEnumerable <UserConfigurationDescriptor.MementoClass> faisRebuilt, IEnumerable <string> typesRebuilt) { foreach (UserConfigurationDescriptor.MementoClass mementoClass in faisRebuilt) { report.FaiUpdates.Add(mementoClass.ConfigurationName); OwaSingleCounters.AggregatedUserConfigurationPartsRebuilt.Increment(); ExTraceGlobals.SessionDataHandlerTracer.TraceError <string>((long)this.GetHashCode(), "error found in configuration type {0}", mementoClass.ConfigurationName); } foreach (string item in typesRebuilt) { report.TypeUpdates.Add(item); } }); flag = true; } if (flag) { ValidateAggregatedConfiguration.AddToValidationCache(base.MailboxIdentityMailboxSession, true); report.IsValidated = true; } } finally { DisposeGuard.DisposeIfPresent(aggregationContext); } return(report); }
private void ValidateAndDisposeAggregatedConfiguration(UserConfigurationManager.IAggregationContext aggregator, MailboxSession session) { bool flag = true; try { if (aggregator != null) { aggregator.Detach(); if (!base.CallContext.HasDeviceHeaders) { ValidateAggregatedConfiguration.AddToValidationCache(session, aggregator); flag = false; } else { flag = true; ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "user configuration being requested by an offline action."); object obj = ValidateAggregatedConfiguration.RemoveFromValidationCache(session); bool flag2 = obj is bool && (bool)obj; if (flag2) { ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "aggregated configuration was already validated during boot."); } else { DisposeGuard.DisposeIfPresent(obj as IDisposable); ExTraceGlobals.CoreTracer.TraceDebug((long)this.GetHashCode(), "aggregated configuration was not validated during boot. validating now."); aggregator.Validate(session, delegate(IEnumerable <UserConfigurationDescriptor.MementoClass> param0, IEnumerable <string> param1) { }); } ValidateAggregatedConfiguration.AddToValidationCache(session, true); } } } finally { if (flag) { DisposeGuard.DisposeIfPresent(aggregator); } } }
private void CommitUpdate(AggregatedUserConfiguration.PendingUpdate pending) { bool flag = true; if (this.memento.ConcurrentUpdates.Contains(pending.DescriptorMemento)) { flag = false; ExTraceGlobals.StorageTracer.TraceWarning <string>((long)this.GetHashCode(), "The configuration object with name[{0}] will not be committed because it is in the concurrent update list.", pending.Descriptor.ConfigurationName); } if (this.RemoveFromPendingAndConcurrent(pending) == 0) { flag = false; ExTraceGlobals.StorageTracer.TraceWarning <string>((long)this.GetHashCode(), "The configuration object with name[{0}] will not be committed because it was not found as a pending update.", pending.Descriptor.ConfigurationName); } if (flag) { IUserConfiguration userConfiguration = null; AggregatedUserConfigurationPart aggregatedUserConfigurationPart = null; try { if (this.TryInternalLoadConfiguration(() => pending.Descriptor.GetConfiguration(this.manager), null, delegate(IUserConfiguration c) { pending.Descriptor.Validate(c); }, out userConfiguration)) { aggregatedUserConfigurationPart = AggregatedUserConfigurationPart.FromConfiguration(userConfiguration); this.memento.Parts.Add(pending.DescriptorMemento, aggregatedUserConfigurationPart.Memento); this.memento.FailedToLoad.Remove(pending.DescriptorMemento); } } finally { DisposeGuard.DisposeIfPresent(userConfiguration); DisposeGuard.DisposeIfPresent(aggregatedUserConfigurationPart); } } this.SaveMemento(AggregatedUserConfiguration.SaveFailureMode.Fail); }
protected override void InternalDispose(bool disposing) { DisposeGuard.DisposeIfPresent(this.aggregatedConfiguration); base.InternalDispose(disposing); }