/// <summary> /// Bind the given resource for teh given key to the current thread /// </summary> /// <param name="key">key to bind the value to</param> /// <param name="value">value to bind</param> public static void BindResource(Object key, Object value) { AssertUtils.ArgumentNotNull(key, "Key value for thread local storage of transactional resources must not be null"); AssertUtils.ArgumentNotNull(value, "Transactional resource to bind to thread local storage must not be null"); IDictionary resources = LogicalThreadContext.GetData(resourcesDataSlotName) as IDictionary; //Set thread local resource storage if not found if (resources == null) { resources = new Hashtable(); LogicalThreadContext.SetData(resourcesDataSlotName, resources); } if (resources.Contains(key)) { throw new InvalidOperationException("Already value [" + resources[key] + "] for key [" + key + "] bound to thread [" + SystemUtils.ThreadId + "]"); } resources.Add(key, value); if (LOG.IsDebugEnabled) { LOG.Debug("Bound value [" + Describe(value) + "] for key [" + Describe(key) + "] to thread [" + SystemUtils.ThreadId + "]"); } }
/// <summary> /// Creates the message converter given its name in the application context. /// </summary> /// <param name="messageConverterObjectName">Name of the message converter object.</param> /// <returns> /// A IMessageConverter instance configured via the application context /// </returns> public IMessageConverter CreateMessageConverter(string messageConverterObjectName) { AssertUtils.ArgumentHasText(messageConverterObjectName, "MessgaeFormatterObjectName"); IDictionary converters = LogicalThreadContext.GetData(CONVERTER_DICTIONARY_SLOTNAME) as IDictionary; if (converters == null) { converters = new Hashtable(); LogicalThreadContext.SetData(CONVERTER_DICTIONARY_SLOTNAME, converters); } if (!converters.Contains(messageConverterObjectName)) { IMessageConverter mc = (IMessageConverter) applicationContext.GetObject(messageConverterObjectName, typeof(IMessageConverter)); if (applicationContext.ObjectFactory.GetObjectDefinition(messageConverterObjectName).IsSingleton) { log.Warn("MessageConverter with name = [" + messageConverterObjectName + "] should be declared with singleton=false. Using Clone() to create independent instance for thread local storage"); converters.Add(messageConverterObjectName, mc.Clone()); } else { converters.Add(messageConverterObjectName, mc); } } return(converters[messageConverterObjectName] as IMessageConverter); }
/// <summary> /// Binds this /// <see cref="Spring.Transaction.Interceptor.TransactionAspectSupport.TransactionInfo"/> /// instance to the thread local storage variable for the current thread and /// backs up the existing /// <see cref="Spring.Transaction.Interceptor.TransactionAspectSupport.TransactionInfo"/> /// object for the current thread. /// </summary> public void BindToThread() { // Expose current TransactionStatus, preserving any existing TransactionStatus // for restoration after this transaction is complete. TransactionInfo currentTransactionInfo = LogicalThreadContext.GetData(CURRENT_TRANSACTIONINFO_SLOTNAME) as TransactionInfo; _oldTransactionInfo = currentTransactionInfo; LogicalThreadContext.SetData(CURRENT_TRANSACTIONINFO_SLOTNAME, this); }
/// <summary> /// Sets a flag, whether this scope is in "open" state on the current logical thread. /// </summary> private void SetOpen(bool isOpen) { if (isOpen) { LogicalThreadContext.SetData(ISOPEN_KEY, ISOPEN_KEY); } else { LogicalThreadContext.FreeNamedDataSlot(ISOPEN_KEY); } }
/// <summary> /// Gets/Sets a flag, whether this scope manages it's own session for the current logical thread or not. /// </summary> /// <value><c>false</c> if session is managed by this module. <c>false</c> otherwise</value> private void SetParticipating(bool participating) { if (participating) { LogicalThreadContext.SetData(PARTICIPATE_KEY, PARTICIPATE_KEY); } else { LogicalThreadContext.FreeNamedDataSlot(PARTICIPATE_KEY); } }
/// <summary> /// 把当前UnitOfWork压入当前线程的事务线中 /// 如果当前线程中不存在事务栈,则创建事务栈,并把事务栈放入当前线程 /// 否则从当前线程中取出栈,并把当前UnitOfWork压入栈中 /// </summary> public static void Push(IUnitOfWork unitOfWork) { if (ThreadBoundUnitOfWorkStack == null) { var stack = new Stack <IUnitOfWork>(); stack.Push(unitOfWork); LogicalThreadContext.SetData(UnitOfWorkStack, stack); } else { ThreadBoundUnitOfWorkStack.Push(unitOfWork); } }
/// <summary> /// Process the xml file in the given location, and schedule all of the /// jobs defined within it. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="systemId">The system id.</param> /// <param name="sched">The sched.</param> public virtual async Task ProcessFileAndScheduleJobs(string fileName, string systemId, IScheduler sched) { LogicalThreadContext.SetData(ThreadLocalKeyScheduler, sched); try { await ProcessFile(fileName, systemId).ConfigureAwait(false); await ExecutePreProcessCommands(sched).ConfigureAwait(false); await ScheduleJobs(sched).ConfigureAwait(false); } finally { LogicalThreadContext.FreeNamedDataSlot(ThreadLocalKeyScheduler); } }
/// <summary> /// Process the xml file in the given location, and schedule all of the /// jobs defined within it. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="systemId">The system id.</param> /// <param name="sched">The sched.</param> public virtual void ProcessFileAndScheduleJobs(string fileName, string systemId, IScheduler sched) { LogicalThreadContext.SetData(ThreadLocalKeyScheduler, sched); try { ProcessFile(fileName, systemId); ExecutePreProcessCommands(sched); ScheduleJobs(sched); } finally { LogicalThreadContext.FreeNamedDataSlot(ThreadLocalKeyScheduler); } }
/// <summary> /// Activate transaction synchronization for the current thread. /// </summary> /// <remarks> /// Called by transaction manager at the beginning of a transaction. /// </remarks> /// <exception cref="System.InvalidOperationException"> /// If synchronization is already active. /// </exception> public static void InitSynchronization() { if (SynchronizationActive) { throw new InvalidOperationException("Cannot activate transaction synchronization - already active"); } if (LOG.IsDebugEnabled) { LOG.Debug("Initializing transaction synchronization"); } ArrayList syncs = new ArrayList(); LogicalThreadContext.SetData(syncsDataSlotName, syncs); }
/// <summary> /// Process the xml file in the given location, and schedule all of the /// jobs defined within it. /// </summary> /// <param name="fileName">Name of the file.</param> /// <param name="systemId">The system id.</param> /// <param name="sched">The sched.</param> /// <param name="overwriteExistingJobs">if set to <c>true</c> [over write existing jobs].</param> public virtual void ProcessFileAndScheduleJobs(string fileName, string systemId, IScheduler sched, bool overwriteExistingJobs) { LogicalThreadContext.SetData(ThreadLocalKeyScheduler, sched); try { ProcessFile(fileName, systemId); ScheduleJobs(ScheduledJobs, sched, overwriteExistingJobs); } finally { LogicalThreadContext.FreeNamedDataSlot(ThreadLocalKeyScheduler); } }
/// <summary> ///Initialize deferred close for the current thread and the given SessionFactory. /// Sessions will not be actually closed on close calls then, but rather at a /// processDeferredClose call at a finishing point (like request completion). /// </summary> /// <param name="sessionFactory">The session factory.</param> public static void InitDeferredClose(ISessionFactory sessionFactory) { AssertUtils.ArgumentNotNull(sessionFactory, "No SessionFactory specified"); log.Debug("Initializing deferred close of Hibernate Sessions"); IDictionary holderDictionary = LogicalThreadContext.GetData(DeferredCloseHolderDataSlotName) as IDictionary; if (holderDictionary == null) { holderDictionary = new Hashtable(); LogicalThreadContext.SetData(DeferredCloseHolderDataSlotName, holderDictionary); } holderDictionary.Add(sessionFactory, new ListSet()); }
/// <summary> /// Process the xml file in the given location, and schedule all of the /// jobs defined within it. /// </summary> /// <param name="stream">stream to read XML data from.</param> /// <param name="sched">The sched.</param> public virtual void ProcessStreamAndScheduleJobs(Stream stream, IScheduler sched) { LogicalThreadContext.SetData(ThreadLocalKeyScheduler, sched); try { using (var sr = new StreamReader(stream)) { ProcessInternal(sr.ReadToEnd()); } ExecutePreProcessCommands(sched); ScheduleJobs(sched); } finally { LogicalThreadContext.FreeNamedDataSlot(ThreadLocalKeyScheduler); } }
/// <summary> /// Process the xml file in the given location, and schedule all of the /// jobs defined within it. /// </summary> /// <param name="stream">stream to read XML data from.</param> /// <param name="sched">The sched.</param> public virtual async Task ProcessStreamAndScheduleJobs(Stream stream, IScheduler sched) { LogicalThreadContext.SetData(ThreadLocalKeyScheduler, sched); try { using (var sr = new StreamReader(stream)) { ProcessInternal(await sr.ReadToEndAsync().ConfigureAwait(false)); } await ExecutePreProcessCommands(sched).ConfigureAwait(false); await ScheduleJobs(sched).ConfigureAwait(false); } finally { LogicalThreadContext.FreeNamedDataSlot(ThreadLocalKeyScheduler); } }
/// <summary> /// Creates the message queue given its name in the application context. /// </summary> /// <param name="messageQueueObjectName">Name of the message queue object.</param> /// <returns> /// A MessageQueue instance configured via the application context /// </returns> public MessageQueue CreateMessageQueue(string messageQueueObjectName) { AssertUtils.ArgumentHasText(messageQueueObjectName, "DefaultMessageQueueObjectName"); IDictionary queues = LogicalThreadContext.GetData(QUEUE_DICTIONARY_SLOTNAME) as IDictionary; if (queues == null) { queues = new Hashtable(); LogicalThreadContext.SetData(QUEUE_DICTIONARY_SLOTNAME, queues); } if (!queues.Contains(messageQueueObjectName)) { MessageQueue mq = applicationContext.GetObject(messageQueueObjectName) as MessageQueue; queues.Add(messageQueueObjectName, mq); } return(queues[messageQueueObjectName] as MessageQueue); }
/// <summary> /// Bind the given resource for teh given key to the current thread /// </summary> /// <param name="key">key to bind the value to</param> /// <param name="value">value to bind</param> public static void BindResource(Object key, Object value) { var resources = LogicalThreadContext.GetData(RESOURCES_DATA_SLOT_NAME) as IDictionary; //Set thread local resource storage if not found if (resources == null) { resources = new Hashtable(); LogicalThreadContext.SetData(RESOURCES_DATA_SLOT_NAME, resources); } if (resources.Contains(key)) { throw new InvalidOperationException("Already value [" + resources[key] + "] for key [" + key + "] bound to thread [" + Thread.CurrentThread.ManagedThreadId + "]"); } resources.Add(key, value); if (log.IsDebugEnabled) { log.Debug("Bound value [" + Describe(value) + "] for key [" + Describe(key) + "] to thread [" + Thread.CurrentThread.ManagedThreadId + "]"); } }
/// <summary> /// Sets the user credentials for current thread. The given username and password /// strings will be added to the connection string for all subsequent GetConnection /// requests. This will override any statically specified user credentials, that is, /// set by the properties Username nad Password. /// </summary> /// <param name="user">The username part of the connection string.</param> /// <param name="pass">The password part of the connection string.</param> public void SetCredentialsForCurrentThread(string user, string pass) { LogicalThreadContext.SetData(USERNAME, user); LogicalThreadContext.SetData(PASSWORD, pass); }
/// <summary> /// 设置当前线程运行环境的WarehouseId /// </summary> /// <param name="warehouseId">a WarehouseId</param> public static void SetCurrentThreadWarehouseId(string warehouseId) { AssertUtils.StringNotNullOrEmpty(warehouseId, "warehouseId"); LogicalThreadContext.SetData(CURRENT_WAREHOUSE_ID, warehouseId); }
public void Before(MethodInfo method, object[] args, object target) { LogicalThreadContext.SetData(ORDERING_SLOT, new object()); }
///<summary> /// TODO ///</summary> ///<param name="applicationContext"></param> ///<param name="name"></param> ///<param name="isContainerManaged"></param> private static void SetCurrentHandlerConfiguration(IConfigurableApplicationContext applicationContext, string name, bool isContainerManaged) { LogicalThreadContext.SetData(CURRENTHANDLER_OBJECTDEFINITION, new HandlerConfigurationMetaData(applicationContext, name, isContainerManaged)); }
/// <summary> /// Restores the previous /// <see cref="Spring.Transaction.Interceptor.TransactionAspectSupport.TransactionInfo"/> /// object to the current thread. /// </summary> public void RestoreThreadLocalStatus() { // Use stack to restore old transaction TransactionInfo. // Will be null if none was set. LogicalThreadContext.SetData(CURRENT_TRANSACTIONINFO_SLOTNAME, _oldTransactionInfo); }