internal void StopChannelCore(WsChannel wsChannel, ChannelStopMode action, bool setInactive)
{
RetryOnHCONNError(() =>
{
var request = _messageAgent.NewRequest(MQC.MQCMD_STOP_CHANNEL);
request.AddParameter(MQC.MQCACH_CHANNEL_NAME, wsChannel.Name);
int mode = MQC.MQMODE_QUIESCE;
switch (action)
{
case ChannelStopMode.Force:
mode = MQC.MQMODE_FORCE;
break;
case ChannelStopMode.Terminate:
mode = MQC.MQMODE_TERMINATE;
break;
default:
mode = MQC.MQMODE_QUIESCE;
break;
}
request.AddParameter(MQC.MQIACF_MODE, mode);
if (setInactive)
{
request.AddParameter(MQC.MQIACH_CHANNEL_STATUS, MQC.MQCHS_INACTIVE);
}
_messageAgent.Send(request);
});
}
internal void StartChannelCore(WsChannel wsChannel)
{
RetryOnHCONNError(() =>
{
var request = _messageAgent.NewRequest(MQC.MQCMD_START_CHANNEL);
request.AddParameter(MQC.MQCACH_CHANNEL_NAME, wsChannel.Name);
_messageAgent.Send(request);
});
}
internal void ResolveChannelCore(WsChannel wsChannel, bool commit)
{
RetryOnHCONNError(() =>
{
var request = _messageAgent.NewRequest(MQC.MQCMD_RESOLVE_CHANNEL);
request.AddParameter(MQC.MQCACH_CHANNEL_NAME, wsChannel.Name);
request.AddParameter(MQC.MQIACH_IN_DOUBT, commit ? MQC.MQIDO_COMMIT : MQC.MQIDO_BACKOUT);
_messageAgent.Send(request);
});
}
internal void ResetChannelCore(WsChannel wsChannel, int msgSequenceNumber)
{
RetryOnHCONNError(() =>
{
var request = _messageAgent.NewRequest(MQC.MQCMD_RESET_CHANNEL);
request.AddParameter(MQC.MQCACH_CHANNEL_NAME, wsChannel.Name);
request.AddParameter(MQC.MQIACH_MSG_SEQUENCE_NUMBER, msgSequenceNumber);
_messageAgent.Send(request);
});
}
public IChannel OpenChannel(string channelName, bool autoLoadInfo = false)
{
if (string.IsNullOrEmpty(channelName))
{
throw new ArgumentNullException(nameof(channelName));
}
try
{
var c = new WsChannel(this, channelName);
if (autoLoadInfo)
{
c.RefreshInfo();
}
return(c);
}
catch (MQException ibmEx)
{
throw ibmEx.ToMqException(AddExtraInfoToError);
}
}
internal void RefreshChannelInfosCore(WsChannel wsChannel)
{
wsChannel.Type = WsChannelType.Unknown;
wsChannel.ConnectionName = null;
wsChannel.TransmissionQueue = null;
wsChannel.Status = null;
wsChannel.IndoubtStatus = null;
RetryOnHCONNError(() =>
{
if (WsSoftwareInfo.AvoidPCFWhenPossible == false)
{
var msg = _messageAgent.NewRequest(MQC.MQCMD_INQUIRE_CHANNEL);
msg.AddParameter(MQC.MQCACH_CHANNEL_NAME, wsChannel.Name);
msg.AddParameter(CMQCFC.MQIACF_CHANNEL_ATTRS, new[]
{
CMQCFC.MQCACH_CHANNEL_NAME,
MQC.MQIACH_CHANNEL_TYPE,
CMQCFC.MQCACH_CONNECTION_NAME,
CMQCFC.MQCACH_XMIT_Q_NAME
});
PCF.PcfMessage[] response;
if (_messageAgent.TrySend(msg, out response))
{
bool readXmitQ = false;
bool readConnName = false;
var qType = response[0].GetIntParameterValue(MQC.MQIACH_CHANNEL_TYPE);
wsChannel.ChannelTypeCore = qType;
switch (qType)
{
case MQC.MQCHT_AMQP:
wsChannel.Type = WsChannelType.Amqp;
break;
case MQC.MQCHT_CLNTCONN:
wsChannel.Type = WsChannelType.ClientConnection;
break;
case MQC.MQCHT_CLUSRCVR:
wsChannel.Type = WsChannelType.ClusterReceiver;
readConnName = true;
break;
case MQC.MQCHT_CLUSSDR:
wsChannel.Type = WsChannelType.ClusterSender;
readConnName = true;
break;
case MQC.MQCHT_REQUESTER:
wsChannel.Type = WsChannelType.Requester;
readConnName = true;
break;
case MQC.MQCHT_RECEIVER:
wsChannel.Type = WsChannelType.Receiver;
break;
case MQC.MQCHT_SENDER:
wsChannel.Type = WsChannelType.Sender;
readConnName = true;
readXmitQ = true;
break;
case MQC.MQCHT_SERVER:
wsChannel.Type = WsChannelType.Server;
readConnName = true;
readXmitQ = true;
break;
case MQC.MQCHT_SVRCONN:
wsChannel.Type = WsChannelType.ServerConnection;
break;
default:
wsChannel.Type = WsChannelType.Unknown;
break;
}
if (readConnName)
{
wsChannel.ConnectionName = response[0].GetStringParameterValue(CMQCFC.MQCACH_CONNECTION_NAME);
}
if (readXmitQ)
{
wsChannel.TransmissionQueue = response[0].GetStringParameterValue(CMQCFC.MQCACH_XMIT_Q_NAME);
}
}
else
{
return;
}
if (wsChannel.Type != WsChannelType.Unknown)
{
var msg2 = _messageAgent.NewRequest(MQC.MQCMD_INQUIRE_CHANNEL_STATUS);
msg2.AddParameter(MQC.MQCACH_CHANNEL_NAME, wsChannel.Name);
msg2.AddParameter(CMQCFC.MQIACH_CHANNEL_INSTANCE_TYPE, MQC.MQOT_CURRENT_CHANNEL);
msg2.AddParameter(CMQCFC.MQIACH_CHANNEL_INSTANCE_ATTRS, new[]
{
CMQCFC.MQCACH_CHANNEL_NAME,
CMQCFC.MQIACH_MSGS,
CMQCFC.MQCACH_LAST_MSG_DATE,
CMQCFC.MQCACH_LAST_MSG_TIME,
CMQCFC.MQIACH_CHANNEL_STATUS,
CMQCFC.MQIACH_INDOUBT_STATUS
});
PCF.PcfMessage[] response2;
if (_messageAgent.TrySend(msg2, out response2))
{
int chlStatus;
if (response2[0].TryGetIntParameterValue(CMQCFC.MQIACH_CHANNEL_STATUS, out chlStatus))
{
switch (chlStatus)
{
case MQC.MQCHS_BINDING:
wsChannel.Status = ChannelStatus.Binding;
break;
case MQC.MQCHS_DISCONNECTED:
wsChannel.Status = ChannelStatus.Disconnected;
break;
case MQC.MQCHS_INACTIVE:
wsChannel.Status = ChannelStatus.Inactive;
break;
case MQC.MQCHS_INITIALIZING:
wsChannel.Status = ChannelStatus.Initializing;
break;
case MQC.MQCHS_PAUSED:
wsChannel.Status = ChannelStatus.Paused;
break;
case MQC.MQCHS_REQUESTING:
wsChannel.Status = ChannelStatus.Requesting;
break;
case MQC.MQCHS_RETRYING:
wsChannel.Status = ChannelStatus.Retrying;
break;
case MQC.MQCHS_RUNNING:
wsChannel.Status = ChannelStatus.Running;
break;
case MQC.MQCHS_STARTING:
wsChannel.Status = ChannelStatus.Starting;
break;
case MQC.MQCHS_STOPPED:
wsChannel.Status = ChannelStatus.Stopped;
break;
case MQC.MQCHS_STOPPING:
wsChannel.Status = ChannelStatus.Stopping;
break;
case MQC.MQCHS_SWITCHING:
wsChannel.Status = ChannelStatus.Switching;
break;
}
}
int indoubtStatus;
if (response2[0].TryGetIntParameterValue(CMQCFC.MQIACH_INDOUBT_STATUS, out indoubtStatus))
{
wsChannel.IndoubtStatus = indoubtStatus == 0 ? false : true;
}
}
else
{
wsChannel.Status = ChannelStatus.Inactive;
}
}
}
});
}
