/// <summary> /// Create a WMQ connection factory and set relevant properties. /// </summary> /// <returns>A connection factory</returns> public static IConnectionFactory CreateConnectionFactory(XmsDestination 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.HostName); cf.SetIntProperty(XMSC.WMQ_PORT, destination.Port); cf.SetStringProperty(XMSC.WMQ_CHANNEL, destination.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.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 bool Equals(XmsDestination other) { if (ReferenceEquals(null, other)) return false; if (ReferenceEquals(this, other)) return true; return Equals(other.Queue, Queue) && Equals(other.HostName, HostName) && other.Port == Port && Equals(other.Channel, Channel) && Equals(other.Manager, Manager); }
private XmsPooledProducer PlainProducerFactory(Pool<XmsPooledProducer> pool, XmsDestination destination) { log.Info("Going to create new plain producer for destination {0}".FormatWith(destination)); var producer = new XmsProducer(destination, transactional); var pooled = new XmsPooledProducer(pool, producer); return pooled; }
public XmsProducer(XmsDestination destination, bool transactional) { this.destination = destination; this.transactional = transactional; log.Debug("New physical producer created. About to connect."); Connect(); log.Debug("New physical producer successfully connected."); }
private Pool<XmsPooledProducer> PoolFactory(XmsDestination destination) { log.Info("Going to create new producer pool for destination {0}".FormatWith(destination)); //TODO: make this configurable var store = new StackStore<XmsPooledProducer>(60.Seconds(), 30.Seconds()); var pool = new Pool<XmsPooledProducer>(10, p => PlainProducerFactory(p, destination), store); return pool; }
public IXmsProducer GetProducer(XmsDestination destination) { Pool<XmsPooledProducer> pool; if (!poolsByDestination.TryGetValue(destination, out pool)) { lock (locker) { pool = poolsByDestination.GetOrAdd(destination, PoolFactory); } } if (IsInTransaction && transactional) { log.Debug("Detected transaction scope on transactional provider. Using per scope producer."); // here we need to keep track of current instances within the current transaction scope // so we can return the same producers for given current thread, transaction and destination var key = "{0}|{1}".FormatWith(Transaction.Current.TransactionInformation.LocalIdentifier, destination); if (!scopedProducers.ContainsKey(key)) { log.Debug("Detected that there is no pending scoped producer for {0}. Acquiring a new instance.".FormatWith(key)); var pooled = pool.Acquire(); var producer = (XmsProducer)pooled.Producer; return scopedProducers.GetOrAdd(key, k => new XmsCommitPerScopeProducer(pooled, producer.Session, () => { log.Debug("Removing pending scoped producer for {0}.".FormatWith(key)); XmsCommitPerScopeProducer _; scopedProducers.TryRemove(key, out _); })); } log.Debug("Detected pending scoped producer for {0}. Reusing the existing instance.".FormatWith(key)); return scopedProducers[key]; } if (transactional) { var pooled = pool.Acquire(); log.Debug("No transaction scope on transactional provider. Using per call producer."); var producer = (XmsProducer)pooled.Producer; return new XmsCommitPerCallProducer(pooled, producer.Session); } return pool.Acquire(); }
public IXmsConsumer GetConsumer(XmsDestination destination) { Pool<XmsPooledConsumer> pool; if (!poolsByDestination.TryGetValue(destination, out pool)) { lock (locker) { pool = poolsByDestination.GetOrAdd(destination, PoolFactory); } } var pooled = pool.Acquire(); if (IsInTransaction) { log.Debug("Detected transaction scope. Wrapping the consumer in transacted consumer."); // not very nice, we need ot get the session somehow var producer = (XmsConsumer)pooled.Consumer; return new XmsTransactedConsumer(pooled, producer.Session); } return pooled; }
// TODO: test this public static void PopulateErrorQueueMessage(IBytesMessage toSend, IBM.XMS.IBytesMessage failed, XmsDestination xmsDestination) { var body = new byte[failed.BodyLength]; if (body.Length > 0) { failed.ReadBytes(body, body.Length); toSend.WriteBytes(body); } toSend.JMSCorrelationID = failed.JMSCorrelationID; toSend.JMSDeliveryMode = failed.JMSDeliveryMode; toSend.CopyStringProperty(HEADER_RETURNADDRESS, failed); toSend.CopyStringProperty(HEADER_IDFORCORRELATION, failed); toSend.CopyStringProperty(HEADER_WINDOWSIDENTITYNAME, failed); toSend.CopyStringProperty(HEADER_MESSAGEINTENT, failed); var keys = failed.GetStringProperty(HEADER_NBSKEYS); var unwrapedKeys = UnwrapKeys(keys); foreach (var unwrapedKey in unwrapedKeys) { toSend.CopyStringProperty(unwrapedKey, failed); } toSend.CopyStringProperty(HEADER_NBSKEYS, failed); // error queue specific toSend.SetStringProperty(HEADER_FAILEDQUEUE, xmsDestination.ToString()); var id = failed.GetStringProperty(HEADER_ORIGINALID); toSend.SetStringProperty(HEADER_ORIGINALID, id); }
public static int GetCurrentQueueDebth(XmsDestination destination) { var manager = new MQQueueManager(destination.Manager, destination.Channel, destination.ConnectionName); var queue = manager.AccessQueue(destination.Queue, MQC.MQOO_INQUIRE); int depth = queue.CurrentDepth; manager.Disconnect(); manager.Close(); return depth; }
public static int Purge(XmsDestination 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; }