/// <summary>
/// Create a WMQ connection factory and set relevant properties.
/// </summary>
/// <returns>A connection factory</returns>
public static IConnectionFactory CreateConnectionFactory(XmsAddress destination)
{
// Create the connection factories factory
XMSFactoryFactory factoryFactory = XMSFactoryFactory.GetInstance(XMSC.CT_WMQ);
// Use the connection factories factory to create a connection factory
IConnectionFactory cf = factoryFactory.CreateConnectionFactory();
// Set the properties
cf.SetStringProperty(XMSC.WMQ_HOST_NAME, destination.Host.HostName);
cf.SetIntProperty(XMSC.WMQ_PORT, destination.Host.Port);
cf.SetStringProperty(XMSC.WMQ_CHANNEL, destination.Host.Channel);
cf.SetIntProperty(XMSC.WMQ_CONNECTION_MODE, XMSC.WMQ_CM_CLIENT);
// since null is not permited for queue manager, pass that as empty string
// so that, while connecting to queue manager, it finds the default queue manager.
cf.SetStringProperty(XMSC.WMQ_QUEUE_MANAGER, destination.Host.Manager);
//cf.SetIntProperty(XMSC.WMQ_BROKER_VERSION, Options.BrokerVersion.ValueAsNumber);
// Integrator
//if (Options.BrokerVersion.ValueAsNumber == XMSC.WMQ_BROKER_V2)
// cf.SetStringProperty(XMSC.WMQ_BROKER_PUBQ, Options.BrokerPublishQueue.Value);
return (cf);
}
public void Init(Address address, bool transactional)
{
this.address = address.ToXmsAddress();
if (PurgeOnStartup)
XmsUtilities.Purge(this.address);
this.useTransactions = transactional;
this.consumerProducer = new XmsConsumerProvider(transactional);
}
public static int GetCurrentQueueDebth(XmsAddress address)
{
var manager = new MQQueueManager(address.Host.Manager, address.Host.Channel, address.Host.ConnectionName);
var queue = manager.AccessQueue(address.Queue, MQC.MQOO_INQUIRE);
int depth = queue.CurrentDepth;
manager.Disconnect();
manager.Close();
return depth;
}
private Pool<XmsPooledConsumer> CreatePool(XmsAddress address)
{
log.Info("Going to create new consumer pool for address {0}".FormatWith(address));
//TODO: make this configurable
var store = new StackStore<XmsPooledConsumer>(60.Seconds(), 30.Seconds());
var pool = new Pool<XmsPooledConsumer>(10, p =>
{
log.Info("Going to create new plain consumer for address {0}".FormatWith(address));
var consumer = new XmsConsumer(address, transactional);
var pooled = new XmsPooledConsumer(p, consumer);
return pooled;
}, store);
return pool;
}
public static int Purge(XmsAddress destination)
{
int i = 0;
var factory = CreateConnectionFactory(destination);
using (var connection = factory.CreateConnection())
{
using (ISession session = connection.CreateSession(false, AcknowledgeMode.AutoAcknowledge))
{
IDestination queue = session.CreateQueue(destination.Queue);
queue.SetIntProperty(XMSC.DELIVERY_MODE, XMSC.DELIVERY_NOT_PERSISTENT);
using (var consumer = session.CreateConsumer(queue))
{
connection.Start();
while (consumer.ReceiveNoWait() != null)
{
++i;
}
}
}
}
return i;
}
public IXmsConsumer GetConsumer(XmsAddress address)
{
Pool<XmsPooledConsumer> pool;
if (!poolsByDestination.TryGetValue(address, out pool))
{
lock (locker)
{
pool = poolsByDestination.GetOrAdd(address, CreatePool);
}
}
if (IsInTransaction && transactional)
{
log.Debug("Detected transaction scope on transactional consumer provider. Using transaction scope allocation.");
var transaction = Transaction.Current;
var key = "{0}|{1}".FormatWith(transaction.TransactionInformation.LocalIdentifier, address);
if (!threadAllocatedConsumers.ContainsKey(key))
{
log.Debug("Allocating consumer to a transaction scope {0}".FormatWith(key));
var pooled = pool.Acquire();
threadAllocatedConsumers[key] = pooled;
XmsPooledConsumer _;
transaction.TransactionCompleted += (s, e) =>
{
log.Debug("Dealocating consumer from transaction scope {0}.".FormatWith(key));
threadAllocatedConsumers.TryRemove(key, out _);
pooled.Dispose();
};
}
return threadAllocatedConsumers[key];
}
log.Debug("Acquiring consumer without the transaction scope.");
return pool.Acquire();
}
public XmsProducer(XmsAddress address, bool transactional)
{
this.address = address;
this.transactional = transactional;
}
protected bool Equals(XmsAddress other)
{
return string.Equals(Queue, other.Queue) && Equals(Host, other.Host);
}
public XmsConsumer(XmsAddress address, bool transactional)
{
this.address = address;
this.transactional = transactional;
}