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;
}
/// <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;
}
/// <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 void SetUp()
{
_transaction = new DefaultTransactionStrategy();
_daoFactory = new HibernateDaoFactory();
}
