/* | |
* Licensed to the Apache Software Foundation (ASF) under one or more | |
* contributor license agreements. See the NOTICE file distributed with | |
* this work for additional information regarding copyright ownership. | |
* The ASF licenses this file to You under the Apache License, Version 2.0 | |
* (the "License"); you may not use this file except in compliance with | |
* the License. You may obtain a copy of the License at | |
* | |
* http://www.apache.org/licenses/LICENSE-2.0 | |
* | |
* Unless required by applicable law or agreed to in writing, software | |
* distributed under the License is distributed on an "AS IS" BASIS, | |
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. | |
* See the License for the specific language governing permissions and | |
* limitations under the License. | |
*/ | |
using System; | |
using System.Collections; | |
using System.Collections.Specialized; | |
using Apache.NMS.XMS.Util; | |
using Apache.NMS.Policies; | |
using Apache.NMS.Util; | |
using IBM.XMS; | |
namespace Apache.NMS.XMS | |
{ | |
/// <summary> | |
/// A Factory that can establish NMS connections to IBM MQ. | |
/// </summary> | |
/// <remarks> | |
/// XMS connection factories can either be created from definitions | |
/// administered in a repository ("administered object"), or created | |
/// from an <c>XMSFactoryFactory</c>. | |
/// | |
/// Addressable repositories for administered objects are: | |
/// - file system context | |
/// (URL format: "file://Path"). | |
/// - LDAP context | |
/// (URL format: "ldap:[Hostname][:Port]["/"[DistinguishedName]]"). | |
/// - WSS context: | |
/// (URL format: "http://Url", "cosnaming://Url" or "wsvc://Url"). | |
/// | |
/// A non-administered object is instanciated for a specific protocol: | |
/// - WebSphere Application Server Service Integration Bus | |
/// (protocol prefix: <c>"wpm:"</c>; XMS key: <c>XMSC.CT_WPM</c>). | |
/// - IBM Integration Bus using WebSphere MQ Real-Time Transport | |
/// (protocol prefix: <c>"rtt:"</c>; XMS key: <c>XMSC.CT_RTT</c>). | |
/// - WebSphere MQ queue manager | |
/// (protocol prefix: <c>"wmq:"</c>; XMS key: <c>XMSC.CT_WMQ</c>). | |
/// </remarks> | |
public class ConnectionFactory : Apache.NMS.IConnectionFactory | |
{ | |
public IBM.XMS.IConnectionFactory xmsConnectionFactory = null; | |
private Uri brokerUri = null; | |
private IRedeliveryPolicy redeliveryPolicy = new RedeliveryPolicy(); | |
#region Constructors | |
/// <summary> | |
/// Constructs a <c>ConnectionFactory</c> object using default values. | |
/// </summary> | |
public ConnectionFactory() | |
: this(new Uri("xms:wmq:")) | |
{ | |
} | |
/// <summary> | |
/// Constructs a <c>ConnectionFactory</c> object. | |
/// </summary> | |
/// <param name="brokerUri">Factory URI.</param> | |
public ConnectionFactory(Uri brokerUri) | |
{ | |
try | |
{ | |
// BrokerUri will construct the xmsConnectionFactory | |
this.BrokerUri = brokerUri; | |
} | |
catch(Exception ex) | |
{ | |
Apache.NMS.Tracer.DebugFormat( | |
"Exception instantiating IBM.XMS.ConnectionFactory: {0}", | |
ex.Message); | |
ExceptionUtil.WrapAndThrowNMSException(ex); | |
} | |
// In case WrapAndThrowNMSException masks the exception | |
if(this.xmsConnectionFactory == null) | |
{ | |
throw new Apache.NMS.NMSException( | |
"Error instantiating XMS connection factory object."); | |
} | |
} | |
/// <summary> | |
/// Constructs the internal <c>ConnectionFactory</c> object from the | |
/// parameters specified in the input URI. | |
/// </summary> | |
/// <param name="factoryUri">Factory URI.</param> | |
/// <returns>URI stripped out from overridable property values. | |
/// </returns> | |
private Uri CreateConnectionFactoryFromURI(Uri factoryUri) | |
{ | |
try | |
{ | |
// Remove "xms:" scheme prefix | |
string originalString = factoryUri.OriginalString; | |
factoryUri = new Uri(originalString.Substring( | |
originalString.IndexOf(":") + 1)); | |
// Parse URI properties | |
StringDictionary properties = URISupport.ParseQuery( | |
factoryUri.Query); | |
// The URI scheme specifies either the repository of | |
// administered objects where the ConnectionFactory object | |
// is defined, or the target connection type for | |
// non-administered objects. | |
switch(factoryUri.Scheme.ToLower()) | |
{ | |
case "rtt": | |
case "wmq": | |
case "wpm": | |
CreateNonAdministeredConnectionFactory( | |
factoryUri, properties); | |
break; | |
case "http": | |
case "ldap": | |
case "cosnaming": | |
case "wsvc": | |
default: | |
CreateAdministeredConnectionFactory( | |
factoryUri, properties); | |
break; | |
} | |
// Configure the instanciated connection factory | |
ConfigureConnectionFactory(factoryUri, properties); | |
return new Uri("xms:" + factoryUri.Scheme); | |
} | |
catch(Exception ex) | |
{ | |
ExceptionUtil.WrapAndThrowNMSException(ex); | |
return null; | |
} | |
} | |
/// <summary> | |
/// Creates a connection factory from the object definition retrieved | |
/// from a repository of administered objects. | |
/// </summary> | |
/// <param name="factoryUri">Factory URI.</param> | |
/// <param name="properties">URI properties.</param> | |
private void CreateAdministeredConnectionFactory( | |
Uri factoryUri, StringDictionary properties) | |
{ | |
// The initial context URL is the non-query part of the factory URI | |
string icUrl = factoryUri.OriginalString.Substring(0, | |
factoryUri.OriginalString.IndexOf('?')); | |
// Extract other InitialContext property values from URI | |
string icPrefix = "ic."; | |
StringDictionary icProperties = URISupport.ExtractProperties( | |
properties, icPrefix); | |
// Initialize environment Hashtable | |
Hashtable environment = new Hashtable(); | |
environment[XMSC.IC_URL] = icUrl; | |
foreach(DictionaryEntry de in icProperties) | |
{ | |
string key = ((string)de.Key).Substring(icPrefix.Length); | |
//TODO: convert "environment." attribute types. | |
environment[key] = de.Value; | |
} | |
// Create an InitialContext | |
InitialContext ic = new InitialContext(environment); | |
// Extract administered object name | |
string objectNameKey = "object.Name"; | |
if(!properties.ContainsKey(objectNameKey)) | |
{ | |
throw new NMSException(string.Format( | |
"URI attribute {0} must be specified.", objectNameKey)); | |
} | |
string objectName = properties[objectNameKey]; | |
properties.Remove(objectNameKey); | |
// Lookup for object | |
this.xmsConnectionFactory = | |
(IBM.XMS.IConnectionFactory)ic.Lookup(objectName); | |
} | |
/// <summary> | |
/// Creates a non-administered connection factory. | |
/// </summary> | |
/// <param name="factoryUri">Factory URI.</param> | |
/// <param name="properties">URI properties.</param> | |
private void CreateNonAdministeredConnectionFactory( | |
Uri factoryUri, StringDictionary properties) | |
{ | |
// Get an XMS factory factory for the requested protocol | |
IBM.XMS.XMSFactoryFactory xmsFactoryFactory = null; | |
string scheme = factoryUri.Scheme.ToLower(); | |
switch(scheme) | |
{ | |
case "rtt": | |
xmsFactoryFactory = | |
IBM.XMS.XMSFactoryFactory.GetInstance(IBM.XMS.XMSC.CT_RTT); | |
if(!string.IsNullOrEmpty(factoryUri.Host)) | |
{ | |
this.RTTHostName = factoryUri.Host; | |
} | |
if(factoryUri.Port != -1) | |
{ | |
this.RTTPort = factoryUri.Port; | |
} | |
break; | |
case "wmq": | |
xmsFactoryFactory = | |
IBM.XMS.XMSFactoryFactory.GetInstance(IBM.XMS.XMSC.CT_WMQ); | |
break; | |
case "wpm": | |
xmsFactoryFactory = | |
IBM.XMS.XMSFactoryFactory.GetInstance(IBM.XMS.XMSC.CT_WPM); | |
break; | |
} | |
// Create the connection factory | |
this.xmsConnectionFactory = | |
xmsFactoryFactory.CreateConnectionFactory(); | |
// For RTT and WMQ protocols, set the host name and port if | |
// they are specified | |
switch(scheme) | |
{ | |
case "rtt": | |
if(!string.IsNullOrEmpty(factoryUri.Host)) | |
{ | |
this.RTTHostName = factoryUri.Host; | |
} | |
if(factoryUri.Port != -1) | |
{ | |
this.RTTPort = factoryUri.Port; | |
} | |
break; | |
case "wmq": | |
if(!string.IsNullOrEmpty(factoryUri.Host)) | |
{ | |
this.WMQHostName = factoryUri.Host; | |
} | |
if(factoryUri.Port != -1) | |
{ | |
this.WMQPort = factoryUri.Port; | |
} | |
break; | |
} | |
} | |
/// <summary> | |
/// Configures the connection factory. | |
/// </summary> | |
/// <param name="factoryUri">Factory URI.</param> | |
/// <param name="properties">URI properties.</param> | |
private void ConfigureConnectionFactory( | |
Uri factoryUri, StringDictionary properties) | |
{ | |
if(properties != null && properties.Count > 0) | |
{ | |
IntrospectionSupport.SetProperties(this, properties); | |
} | |
} | |
#endregion | |
#region Redelivery Policy | |
/// <summary> | |
/// Get/or set the redelivery policy that new IConnection objects are | |
/// assigned upon creation. | |
/// </summary> | |
public IRedeliveryPolicy RedeliveryPolicy | |
{ | |
get { return this.redeliveryPolicy; } | |
set | |
{ | |
if(value != null) | |
{ | |
this.redeliveryPolicy = value; | |
} | |
} | |
} | |
#endregion | |
#region Properties (configure via URL parameters) | |
// http://www-01.ibm.com/support/knowledgecenter/?lang=en#!/SSFKSJ_8.0.0/com.ibm.mq.msc.doc/props_connf.htm | |
#region Connection Factory Properties common to all protocols | |
/// <summary> | |
/// The client identifier for a connection. | |
/// </summary> | |
[UriAttribute("factory.ClientId")] | |
public string ClientId | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.CLIENT_ID); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.CLIENT_ID, value); } | |
} | |
/// <summary> | |
/// The type of messaging server to which an application connects. | |
/// </summary> | |
[UriAttribute("factory.XMSConnectionType")] | |
public Int32 XMSConnectionType | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.CONNECTION_TYPE); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.CONNECTION_TYPE, value); } | |
} | |
/// <summary> | |
/// The type of messaging server to which an application connects. | |
/// </summary> | |
[UriAttribute("factory.ConnectionType")] | |
public ConnectionType ConnectionType | |
{ | |
get { return XMSConvert.ToConnectionType(this.XMSConnectionType); } | |
set { this.XMSConnectionType = XMSConvert.ToXMSConnectionType(value); } | |
} | |
/// <summary> | |
/// A user identifier that can be used to authenticate the application | |
/// when it attempts to connect to a messaging server. | |
/// </summary> | |
[UriAttribute("factory.UserId")] | |
public string UserId | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.USERID); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.USERID, value); } | |
} | |
/// <summary> | |
/// A password that can be used to authenticate the application when it | |
/// attempts to connect to a messaging server. | |
/// </summary> | |
[UriAttribute("factory.XMSPassword")] | |
public byte[] XMSPassword | |
{ | |
get { return this.xmsConnectionFactory.GetBytesProperty(XMSC.PASSWORD); } | |
set { this.xmsConnectionFactory.SetBytesProperty(XMSC.PASSWORD, value); } | |
} | |
/// <summary> | |
/// A password that can be used to authenticate the application when it | |
/// attempts to connect to a messaging server, specified as a string. | |
/// </summary> | |
[UriAttribute("factory.Password")] | |
public string Password | |
{ | |
get { return Convert.ToBase64String(this.XMSPassword); } | |
set { this.XMSPassword = Convert.FromBase64String(value); } | |
} | |
/// <summary> | |
/// This property determines whether XMS informs an ExceptionListener | |
/// only when a connection is broken, or when any exception occurs | |
/// asynchronously to an XMS API call. | |
/// </summary> | |
/// <remarks> | |
/// This property applies to all Connections created from this | |
/// ConnectionFactory that have an ExceptionListener registered. | |
/// </remarks> | |
[UriAttribute("factory.XMSAsynchronousExceptions")] | |
public Int32 XMSAsynchronousExceptions | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.ASYNC_EXCEPTIONS); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.ASYNC_EXCEPTIONS, value); } | |
} | |
/// <summary> | |
/// This property determines whether XMS informs an | |
/// <c>ExceptionListener</c> only when a connection is broken, or when | |
/// any exception occurs asynchronously to an XMS API call. | |
/// </summary> | |
[UriAttribute("factory.AsynchronousExceptions")] | |
public AsynchronousExceptions AsynchronousExceptions | |
{ | |
get { return XMSConvert.ToAsynchronousExceptions(this.XMSAsynchronousExceptions); } | |
set { this.XMSAsynchronousExceptions = XMSConvert.ToXMSAsynchronousExceptions(value); } | |
} | |
#endregion | |
#region RTT-specific properties | |
/// <summary> | |
/// The communications protocol used for a real-time connection to a broker. | |
/// </summary> | |
[UriAttribute("rtt.XMSConnectionProtocol")] | |
public Int32 XMSConnectionProtocol | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.RTT_CONNECTION_PROTOCOL); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.RTT_CONNECTION_PROTOCOL, value); } | |
} | |
/// <summary> | |
/// The communications protocol used for a real-time connection to a broker. | |
/// </summary> | |
[UriAttribute("rtt.ConnectionProtocol")] | |
public RTTConnectionProtocol ConnectionProtocol | |
{ | |
get { return XMSConvert.ToRTTConnectionProtocol(this.XMSConnectionProtocol); } | |
set { this.XMSConnectionProtocol = XMSConvert.ToXMSRTTConnectionProtocol(value); } | |
} | |
/// <summary> | |
/// The host name or IP address of the system on which a broker runs. | |
/// </summary> | |
[UriAttribute("rtt.HostName")] | |
public string RTTHostName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.RTT_HOST_NAME); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.RTT_HOST_NAME, value); } | |
} | |
/// <summary> | |
/// The number of the port on which a broker listens for incoming requests. | |
/// </summary> | |
[UriAttribute("rtt.Port")] | |
public Int32 RTTPort | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.RTT_PORT); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.RTT_PORT, value); } | |
} | |
/// <summary> | |
/// The host name or IP address of the local network interface to be | |
/// used for a real-time connection to a broker. | |
/// </summary> | |
[UriAttribute("rtt.LocalAddress")] | |
public string RTTLocalAddress | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.RTT_LOCAL_ADDRESS); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.RTT_LOCAL_ADDRESS, value); } | |
} | |
/// <summary> | |
/// The multicast setting for the connection factory. | |
/// </summary> | |
[UriAttribute("rtt.XMSMulticast")] | |
public Int32 XMSMulticast | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.RTT_MULTICAST); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.RTT_MULTICAST, value); } | |
} | |
/// <summary> | |
/// The multicast setting for a connection factory or destination. | |
/// </summary> | |
[UriAttribute("rtt.Multicast")] | |
public Multicast Multicast | |
{ | |
get { return XMSConvert.ToMulticast(this.XMSMulticast); } | |
set { this.XMSMulticast = XMSConvert.ToXMSMulticast(value); } | |
} | |
/// <summary> | |
/// The time interval, in milliseconds, after which XMS .NET checks the | |
/// connection to a Real Time messaging server to detect any activity. | |
/// </summary> | |
[UriAttribute("rtt.BrokerPingInterval")] | |
public Int32 BrokerPingInterval | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.RTT_BROKER_PING_INTERVAL); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.RTT_BROKER_PING_INTERVAL, value); } | |
} | |
#endregion | |
#region WMQ-specific properties | |
/// <summary> | |
/// The host name or IP address of the system on which a queue manager | |
/// runs. | |
/// </summary> | |
[UriAttribute("wmq.HostName")] | |
public string WMQHostName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_HOST_NAME); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_HOST_NAME, value); } | |
} | |
/// <summary> | |
/// The number of the port on which a queue manager listens for | |
/// incoming requests. | |
/// </summary> | |
[UriAttribute("wmq.Port")] | |
public Int32 WMQPort | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_PORT); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_PORT, value); } | |
} | |
/// <summary> | |
/// For a connection to a queue manager, this property specifies the | |
/// local network interface to be used, or the local port or range of | |
/// local ports to be used, or both. | |
/// </summary> | |
[UriAttribute("wmq.LocalAddress")] | |
public string WMQLocalAddress | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_LOCAL_ADDRESS); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_LOCAL_ADDRESS, value); } | |
} | |
/// <summary> | |
/// The name of the queue manager to connect to. | |
/// </summary> | |
[UriAttribute("wmq.QueueManagerName")] | |
public string QueueManagerName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_QUEUE_MANAGER); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_QUEUE_MANAGER, value); } | |
} | |
/// <summary> | |
/// The version, release, modification level and fix pack of the queue | |
/// manager to which the application intends to connect. | |
/// </summary> | |
[UriAttribute("wmq.ProviderVersion")] | |
public string ProviderVersion | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_PROVIDER_VERSION); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_PROVIDER_VERSION, value); } | |
} | |
/// <summary> | |
/// The name of the channel to be used for a connection. | |
/// </summary> | |
[UriAttribute("wmq.ChannelName")] | |
public string ChannelName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_CHANNEL); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_CHANNEL, value); } | |
} | |
/// <summary> | |
/// A Uniform Resource Locator (URL) that identifies the name and | |
/// location of the file that contains the client channel definition | |
/// table and also specifies how the file can be accessed. | |
/// </summary> | |
[UriAttribute("wmq.ClientChannelDefinitionTableURL")] | |
public string ClientChannelDefinitionTableURL | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_CCDTURL); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_CCDTURL, value); } | |
} | |
/// <summary> | |
/// The mode by which an application connects to a queue manager. | |
/// </summary> | |
[UriAttribute("wmq.XMSConnectionMode")] | |
public Int32 XMSConnectionMode | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_CONNECTION_MODE); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_CONNECTION_MODE, value); } | |
} | |
/// <summary> | |
/// The mode by which an application connects to a queue manager, | |
/// specified as a string. | |
/// </summary> | |
[UriAttribute("wmq.ConnectionMode")] | |
public ConnectionMode ConnectionMode | |
{ | |
get { return XMSConvert.ToConnectionMode(this.XMSConnectionMode); } | |
set { this.XMSConnectionMode = XMSConvert.ToXMSConnectionMode(value); } | |
} | |
/// <summary> | |
/// This property specifies the client reconnect options for new | |
/// connections created by this factory. | |
/// </summary> | |
[UriAttribute("wmq.ClientReconnectOptions")] | |
public string ClientReconnectOptions | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_CLIENT_RECONNECT_OPTIONS); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_CLIENT_RECONNECT_OPTIONS, value); } | |
} | |
/// <summary> | |
/// This property specifies the duration of time, in seconds, that a | |
/// client connection attempts to reconnect. | |
/// </summary> | |
[UriAttribute("wmq.ClientReconnectTimeout")] | |
public string ClientReconnectTimeout | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_CLIENT_RECONNECT_TIMEOUT); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_CLIENT_RECONNECT_TIMEOUT, value); } | |
} | |
/// <summary> | |
/// This property specifies the hosts to which the client attempts to | |
/// reconnect to after its connection are broken. | |
/// </summary> | |
[UriAttribute("wmq.ConnectionNameList")] | |
public string ConnectionNameList | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_CONNECTION_NAME_LIST); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_CONNECTION_NAME_LIST, value); } | |
} | |
/// <summary> | |
/// Whether calls to certain methods fail if the queue manager to which | |
/// the application is connected is in a quiescing state. | |
/// </summary> | |
[UriAttribute("wmq.XMSFailIfQuiesce")] | |
public Int32 XMSFailIfQuiesce | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_FAIL_IF_QUIESCE); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_FAIL_IF_QUIESCE, value); } | |
} | |
/// <summary> | |
/// Whether calls to certain methods fail if the queue manager to which | |
/// the application is connected is in a quiescing state. | |
/// </summary> | |
[UriAttribute("wmq.FailIfQuiesce")] | |
public bool FailIfQuiesce | |
{ | |
get { return XMSConvert.ToFailIfQuiesce(this.XMSFailIfQuiesce); } | |
set { this.XMSFailIfQuiesce = XMSConvert.ToXMSFailIfQuiesce(value); } | |
} | |
/// <summary> | |
/// The type of broker used by the application for a connection or for | |
/// the destination. | |
/// </summary> | |
[UriAttribute("wmq.XMSBrokerVersion")] | |
public Int32 XMSBrokerVersion | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_BROKER_VERSION); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_BROKER_VERSION, value); } | |
} | |
/// <summary> | |
/// The type of broker used by the application for a connection or for | |
/// the destination. | |
/// </summary> | |
[UriAttribute("wmq.BrokerVersion")] | |
public BrokerVersion BrokerVersion | |
{ | |
get { return XMSConvert.ToBrokerVersion(this.XMSBrokerVersion); } | |
set { this.XMSBrokerVersion = XMSConvert.ToXMSBrokerVersion(value); } | |
} | |
/// <summary> | |
/// The name of the queue manager to which a broker is connected. | |
/// </summary> | |
[UriAttribute("wmq.BrokerQueueManagerName")] | |
public string BrokerQueueManagerName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_BROKER_QMGR); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_BROKER_QMGR, value); } | |
} | |
/// <summary> | |
/// The name of the control queue used by a broker. | |
/// </summary> | |
[UriAttribute("wmq.BrokerControlQueueName")] | |
public string BrokerControlQueueName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_BROKER_CONTROLQ); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_BROKER_CONTROLQ, value); } | |
} | |
/// <summary> | |
/// The name of the queue monitored by a broker where applications send | |
/// messages that they publish. | |
/// </summary> | |
[UriAttribute("wmq.BrokerPublishQueueName")] | |
public string BrokerPublishQueueName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_BROKER_PUBQ); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_BROKER_PUBQ, value); } | |
} | |
/// <summary> | |
/// The name of the subscriber queue for a nondurable message consumer. | |
/// </summary> | |
[UriAttribute("wmq.BrokerSubscriberQueueName")] | |
public string BrokerSubscriberQueueName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_BROKER_SUBQ); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_BROKER_SUBQ, value); } | |
} | |
/// <summary> | |
/// Determines whether message selection is done by the XMS client or | |
/// by the broker. | |
/// </summary> | |
[UriAttribute("wmq.XMSMessageSelection")] | |
public Int32 XMSMessageSelection | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_MESSAGE_SELECTION); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_MESSAGE_SELECTION, value); } | |
} | |
/// <summary> | |
/// Determines whether message selection is done by the XMS client or | |
/// by the broker. | |
/// </summary> | |
[UriAttribute("wmq.MessageSelection")] | |
public MessageSelection MessageSelection | |
{ | |
get { return XMSConvert.ToMessageSelection(this.XMSMessageSelection); } | |
set { this.XMSMessageSelection = XMSConvert.ToXMSMessageSelection(value); } | |
} | |
/// <summary> | |
/// The maximum number of messages to be retrieved from a queue in one | |
/// batch when using asynchronous message delivery. | |
/// </summary> | |
[UriAttribute("wmq.MessageBatchSize")] | |
public Int32 MessageBatchSize | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_MSG_BATCH_SIZE); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_MSG_BATCH_SIZE, value); } | |
} | |
/// <summary> | |
/// If each message listener within a session has no suitable message | |
/// on its queue, this value is the maximum interval, in milliseconds, | |
/// that elapses before each message listener tries again to get a | |
/// message from its queue. | |
/// </summary> | |
[UriAttribute("wmq.PollingInterval")] | |
public Int32 PollingInterval | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_POLLING_INTERVAL); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_POLLING_INTERVAL, value); } | |
} | |
/// <summary> | |
/// The number of messages published by a publisher before the XMS | |
/// client requests an acknowledgement from the broker. | |
/// </summary> | |
[UriAttribute("wmq.PublishAcknowledgementInterval")] | |
public Int32 PublishAcknowledgementInterval | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_PUB_ACK_INTERVAL); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_PUB_ACK_INTERVAL, value); } | |
} | |
/// <summary> | |
/// This property determines whether message producers are allowed to | |
/// use asynchronous puts to send messages to this destination. | |
/// </summary> | |
[UriAttribute("wmq.XMSAsynchronousPutsAllowed")] | |
public Int32 XMSAsynchronousPutsAllowed | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_PUT_ASYNC_ALLOWED); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_PUT_ASYNC_ALLOWED, value); } | |
} | |
/// <summary> | |
/// This property determines whether message producers are allowed to | |
/// use asynchronous puts to send messages to this destination. | |
/// </summary> | |
[UriAttribute("wmq.AsynchronousPutsAllowed")] | |
public AsynchronousPutsAllowed AsynchronousPutsAllowed | |
{ | |
get { return XMSConvert.ToAsynchronousPutsAllowed(this.XMSAsynchronousPutsAllowed); } | |
set { this.XMSAsynchronousPutsAllowed = XMSConvert.ToXMSAsynchronousPutsAllowed(value); } | |
} | |
/// <summary> | |
/// The identifier (CCSID) of the coded character set, or code page, | |
/// in which fields of character data defined in the Message Queue | |
/// Interface (MQI) are exchanged between the XMS client and the | |
/// WebSphere MQ client. | |
/// </summary> | |
[UriAttribute("wmq.QueueManagerCCSID")] | |
public string QueueManagerCCSID | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_QMGR_CCSID); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_QMGR_CCSID, value); } | |
} | |
/// <summary> | |
/// Identifies a channel receive exit to be run. | |
/// </summary> | |
[UriAttribute("wmq.ReceiveExit")] | |
public string ReceiveExit | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_RECEIVE_EXIT); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_RECEIVE_EXIT, value); } | |
} | |
/// <summary> | |
/// The user data that is passed to a channel receive exit when it | |
/// is called. | |
/// </summary> | |
[UriAttribute("wmq.ReceiveExitInit")] | |
public string ReceiveExitInit | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_RECEIVE_EXIT_INIT); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_RECEIVE_EXIT_INIT, value); } | |
} | |
/// <summary> | |
/// Identifies a channel security exit. | |
/// </summary> | |
[UriAttribute("wmq.SecurityExit")] | |
public string SecurityExit | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SECURITY_EXIT); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SECURITY_EXIT, value); } | |
} | |
/// <summary> | |
/// The user data that is passed to a channel security exit when it | |
/// is called. | |
/// </summary> | |
[UriAttribute("wmq.SecurityExitInit")] | |
public string SecurityExitInit | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SECURITY_EXIT_INIT); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SECURITY_EXIT_INIT, value); } | |
} | |
/// <summary> | |
/// Identifies a channel send exit. | |
/// </summary> | |
[UriAttribute("wmq.SendExit")] | |
public string SendExit | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SEND_EXIT); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SEND_EXIT, value); } | |
} | |
/// <summary> | |
/// The user data that is passed to channel send exits when they | |
/// are called. | |
/// </summary> | |
[UriAttribute("wmq.SendExitInit")] | |
public string SendExitInit | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SEND_EXIT_INIT); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SEND_EXIT_INIT, value); } | |
} | |
/// <summary> | |
/// The number of send calls to allow between checking for asynchronous | |
/// put errors, within a single non-transacted XMS session. | |
/// </summary> | |
[UriAttribute("wmq.SendCheckCount")] | |
public Int32 SendCheckCount | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_SEND_CHECK_COUNT); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_SEND_CHECK_COUNT, value); } | |
} | |
/// <summary> | |
/// Whether a client connection can share its socket with other | |
/// top-level XMS connections from the same process to the same queue | |
/// manager, if the channel definitions match. | |
/// </summary> | |
[UriAttribute("wmq.XMSShareSocketAllowed")] | |
public Int32 XMSShareSocketAllowed | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_SHARE_CONV_ALLOWED); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_SHARE_CONV_ALLOWED, value); } | |
} | |
/// <summary> | |
/// Whether a client connection can share its socket with other | |
/// top-level XMS connections from the same process to the same queue | |
/// manager, if the channel definitions match. | |
/// </summary> | |
[UriAttribute("wmq.ShareSocketAllowed")] | |
public bool ShareSocketAllowed | |
{ | |
get { return XMSConvert.ToShareSocketAllowed(this.XMSShareSocketAllowed); } | |
set { this.XMSShareSocketAllowed = XMSConvert.ToXMSShareSocketAllowed(value); } | |
} | |
/// <summary> | |
/// The locations of the servers that hold the certificate revocation | |
/// lists (CRLs) to be used on an SSL connection to a queue manager. | |
/// </summary> | |
[UriAttribute("wmq.SSLCertificateStores")] | |
public string SSLCertificateStores | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SSL_CERT_STORES); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SSL_CERT_STORES, value); } | |
} | |
/// <summary> | |
/// The name of the CipherSpec to be used on a secure connection to | |
/// a queue manager. | |
/// </summary> | |
[UriAttribute("wmq.SSLCipherSpec")] | |
public string SSLCipherSpec | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SSL_CIPHER_SPEC); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SSL_CIPHER_SPEC, value); } | |
} | |
/// <summary> | |
/// The name of the CipherSuite to be used on an SSL or TLS connection | |
/// to a queue manager. The protocol used in negotiating the secure | |
/// connection depends on the specified CipherSuite. | |
/// </summary> | |
[UriAttribute("wmq.SSLCipherSuite")] | |
public string SSLCipherSuite | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SSL_CIPHER_SUITE); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SSL_CIPHER_SUITE, value); } | |
} | |
/// <summary> | |
/// Configuration details for the cryptographic hardware connected | |
/// to the client system. | |
/// </summary> | |
[UriAttribute("wmq.SSLCryptoHardware")] | |
public string SSLCryptoHardware | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SSL_CRYPTO_HW); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SSL_CRYPTO_HW, value); } | |
} | |
/// <summary> | |
/// The value of this property determines whether an application can | |
/// or cannot use non-FIPS compliant cipher suites. If this property | |
/// is set to true, only FIPS algorithms are used for the client-server | |
/// connection. | |
/// </summary> | |
[UriAttribute("wmq.SSLFipsRequired")] | |
public bool SSLFipsRequired | |
{ | |
get { return this.xmsConnectionFactory.GetBooleanProperty(XMSC.WMQ_SSL_FIPS_REQUIRED); } | |
set { this.xmsConnectionFactory.SetBooleanProperty(XMSC.WMQ_SSL_FIPS_REQUIRED, value); } | |
} | |
/// <summary> | |
/// The location of the key database file in which keys and | |
/// certificates are stored. | |
/// </summary> | |
[UriAttribute("wmq.SSLKeyRepository")] | |
public string SSLKeyRepository | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SSL_KEY_REPOSITORY); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SSL_KEY_REPOSITORY, value); } | |
} | |
/// <summary> | |
/// The KeyResetCount represents the total number of unencrypted bytes | |
/// sent and received within an SSL conversation before the secret key | |
/// is renegotiated. | |
/// </summary> | |
[UriAttribute("wmq.SSLKeyResetCount")] | |
public Int32 SSLKeyResetCount | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_SSL_KEY_RESETCOUNT); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_SSL_KEY_RESETCOUNT, value); } | |
} | |
/// <summary> | |
/// The peer name to be used on an SSL connection to a queue manager. | |
/// </summary> | |
[UriAttribute("wmq.SSLPeerName")] | |
public string SSLPeerName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_SSL_PEER_NAME); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_SSL_PEER_NAME, value); } | |
} | |
/// <summary> | |
/// Whether all messages must be retrieved from queues within sync point control. | |
/// </summary> | |
[UriAttribute("wmq.SyncpointAllGets")] | |
public bool SyncpointAllGets | |
{ | |
get { return this.xmsConnectionFactory.GetBooleanProperty(XMSC.WMQ_SYNCPOINT_ALL_GETS); } | |
set { this.xmsConnectionFactory.SetBooleanProperty(XMSC.WMQ_SYNCPOINT_ALL_GETS, value); } | |
} | |
/// <summary> | |
/// Whether messages sent to the destination contain an MQRFH2 header. | |
/// </summary> | |
[UriAttribute("wmq.XMSTargetClient")] | |
public Int32 XMSTargetClient | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WMQ_TARGET_CLIENT); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WMQ_TARGET_CLIENT, value); } | |
} | |
/// <summary> | |
/// Whether messages sent to the destination contain an <c>MQRFH2</c> | |
/// header. | |
/// </summary> | |
[UriAttribute("wmq.TargetClient")] | |
public TargetClient TargetClient | |
{ | |
get { return XMSConvert.ToTargetClient(this.XMSTargetClient); } | |
set { this.XMSTargetClient = XMSConvert.ToXMSTargetClient(value); } | |
} | |
/// <summary> | |
/// The prefix used to form the name of the WebSphere MQ dynamic queue | |
/// that is created when the application creates an XMS temporary queue. | |
/// </summary> | |
[UriAttribute("wmq.TemporaryQueuePrefix")] | |
public string WMQTemporaryQueuePrefix | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_TEMP_Q_PREFIX); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_TEMP_Q_PREFIX, value); } | |
} | |
/// <summary> | |
/// When creating temporary topics, XMS generates a topic string of | |
/// the form "TEMP/TEMPTOPICPREFIX/unique_id", or if this property | |
/// contains the default value, then this string, "TEMP/unique_id", is | |
/// generated. Specifying a non-empty value allows specific model | |
/// queues to be defined for creating the managed queues for subscribers | |
/// to temporary topics created under this connection. | |
/// </summary> | |
[UriAttribute("wmq.TemporaryTopicPrefix")] | |
public string WMQTemporaryTopicPrefix | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_TEMP_TOPIC_PREFIX); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_TEMP_TOPIC_PREFIX, value); } | |
} | |
/// <summary> | |
/// The name of the WebSphere MQ model queue from which a dynamic | |
/// queue is created when the application creates an XMS temporary | |
/// queue. | |
/// </summary> | |
[UriAttribute("wmq.TemporaryModel")] | |
public string WMQTemporaryModel | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_TEMP_TOPIC_PREFIX); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_TEMP_TOPIC_PREFIX, value); } | |
} | |
#endregion | |
#region WPM-specific properties | |
/// <summary> | |
/// For a connection to a service integration bus, this property | |
/// specifies the local network interface to be used, or the local | |
/// port or range of local ports to be used, or both. | |
/// </summary> | |
[UriAttribute("wpm.LocalAddress")] | |
public string WPMLocalAddress | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WPM_LOCAL_ADDRESS); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WPM_LOCAL_ADDRESS, value); } | |
} | |
/// <summary> | |
/// The name of the service integration bus that the application | |
/// connects to. | |
/// </summary> | |
[UriAttribute("wpm.BusName")] | |
public string BusName | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WPM_BUS_NAME); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WPM_BUS_NAME, value); } | |
} | |
/// <summary> | |
/// The connection proximity setting for the connection. | |
/// </summary> | |
[UriAttribute("wpm.XMSConnectionProximity")] | |
public Int32 XMSConnectionProximity | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WPM_CONNECTION_PROXIMITY); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WPM_CONNECTION_PROXIMITY, value); } | |
} | |
/// <summary> | |
/// The connection proximity setting for the connection. | |
/// </summary> | |
[UriAttribute("wpm.ConnectionProximity")] | |
public ConnectionProximity ConnectionProximity | |
{ | |
get { return XMSConvert.ToConnectionProximity(this.XMSConnectionProximity); } | |
set { this.XMSConnectionProximity = XMSConvert.ToXMSConnectionProximity(value); } | |
} | |
/// <summary> | |
/// The name of the messaging engine where all durable subscriptions | |
/// for a connection or a destination are managed. | |
/// </summary> | |
[UriAttribute("wpm.DurableSubscriptionHome")] | |
public string DurableSubscriptionHome | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WPM_DUR_SUB_HOME); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WPM_DUR_SUB_HOME, value); } | |
} | |
/// <summary> | |
/// The reliability level of nonpersistent messages that are sent | |
/// using the connection. | |
/// </summary> | |
[UriAttribute("wpm.XMSNonPersistentMap")] | |
public Int32 XMSNonPersistentMap | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WPM_NON_PERSISTENT_MAP); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WPM_NON_PERSISTENT_MAP, value); } | |
} | |
/// <summary> | |
/// The reliability level of nonpersistent messages that are sent | |
/// using the connection. | |
/// </summary> | |
[UriAttribute("wpm.NonPersistentMap")] | |
public Mapping NonPersistentMap | |
{ | |
get { return XMSConvert.ToMapping(this.XMSNonPersistentMap); } | |
set { this.XMSNonPersistentMap = XMSConvert.ToXMSMapping(value); } | |
} | |
/// <summary> | |
/// The reliability level of persistent messages that are sent | |
/// using the connection. | |
/// </summary> | |
[UriAttribute("wpm.XMSPersistentMap")] | |
public Int32 XMSPersistentMap | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WPM_PERSISTENT_MAP); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WPM_PERSISTENT_MAP, value); } | |
} | |
/// <summary> | |
/// The reliability level of persistent messages that are sent | |
/// using the connection. | |
/// </summary> | |
[UriAttribute("wpm.PersistentMap")] | |
public Mapping PersistentMap | |
{ | |
get { return XMSConvert.ToMapping(this.XMSPersistentMap); } | |
set { this.XMSPersistentMap = XMSConvert.ToXMSMapping(value); } | |
} | |
/// <summary> | |
/// A sequence of one or more endpoint addresses of bootstrap servers. | |
/// </summary> | |
[UriAttribute("wpm.ProviderEndpoints")] | |
public string ProviderEndpoints | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WPM_PROVIDER_ENDPOINTS); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WPM_PROVIDER_ENDPOINTS, value); } | |
} | |
/// <summary> | |
/// The name of a target group of messaging engines. | |
/// </summary> | |
[UriAttribute("wpm.TargetGroup")] | |
public string TargetGroup | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WPM_TARGET_GROUP); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WPM_TARGET_GROUP, value); } | |
} | |
/// <summary> | |
/// The significance of the target group of messaging engines. | |
/// </summary> | |
[UriAttribute("wpm.XMSTargetSignificance")] | |
public Int32 XMSTargetSignificance | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WPM_TARGET_SIGNIFICANCE); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WPM_TARGET_SIGNIFICANCE, value); } | |
} | |
/// <summary> | |
/// The significance of the target group of messaging engines. | |
/// </summary> | |
[UriAttribute("wpm.TargetSignificance")] | |
public TargetSignificance TargetSignificance | |
{ | |
get { return XMSConvert.ToTargetSignificance(this.XMSTargetSignificance); } | |
set { this.XMSTargetSignificance = XMSConvert.ToXMSTargetSignificance(value); } | |
} | |
/// <summary> | |
/// The name of the inbound transport chain that the application must | |
/// use to connect to a messaging engine. | |
/// </summary> | |
[UriAttribute("wpm.TargetTransportChain")] | |
public string TargetTransportChain | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WPM_TARGET_TRANSPORT_CHAIN); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WPM_TARGET_TRANSPORT_CHAIN, value); } | |
} | |
/// <summary> | |
/// The type of the target group of messaging engines. | |
/// </summary> | |
[UriAttribute("wpm.XMSTargetType")] | |
public Int32 XMSTargetType | |
{ | |
get { return this.xmsConnectionFactory.GetIntProperty(XMSC.WPM_TARGET_TYPE); } | |
set { this.xmsConnectionFactory.SetIntProperty(XMSC.WPM_TARGET_TYPE, value); } | |
} | |
/// <summary> | |
/// The type of the target group of messaging engines. | |
/// </summary> | |
[UriAttribute("wpm.TargetType")] | |
public TargetType TargetType | |
{ | |
get { return XMSConvert.ToTargetType(this.XMSTargetType); } | |
set { this.XMSTargetType = XMSConvert.ToXMSTargetType(value); } | |
} | |
/// <summary> | |
/// The prefix used to form the name of the temporary queue that is | |
/// created in the service integration bus when the application creates | |
/// an XMS temporary queue. | |
/// </summary> | |
[UriAttribute("wpm.TemporaryQueuePrefix")] | |
public string WPMTemporaryQueuePrefix | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_TEMP_Q_PREFIX); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_TEMP_Q_PREFIX, value); } | |
} | |
/// <summary> | |
/// The prefix used to form the name of a temporary topic that is | |
/// created by the application. | |
/// </summary> | |
[UriAttribute("wpm.TemporaryTopicPrefix")] | |
public string WPMTemporaryTopicPrefix | |
{ | |
get { return this.xmsConnectionFactory.GetStringProperty(XMSC.WMQ_TEMP_TOPIC_PREFIX); } | |
set { this.xmsConnectionFactory.SetStringProperty(XMSC.WMQ_TEMP_TOPIC_PREFIX, value); } | |
} | |
#endregion | |
#region Common properties having protocol-specific keys | |
/// <summary> | |
/// The host name or IP address of the system on which a broker (RTT) | |
/// or queue manager (WMQ) runs. | |
/// </summary> | |
public string HostName | |
{ | |
get | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case XMSC.CT_RTT: return this.RTTHostName; | |
case XMSC.CT_WMQ: return this.WMQHostName; | |
case XMSC.CT_WPM: return null; | |
default : return null; | |
} | |
} | |
set | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case XMSC.CT_RTT: this.RTTHostName = value; break; | |
case XMSC.CT_WMQ: this.WMQHostName = value; break; | |
case XMSC.CT_WPM: break; | |
default : break; | |
} | |
} | |
} | |
/// <summary> | |
/// The number of the port on which a broker (RTT) or queue manager | |
/// (WMQ) listens for incoming requests. | |
/// </summary> | |
public Int32 Port | |
{ | |
get | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: return this.RTTPort; | |
case IBM.XMS.XMSC.CT_WMQ: return this.WMQPort; | |
case IBM.XMS.XMSC.CT_WPM: return 0; | |
default : return 0; | |
} | |
} | |
set | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: this.RTTPort = value; break; | |
case IBM.XMS.XMSC.CT_WMQ: this.WMQPort = value; break; | |
case IBM.XMS.XMSC.CT_WPM: break; | |
default : break; | |
} | |
} | |
} | |
/// <summary> | |
/// The host name or IP address of the local network interface to be | |
/// used for a RTT real-time connection to a broker. | |
/// For a WMQ connection to a queue manager, this property specifies | |
/// the local network interface to be used, or the local port or range | |
/// of local ports to be used, or both. | |
/// For a WPM connection to a service integration bus, this property | |
/// specifies the local network interface to be used, or the local | |
/// port or range of local ports to be used, or both. | |
/// </summary> | |
public string LocalAddress | |
{ | |
get | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: return this.RTTLocalAddress; | |
case IBM.XMS.XMSC.CT_WMQ: return this.WMQLocalAddress; | |
case IBM.XMS.XMSC.CT_WPM: return this.WPMLocalAddress; | |
default : return null; | |
} | |
} | |
set | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: this.RTTLocalAddress = value; break; | |
case IBM.XMS.XMSC.CT_WMQ: this.WMQLocalAddress = value; break; | |
case IBM.XMS.XMSC.CT_WPM: this.WPMLocalAddress = value; break; | |
default : break; | |
} | |
} | |
} | |
/// <summary> | |
/// The prefix used to form the name of the WebSphere MQ dynamic queue | |
/// that is created (WMQ), or the name of the temporary queue that is | |
/// created in the service integration bus (WPM) when the application | |
/// creates an XMS temporary queue. | |
/// </summary> | |
public string TemporaryQueuePrefix | |
{ | |
get | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: return null; | |
case IBM.XMS.XMSC.CT_WMQ: return this.WMQTemporaryQueuePrefix; | |
case IBM.XMS.XMSC.CT_WPM: return this.WPMTemporaryQueuePrefix; | |
default : return null; | |
} | |
} | |
set | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: break; | |
case IBM.XMS.XMSC.CT_WMQ: this.WMQTemporaryQueuePrefix = value; break; | |
case IBM.XMS.XMSC.CT_WPM: this.WPMTemporaryQueuePrefix = value; break; | |
default : break; | |
} | |
} | |
} | |
/// <summary> | |
/// The prefix used to form the name of a temporary topic that is | |
/// created by the application (WMQ and WPM). | |
/// </summary> | |
public string TemporaryTopicPrefix | |
{ | |
get | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: return null; | |
case IBM.XMS.XMSC.CT_WMQ: return this.WMQTemporaryTopicPrefix; | |
case IBM.XMS.XMSC.CT_WPM: return this.WPMTemporaryTopicPrefix; | |
default : return null; | |
} | |
} | |
set | |
{ | |
switch(this.XMSConnectionType) | |
{ | |
case IBM.XMS.XMSC.CT_RTT: break; | |
case IBM.XMS.XMSC.CT_WMQ: this.WMQTemporaryTopicPrefix = value; break; | |
case IBM.XMS.XMSC.CT_WPM: this.WPMTemporaryTopicPrefix = value; break; | |
default : break; | |
} | |
} | |
} | |
#endregion | |
#endregion | |
#region IConnectionFactory Members | |
/// <summary> | |
/// Creates a new connection to IBM MQ with the default properties. | |
/// </summary> | |
public Apache.NMS.IConnection CreateConnection() | |
{ | |
Apache.NMS.IConnection connection = null; | |
try | |
{ | |
connection = new Apache.NMS.XMS.Connection( | |
this.xmsConnectionFactory.CreateConnection()); | |
ConfigureConnection(connection); | |
} | |
catch(Exception ex) | |
{ | |
ExceptionUtil.WrapAndThrowNMSException(ex); | |
} | |
return connection; | |
} | |
/// <summary> | |
/// Creates a new connection to IBM MQ using a specified user identity. | |
/// </summary> | |
/// <param name="userName">User name.</param> | |
/// <param name="password">Password.</param> | |
public Apache.NMS.IConnection CreateConnection( | |
string userName, string password) | |
{ | |
Apache.NMS.IConnection connection = null; | |
try | |
{ | |
connection = new Apache.NMS.XMS.Connection( | |
this.xmsConnectionFactory.CreateConnection( | |
userName, password)); | |
ConfigureConnection(connection); | |
} | |
catch(Exception ex) | |
{ | |
ExceptionUtil.WrapAndThrowNMSException(ex); | |
} | |
return connection; | |
} | |
/// <summary> | |
/// Configure the newly created connection. | |
/// </summary> | |
/// <param name="connection">Connection.</param> | |
private void ConfigureConnection(IConnection connection) | |
{ | |
connection.RedeliveryPolicy = this.redeliveryPolicy.Clone() as IRedeliveryPolicy; | |
connection.ConsumerTransformer = this.consumerTransformer; | |
connection.ProducerTransformer = this.producerTransformer; | |
} | |
/// <summary> | |
/// Get or set the broker URI. | |
/// </summary> | |
public Uri BrokerUri | |
{ | |
get { return this.brokerUri; } | |
set { this.brokerUri = CreateConnectionFactoryFromURI(value); } | |
} | |
private ConsumerTransformerDelegate consumerTransformer; | |
/// <summary> | |
/// A Delegate that is called each time a Message is dispatched to allow the client to do | |
/// any necessary transformations on the received message before it is delivered. The | |
/// ConnectionFactory sets the provided delegate instance on each Connection instance that | |
/// is created from this factory, each connection in turn passes the delegate along to each | |
/// Session it creates which then passes that along to the Consumers it creates. | |
/// </summary> | |
public ConsumerTransformerDelegate ConsumerTransformer | |
{ | |
get { return this.consumerTransformer; } | |
set { this.consumerTransformer = value; } | |
} | |
private ProducerTransformerDelegate producerTransformer; | |
/// <summary> | |
/// A delegate that is called each time a Message is sent from this Producer which allows | |
/// the application to perform any needed transformations on the Message before it is sent. | |
/// The ConnectionFactory sets the provided delegate instance on each Connection instance that | |
/// is created from this factory, each connection in turn passes the delegate along to each | |
/// Session it creates which then passes that along to the Producers it creates. | |
/// </summary> | |
public ProducerTransformerDelegate ProducerTransformer | |
{ | |
get { return this.producerTransformer; } | |
set { this.producerTransformer = value; } | |
} | |
#endregion | |
} | |
} |