public RhinoQueuesTransport(Uri endpoint, IEndpointRouter endpointRouter, IMessageSerializer messageSerializer, int threadCount, string path, IsolationLevel queueIsolationLevel, int numberOfRetries, bool enablePerformanceCounters, IMessageBuilder <MessagePayload> messageBuilder, QueueManagerConfiguration queueManagerConfiguration, ITransactionStrategy transactionStrategy) { this.endpoint = endpoint; this.queueIsolationLevel = queueIsolationLevel; this.numberOfRetries = numberOfRetries; this.enablePerformanceCounters = enablePerformanceCounters; this.messageBuilder = messageBuilder; this.queueManagerConfiguration = queueManagerConfiguration; this.transactionStrategy = transactionStrategy; this.endpointRouter = endpointRouter; this.messageSerializer = messageSerializer; this.threadCount = threadCount; this.path = path; queueName = endpoint.GetQueueName(); threads = new Thread[threadCount]; // This has to be the first subscriber to the transport events // in order to successfully handle the errors semantics new ErrorAction(numberOfRetries).Init(this); messageBuilder.Initialize(this.Endpoint); }
public void UpgradeStarting(IUpgradeLog upgradeLog) { if (transactionStrategy != null) { throw new InvalidOperationException("UpgradeStarting is meant to be called by DbUp and can only be called once"); } transactionStrategy = transactionStrategyFactory[TransactionMode](); transactionStrategy.Initialise(upgradeLog); }
public MsmqReadyForWorkListener(IQueueStrategy queueStrategy, Uri endpoint, int threadCount, IMessageSerializer messageSerializer, IEndpointRouter endpointRouter, TransactionalOptions transactional, IMessageBuilder <Message> messageBuilder, ITransactionStrategy transactionStrategy) : base(queueStrategy, endpoint, threadCount, messageSerializer, endpointRouter, transactional, messageBuilder, transactionStrategy) { }
public Builder WithAmount(double amount) { _amount = amount; if (_amount >= 10000.00) { _transactionStrategy = new ProAccountStrategy(); } return(this); }
/// <summary> /// Construct a new manager with a given strategy /// </summary> /// <param name="strategy"></param> private TransactionManager(ITransactionStrategy strategy) { if (strategy == null) { throw new ArgumentNullException( "strategy", "Strategy must not be null, to use a default call the overload with no arguments"); } Strategy = strategy; TransactionWrapper = new TransactionWrapper(); DoAssertInIdleThread = true; }
public MsmqLoadBalancer( IMessageSerializer serializer, IQueueStrategy queueStrategy, IEndpointRouter endpointRouter, Uri endpoint, int threadCount, Uri secondaryLoadBalancer, TransactionalOptions transactional, IMessageBuilder <Message> messageBuilder, ITransactionStrategy transactionStrategy) : this(serializer, queueStrategy, endpointRouter, endpoint, threadCount, transactional, messageBuilder, transactionStrategy) { this.secondaryLoadBalancer = secondaryLoadBalancer; }
public UnitOfWork( IConnectionStringResolver connectionStringResolver, IDbContextResolver dbContextResolver, IDependencyResolver dependencyResolver, ITransactionStrategy transactionStrategy, IUserContext userContext) { Id = Guid.NewGuid().ToString("N"); _dependencyResolver = dependencyResolver; _transactionStrategy = transactionStrategy; _connectionStringResolver = connectionStringResolver; _dbContextResolver = dbContextResolver; _activeDbContexts = new Dictionary <string, DbContext>(); _userContext = userContext; }
public MsmqLoadBalancer( IMessageSerializer serializer, IQueueStrategy queueStrategy, IEndpointRouter endpointRouter, Uri endpoint, int threadCount, TransactionalOptions transactional, IMessageBuilder <Message> messageBuilder, ITransactionStrategy transactionStrategy) : base(queueStrategy, endpoint, threadCount, serializer, endpointRouter, transactional, messageBuilder, transactionStrategy) { heartBeatTimer = new Timer(SendHeartBeatToSecondaryServer); this.queueStrategy = queueStrategy; _transactionStrategy = transactionStrategy; }
public MsmqSecondaryLoadBalancer( IMessageSerializer serializer, IQueueStrategy queueStrategy, IEndpointRouter endpointRouter, Uri endpoint, Uri primaryLoadBalancer, int threadCount, TransactionalOptions transactional, IMessageBuilder <Message> messageBuilder, ITransactionStrategy transactionStrategy) : base(serializer, queueStrategy, endpointRouter, endpoint, threadCount, transactional, messageBuilder, transactionStrategy) { TimeoutForHeartBeatFromPrimary = TimeSpan.FromSeconds(10); this.primaryLoadBalancer = primaryLoadBalancer; tookOverWork = false; }
public void SetTransactionMode() { TestFunction2 function = new TestFunction2(); ITransactionStrategy actualTransaction = null; function.Add(new WxeDelegateStep(() => actualTransaction = function.Transaction)); function.SetTransactionMode(WxeTransactionMode <TestTransactionFactory> .CreateRoot); WxeContextFactory contextFactory = new WxeContextFactory(); var context = contextFactory.CreateContext(function); Assert.That(function.Transaction, Is.InstanceOf <NullTransactionStrategy>()); function.Execute(context); Assert.That(actualTransaction, Is.InstanceOf <RootTransactionStrategy>()); }
public MsmqTransport(IMessageSerializer serializer, IQueueStrategy queueStrategy, Uri endpoint, int threadCount, IMsmqTransportAction[] transportActions, IEndpointRouter endpointRouter, IsolationLevel queueIsolationLevel, TransactionalOptions transactional, bool consumeInTransaction, IMessageBuilder <Message> messageBuilder, ITransactionStrategy transactionStrategy) : base(queueStrategy, endpoint, threadCount, serializer, endpointRouter, transactional, messageBuilder, transactionStrategy) { this.transportActions = transportActions; this.queueIsolationLevel = queueIsolationLevel; this.consumeInTransaction = consumeInTransaction; _transactionStrategy = transactionStrategy; }
private void SetTransactionStrategy(ExecuteCommand executeCommand) { if (executeCommand != null) { switch (executeCommand.Type) { case ExecuteCommand.CommandType.Delete: transactionStrategy = new DeleteTransactionStrategy(); break; case ExecuteCommand.CommandType.Insert: transactionStrategy = new InsertTransactionStrategy(); break; case ExecuteCommand.CommandType.Update: transactionStrategy = new UpdateTransactionStrategy(); break; } } }
/// <summary> /// Tells the connection manager is starting /// </summary> public IDisposable OperationStarting(IUpgradeLog upgradeLog, List <SqlScript> executedScripts, TransactionMode transactionMode) { upgradeConnection = CreateConnection(upgradeLog); if (upgradeConnection.State == ConnectionState.Closed) { upgradeConnection.Open(); } transactionStrategy = transactionStrategyFactory[transactionMode](); transactionStrategy.Initialise(upgradeConnection, upgradeLog); return(new DelegateDisposable(() => { transactionStrategy.Dispose(); upgradeConnection.Dispose(); transactionStrategy = null; upgradeConnection = null; })); }
/// <summary> /// Tells the connection manager is starting /// </summary> public IDisposable OperationStarting(IUpgradeLog upgradeLog, List <SqlScript> executedScripts) { upgradeConnection = CreateConnection(upgradeLog); if (upgradeConnection.State == ConnectionState.Closed) { upgradeConnection.Open(); } if (transactionStrategy != null) { throw new InvalidOperationException("OperationStarting is meant to be called by DbUp and can only be called once"); } transactionStrategy = transactionStrategyFactory[TransactionMode](); transactionStrategy.Initialise(upgradeConnection, upgradeLog, executedScripts); return(new DelegateDisposable(() => { transactionStrategy.Dispose(); upgradeConnection.Dispose(); transactionStrategy = null; upgradeConnection = null; })); }
protected AbstractMsmqListener( IQueueStrategy queueStrategy, Uri endpoint, int threadCount, IMessageSerializer messageSerializer, IEndpointRouter endpointRouter, TransactionalOptions transactional, IMessageBuilder <Message> messageBuilder, ITransactionStrategy transactionStrategy) { this.queueStrategy = queueStrategy; this.messageSerializer = messageSerializer; this.endpointRouter = endpointRouter; this.endpoint = endpoint; this.threadCount = threadCount; threads = new Thread[threadCount]; switch (transactional) { case TransactionalOptions.Transactional: this.transactional = true; break; case TransactionalOptions.NonTransactional: this.transactional = false; break; case TransactionalOptions.FigureItOut: this.transactional = null; break; default: throw new ArgumentOutOfRangeException("transactional"); } this.messageBuilder = messageBuilder; _transactionStrategy = transactionStrategy; this.messageBuilder.Initialize(Endpoint); }
public void SetUp() { _transaction = new DefaultTransactionStrategy(); _daoFactory = new HibernateDaoFactory(); }
public static void Reset(this ITransactionStrategy transactionStrategy) { throw new NotImplementedException(); }
public RhinoQueuesOneWayBus(MessageOwner[] messageOwners, IMessageSerializer messageSerializer, string path, bool enablePerformanceCounters, IMessageBuilder <MessagePayload> messageBuilder, QueueManagerConfiguration queueManagerConfiguration, ITransactionStrategy transactionStrategy) : base(NullEndpoint, new EndpointRouter(), messageSerializer, 1, path, IsolationLevel.ReadCommitted, 5, enablePerformanceCounters, messageBuilder, queueManagerConfiguration, transactionStrategy) { this.messageOwners = new MessageOwnersSelector(messageOwners, new EndpointRouter()); Start(); }
/// <summary> /// Setup a manager with a specified strategy /// </summary> public static void SetupManager(ITransactionStrategy strategy) { Log("Setting up Transaction Manager with Strategy: " + strategy.GetType()); manager = new TransactionManager(strategy); }
public TimeoutAction(IQueueStrategy queueStrategy, ITransactionStrategy transactionStrategy) { this.queueStrategy = queueStrategy; this.transactionStrategy = transactionStrategy; }