Example #1
0
 public void Dispose()
 {
     lock (disposeLock)
     {
         if (timer != null)
         {
             timer.Stop();
             timer.Dispose();
             timer = null;
         }
         storage  = null;
         callback = null;
     }
 }
	public ConfigurableCallbackTimer(BerkeleyDbStorage storage, ITimerConfig timerConfig, string name,
			int defaultInterval, ConfigurableCallbackTimerDelegate callback)
		{
			if (timerConfig != null && timerConfig.Enabled)
			{
				this.name = name;
				this.storage = storage;
				this.callback = callback;
				timer = new Timer();
				int interval = timerConfig.Interval;
				if (interval <= 0) interval = defaultInterval;
				timer.Interval = interval;
				timer.Elapsed += timer_Elapsed;
				timer.Enabled = true;
				if (BerkeleyDbStorage.Log.IsInfoEnabled)
				{
					BerkeleyDbStorage.Log.InfoFormat("Initialize() {0} Interval = {1} milliseconds", name, interval);
				}
			}
		}
Example #3
0
 public ConfigurableCallbackTimer(BerkeleyDbStorage storage, ITimerConfig timerConfig, string name,
                                  int defaultInterval, ConfigurableCallbackTimerDelegate callback)
 {
     if (timerConfig != null && timerConfig.Enabled)
     {
         this.name     = name;
         this.storage  = storage;
         this.callback = callback;
         timer         = new Timer();
         int interval = timerConfig.Interval;
         if (interval <= 0)
         {
             interval = defaultInterval;
         }
         timer.Interval = interval;
         timer.Elapsed += timer_Elapsed;
         timer.Enabled  = true;
         if (BerkeleyDbStorage.Log.IsInfoEnabled)
         {
             BerkeleyDbStorage.Log.InfoFormat("Initialize() {0} Interval = {1} milliseconds", name, interval);
         }
     }
 }
		public void Dispose()
		{
			lock (disposeLock)
			{
				if (timer != null)
				{
					timer.Stop();
					timer.Dispose();
					timer = null;
				}
				storage = null;
				callback = null;
			}
		}
 internal BackupSet(BerkeleyDbStorage storage, string backupDir, Backup backupConfig)
     :
     this(storage.Environment.GetHomeDirectory(), backupDir, backupConfig)
 {
     this.storage = storage;
 }
Example #6
0
        void timer_Elapsed(object sender, ElapsedEventArgs e)
        {
            BerkeleyDbStorage errorStorage = null;
            BdbException      bdbExc       = null;
            Exception         regExc       = null;
            var errorHandleIteration       = -1;

            lock (disposeLock)
            {
                if (timer == null)
                {
                    return;                                // for race condition where Elapsed event fires even after Dispose called
                }
                timer.Stop();
                if (storage == null)
                {
                    return;
                }
                if (storage.IsShuttingDown)
                {
                    return;
                }
                if (storage.IsInRecovery)
                {
                    return;
                }
                try
                {
                    storage.BlockOnRecovery();
                    callback();
                }
                catch (BdbException exc)
                {
                    errorStorage         = storage;
                    errorHandleIteration = errorStorage.HandleIteration;
                    bdbExc = exc;
                }
                catch (Exception exc)
                {
                    errorStorage         = storage;
                    errorHandleIteration = errorStorage.HandleIteration;
                    regExc = exc;
                }
            }
            // needed to store storage in case Dispose called after lock, but need to do error handling outside of lock
            // because error handler might wind up calling Dispose, which also uses lock
            if (errorStorage != null && errorHandleIteration == errorStorage.HandleIteration)
            {
                if (bdbExc != null)
                {
                    errorStorage.HandleBdbError(bdbExc);
                }
                else
                {
                    errorStorage.HandleGeneralError(regExc);
                }
            }
            if (timer != null)
            {
                timer.Start();
            }
        }
		public void Initialize(BerkeleyDbConfig config, string InstanceName, ComponentRunState runState)
		{
			try
			{
			   
				instanceName = InstanceName;
				#region Perf Counter init
				BerkeleyDbCounters.Instance.Initialize(InstanceName);
				storage = new BerkeleyDbStorage
						  {
							  TrickledPagesCounter =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.PagesTrickled),
							  DeletedObjectsCounter =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.DeletedObjects),
							  StoredObjectsCounter =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.ObjectsStored),
							  PooledBufferSizeCounter =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 PooledBufferSize),
							  AllocatedBuffersCounter =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 AllocatedBuffers),
							  BuffersInUseCounter =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.BuffersInUse),
							  LockStatCurrentMaxLockerId =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatCurrentMaxLockerId),
							  LockStatLastLockerId =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLastLockerId),
							  LockStatLockersNoWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLockersNoWait),
							  LockStatLockersWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLockersWait),
							  LockStatLockNoWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLockNoWait),
							  LockStatLocksWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLocksWait),
							  LockStatLockTimeout =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLockTimeout),
							  LockStatLockWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLockWait),
							  LockStatMaxLockersPossible =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatMaxLockersPossible),
							  LockStatMaxLockObjectsPossible =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatMaxLockObjectsPossible),
							  LockStatMaxLocksPossible =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatMaxLocksPossible),
							  LockStatMaxNumberLockersAtOneTime =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatMaxNumberLockersAtOneTime),
							  LockStatMaxNumberLocksAtOneTime =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatMaxNumberLocksAtOneTime),
							  LockStatNumberCurrentLockers =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberCurrentLockers),
							  LockStatNumberCurrentLockObjects =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberCurrentLockObjects),
							  LockStatNumberCurrentLockObjectsAtOneTime =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberCurrentLockObjectsAtOneTime),
							  LockStatNumberCurrentLocks =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberCurrentLocks),
							  LockStatNumberDeadLocks =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberDeadLocks),
							  LockStatNumberLockModes =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberLockModes),
							  LockStatNumberLocksDownGraded =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberLocksDownGraded),
							  LockStatNumberLocksReleased =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberLocksReleased),
							  LockStatNumberLocksRequested =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberLocksRequested),
							  LockStatNumberLocksUpgraded =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberLocksUpgraded),
							  LockStatNumberLockTimeouts =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberLockTimeouts),
							  LockStatNumberTxnTimeouts =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatNumberTxnTimeouts),
							  LockStatObjectsNoWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatObjectsNoWait),
							  LockStatObjectsWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatObjectsWait),
							  LockStatTxnTimeout =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatTxnTimeout),
							  LockStatLockHashLen =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLockHashLen),
							  LockStatLockRegionSize =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLockRegionSize),
							  LockStatLocksNoWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatLocksNoWait),
							  LockStatRegionNoWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatRegionNoWait),
							  LockStatRegionWait =
								  BerkeleyDbCounters.Instance.GetCounter(GetInstanceName(),
																		 BerkeleyDbCounters.PerformanceCounterIndexes.
																			 LockStatRegionWait)
						  };


				
					if (storage.LockStatRegionWait == null)
					{
						Log.WarnFormat("Lock Statistics not initialized properly from BerkeleyDbComponent.");
					}
					else
					{
						Log.DebugFormat("Lock Statistics initialized properly from BerkeleyDbComponent.");
					}
				
				#endregion
				bdbConfig = config;
				storage.Initialize(InstanceName, bdbConfig);

				if (relayNodeConfig != null)
				{
					// tell database objects if they are to check for race conditions - Dale Earnhardt Jr. # 8 yes!
					DatabaseConfig dbConfig;
					foreach (TypeSetting typeSetting in relayNodeConfig.TypeSettings.TypeSettingCollection)
					{
						try
						{
							dbConfig = bdbConfig.EnvironmentConfig.DatabaseConfigs.GetConfigFor(typeSetting.TypeId);
						}
						catch (Exception e)
						{
							Log.ErrorFormat("Exception getting database config for type {0}: {1}", typeSetting.TypeId, e);
							throw;
						}
						if (dbConfig.Id == 0)
						{
							DatabaseConfig newDbConfig = dbConfig.Clone(typeSetting.TypeId);
							bdbConfig.EnvironmentConfig.DatabaseConfigs.Add(newDbConfig);
						}						
						RaceConditionLookup[typeSetting.TypeId] = typeSetting.CheckRaceCondition;
					}
				}

				ThrottleThreads throttleThreads = bdbConfig.ThrottleThreads;
				bool throttleThreadsEnabled = throttleThreads != null && throttleThreads.Enabled;
				if (Log.IsDebugEnabled)
				{
					Log.DebugFormat("Initialize() BerkeleyDbConfig: ThrottleThreads = {0}", throttleThreadsEnabled);
				}
				if (throttleThreadsEnabled)
				{
					threadCount = bdbConfig.ThrottleThreads.ThreadCount;
					if (Log.IsInfoEnabled)
					{
						Log.InfoFormat("Initialize() BerkeleyDbConfig: ThreadCount = {0}", threadCount);
					}
					//int federationSize = 10;
					int dbCount = bdbConfig.GetDatabaseCount();
					if (Log.IsInfoEnabled)
					{
						Log.InfoFormat("Initialize() Calculated number of databases = {0}", dbCount);
					}
					if (dbCount < threadCount)
					{
						threadCount = dbCount;
						if (Log.IsInfoEnabled)
						{
							Log.InfoFormat("Initialize() Thread count reduced to {0}", threadCount);
						}
					}
					const string threadPoolName = "BerkeleyDb Thread Pool";
					const string dispatcherQueueName = "Single Thread Queue";
					queues = new ThrottledQueue[threadCount];
					PostMessageDelegate postMessageDelegate = PostMessage;
					for (int i = 0; i < threadCount; i++)
					{
						queues[i] = new ThrottledQueue(threadPoolName, dispatcherQueueName + i,
							postMessageDelegate, bdbConfig.MaxPoolItemReuse);
					}
					queueCounterTimer = new Timer(CountThrottledQueues, null, 5000, 5000);
				}
			}
			catch (Exception exc)
			{
				if (Log.IsErrorEnabled)
				{
					Log.Error("Error initializing.", exc);
				}
				throw;
			}
		}
Example #8
0
		internal BackupSet(BerkeleyDbStorage storage, string backupDir, Backup backupConfig)
			:
			this(storage.Environment.GetHomeDirectory(), backupDir, backupConfig)
		{
			this.storage = storage;
		}