def execute(cmd, args, service_name, wait):
"""
Execute an arbitrary command.
\b
Examples:
python punch-q.py command execute -c /bin/ping -a "-c 1 192.168.0.1"
python punch-q.py -C pq.yml command execute --cmd "/bin/ping" --args "-c 5 192.168.0.8" --wait 8
"""
# Generate a service name if none was provided
if not service_name:
service_name = uuid.uuid4()
# Cleanup the service name to remove spaces and dashes and limit to 16 chars
service_name = str(service_name).replace('-', '').replace(' ', '')[0:16]
# information
click.secho('Cmd: {0}'.format(cmd), bold=True)
click.secho('Arg: {0}'.format(args), bold=True)
click.secho('Service Name: {0}\n'.format(service_name))
qmgr = pymqi.connect(mqstate.qm_name, mqstate.channel, mqstate.get_host(),
mqstate.username, mqstate.password)
# create the service
click.secho('Creating service...', dim=True)
args = {
pymqi.CMQC.MQCA_SERVICE_NAME: service_name,
pymqi.CMQC.MQIA_SERVICE_CONTROL: pymqi.CMQC.MQSVC_CONTROL_MANUAL,
pymqi.CMQC.MQIA_SERVICE_TYPE: pymqi.CMQC.MQSVC_TYPE_COMMAND,
pymqi.CMQC.MQCA_SERVICE_START_COMMAND: str(cmd),
pymqi.CMQC.MQCA_SERVICE_START_ARGS: str(args)
}
pcf = pymqi.PCFExecute(qmgr)
pcf.MQCMD_CREATE_SERVICE(args)
# start the service
click.secho('Starting service...', fg='green')
args = {pymqi.CMQC.MQCA_SERVICE_NAME: service_name}
pcf = pymqi.PCFExecute(qmgr)
pcf.MQCMD_START_SERVICE(args)
click.secho('Giving the service {0} second(s) to live...'.format(wait),
dim=True)
time.sleep(wait)
# delete service
click.secho('Cleaning up service...', dim=True)
args = {pymqi.CMQC.MQCA_SERVICE_NAME: service_name}
pcf = pymqi.PCFExecute(qmgr)
pcf.MQCMD_DELETE_SERVICE(args)
qmgr.disconnect()
click.secho('Done', fg='green')
def get_metrics_channels(self):
with self.query_qmgr() as conn:
args = {
CMQCFC.MQCACH_CHANNEL_NAME: '*',
}
channel_metrics = {
'CMQCFC.MQCMD_INQUIRE_CHANNEL_STATUS': {
CMQCFC.MQIACH_CHANNEL_STATUS: {
'key': 'channelStatus'
},
CMQCFC.MQIACH_MSGS: {
'key': 'channelMessages'
},
CMQCFC.MQIACH_BYTES_SENT: {
'key': 'channelBytesSent'
},
CMQCFC.MQIACH_BYTES_RECEIVED: {
'key': 'channelBytesReceived'
},
CMQCFC.MQIACH_BUFFERS_SENT: {
'key': 'channelBuffersSent'
},
CMQCFC.MQIACH_BUFFERS_RECEIVED: {
'key': 'channelBuffersReceived'
},
CMQCFC.MQCACH_LAST_MSG_DATE: {
'key': 'channelLastMsgDate'
},
CMQCFC.MQCACH_LAST_MSG_TIME: {
'key': 'channelLastMsgTime'
},
CMQCFC.MQIACH_CURRENT_SHARING_CONVS: {
'key': 'channelCurrentSharingConvs'
},
},
}
local_metrics = []
for command in channel_metrics:
for channel in getattr(pymqi.PCFExecute(conn), command)(args):
channel_name = channel[CMQCFC.MQCACH_CHANNEL_NAME].strip()
for attribute, properties in channel_metrics[
command].items():
if attribute in channel.keys():
local_metrics.append({
'key': properties["key"],
'value': channel[attribute],
'dimensions': {
'Channel': channel_name
},
'type': 'absolute'
})
with self.lock:
self.metrics_to_report.extend(local_metrics)
def delete_queue(self, sub_desc, queue_name):
# must be unmanaged
if not sub_desc["Options"] & pymqi.CMQC.MQSO_MANAGED:
pcf = pymqi.PCFExecute(self.qmgr)
args = {pymqi.CMQC.MQCA_Q_NAME: utils.py3str2bytes(queue_name),
pymqi.CMQCFC.MQIACF_PURGE: pymqi.CMQCFC.MQPO_YES}
pcf.MQCMD_DELETE_Q(args)
def get_metrics_queue_managers(self):
with self.query_qmgr() as conn:
queue_manager_metrics = {
'CMQCFC.MQCMD_INQUIRE_Q_MGR_STATUS': {
CMQCFC.MQIACF_Q_MGR_STATUS: {
'key': 'queueManagerStatus'
},
CMQCFC.MQIACF_CONNECTION_COUNT: {
'key': 'queueManagerConnections'
},
},
}
local_metrics = []
for command in queue_manager_metrics:
for queue_manager in getattr(pymqi.PCFExecute(conn),
command)():
for attribute, properties in queue_manager_metrics[
command].items():
if attribute in queue_manager.keys():
local_metrics.append({
'key':
properties["key"],
'value':
queue_manager[attribute],
'type':
'absolute'
})
with self.lock:
self.metrics_to_report.extend(local_metrics)
def _submit_channel_status(self, queue_manager, search_channel_name, tags,
config):
"""Submit channel status
:param search_channel_name might contain wildcard characters
"""
search_channel_tags = tags + ["channel:{}".format(search_channel_name)]
try:
args = {
pymqi.CMQCFC.MQCACH_CHANNEL_NAME:
ensure_bytes(search_channel_name)
}
pcf = pymqi.PCFExecute(queue_manager)
response = pcf.MQCMD_INQUIRE_CHANNEL_STATUS(args)
self.service_check(self.CHANNEL_SERVICE_CHECK, AgentCheck.OK,
search_channel_tags)
except pymqi.MQMIError as e:
self.log.warning("Error getting CHANNEL stats {}".format(e))
self.service_check(self.CHANNEL_SERVICE_CHECK, AgentCheck.CRITICAL,
search_channel_tags)
else:
for channel_info in response:
channel_name = ensure_unicode(
channel_info[pymqi.CMQCFC.MQCACH_CHANNEL_NAME]).strip()
channel_tags = tags + ["channel:{}".format(channel_name)]
channel_status = channel_info[
pymqi.CMQCFC.MQIACH_CHANNEL_STATUS]
self._submit_channel_count(channel_name, channel_status,
channel_tags)
self._submit_status_check(channel_name, channel_status,
channel_tags, config)
def setUpClass(cls):
"""Initialize test environment."""
cls.prefix = os.environ.get('PYMQI_TEST_OBJECT_PREFIX', 'PYMQI.')
# max length of queue names is 48 characters
cls.queue_name = '{prefix}MSG.QUEUE'.format(prefix=config.MQ.QUEUE.PREFIX)
cls.queue_manager = config.MQ.QM.NAME
cls.channel = config.MQ.QM.CHANNEL
cls.host = config.MQ.QM.HOST
cls.port = config.MQ.QM.PORT
cls.user = config.MQ.QM.USER
cls.password = config.MQ.QM.PASSWORD
cls.conn_info = '{0}({1})'.format(cls.host, cls.port)
if pymqi.__mqbuild__ == 'server':
cls.qmgr = pymqi.QueueManager(cls.queue_manager)
else:
cls.qmgr = pymqi.QueueManager(None)
cls.qmgr.connectTCPClient(cls.queue_manager, pymqi.CD(), cls.channel,
cls.conn_info, cls.user, cls.password)
cls.pcf = pymqi.PCFExecute(cls.qmgr, response_wait_interval=15000)
cls.version = cls.inquire_qmgr_version().decode()
def get_pcf_channel_metrics(self, queue_manager, tags, config):
args = {pymqi.CMQCFC.MQCACH_CHANNEL_NAME: ensure_bytes('*')}
try:
pcf = pymqi.PCFExecute(queue_manager)
response = pcf.MQCMD_INQUIRE_CHANNEL(args)
except pymqi.MQMIError as e:
self.log.warning("Error getting CHANNEL stats %s", e)
else:
channels = len(response)
mname = '{}.channel.channels'.format(self.METRIC_PREFIX)
self.gauge(mname, channels, tags=tags)
for channel_info in response:
channel_name = ensure_unicode(channel_info[pymqi.CMQCFC.MQCACH_CHANNEL_NAME]).strip()
channel_tags = tags + ["channel:{}".format(channel_name)]
self._submit_metrics_from_properties(channel_info, metrics.channel_metrics(), channel_tags)
# Check specific channels
# If a channel is not discoverable, a user may want to check it specifically.
# Specific channels are checked first to send channel metrics and `ibm_mq.channel` service checks
# at the same time, but the end result is the same in any order.
for channel in config.channels:
self._submit_channel_status(queue_manager, channel, tags, config)
# Grab all the discoverable channels
self._submit_channel_status(queue_manager, '*', tags, config, config.channels)
def get_pcf_queue_status_metrics(self, queue_manager, queue_name, tags):
try:
args = {
pymqi.CMQC.MQCA_Q_NAME: pymqi.ensure_bytes(queue_name),
pymqi.CMQC.MQIA_Q_TYPE: pymqi.CMQC.MQQT_ALL,
pymqi.CMQCFC.MQIACF_Q_STATUS_ATTRS: pymqi.CMQCFC.MQIACF_ALL,
}
pcf = pymqi.PCFExecute(queue_manager, convert=self.config.convert_endianness)
response = pcf.MQCMD_INQUIRE_Q_STATUS(args)
except pymqi.MQMIError as e:
# Don't warn if no messages, see:
# https://github.com/dsuch/pymqi/blob/v1.12.0/docs/examples.rst#how-to-wait-for-multiple-messages
if not (e.comp == pymqi.CMQC.MQCC_FAILED and e.reason == pymqi.CMQC.MQRC_NO_MSG_AVAILABLE):
self.warning("Error getting pcf queue stats for %s: %s", queue_name, e)
else:
# Response is a list. It likely has only one member in it.
for queue_info in response:
for mname, values in iteritems(metrics.pcf_metrics()):
failure_value = values['failure']
pymqi_value = values['pymqi_value']
mname = '{}.queue.{}'.format(metrics.METRIC_PREFIX, mname)
m = int(queue_info[pymqi_value])
if m > failure_value:
self.send_metric(GAUGE, mname, m, tags=tags)
else:
msg = "Unable to get {}, turn on queue level monitoring to access these metrics for {}"
msg = msg.format(mname, queue_name)
self.log.debug(msg)
def delete_queue(self, queue_name):
pcf = pymqi.PCFExecute(self.qmgr)
args = {
pymqi.CMQC.MQCA_Q_NAME: utils.py3str2bytes(queue_name),
pymqi.CMQCFC.MQIACF_PURGE: pymqi.CMQCFC.MQPO_YES
}
pcf.MQCMD_DELETE_Q(args)
def create_process(qmgr, file_loc):
# create process to initiate aut script
app_type = CMQC.MQAT_UNIX
proc_desc = 'Process to run AUT files'
app_id = file_loc
env_data = '&'
pargs = {
CMQC.MQCA_PROCESS_NAME: proc_name,
CMQC.MQCA_PROCESS_DESC: proc_desc,
CMQC.MQIA_APPL_TYPE: app_type,
CMQC.MQCA_APPL_ID: app_id,
CMQC.MQCA_ENV_DATA: env_data
}
try:
pcf = pymqi.PCFExecute(qmgr)
print '! - trying to create process'
pcf.MQCMD_CREATE_PROCESS(pargs)
print ' - process was created'
except pymqi.MQMIError, e:
# need to check for other exceptions as well like queue manager not reachable
if e.comp == CMQC.MQCC_FAILED and e.reason == CMQCFC.MQRCCF_OBJECT_ALREADY_EXISTS:
print ' * process already exists'
print ' - updating process'
try:
print ' ! - trying to update'
pcf.MQCMD_CHANGE_PROCESS(pargs)
print ' - updated'
except pymqi.MQMIError, f:
print ' * did not update process'
print ' - completion code: ', f.comp
print ' - reason code:', f.reason
pass
def setUpClass(cls):
"""Initialize test environment."""
super(TestPCF, cls).setUpClass()
# max length of queue names is 48 characters
cls.queue_name = "{prefix}PCF.QUEUE".format(prefix=cls.prefix)
cls.pcf = pymqi.PCFExecute(cls.qmgr, response_wait_interval=600)
def delete_sub(self, sub_desc):
# can only delete a durable subscription
if sub_desc["Options"] & pymqi.CMQC.MQSO_DURABLE:
subname = sub_desc.get_vs("SubName")
pcf = pymqi.PCFExecute(self.qmgr)
args = {pymqi.CMQCFC.MQCACF_SUB_NAME: subname}
pcf.MQCMD_DELETE_SUBSCRIPTION(args)
def queue_stats(self, queue_manager, queue_name, tags):
"""
Grab stats from queues
"""
pcf = None
try:
args = {pymqi.CMQC.MQCA_Q_NAME: pymqi.ensure_bytes(queue_name), pymqi.CMQC.MQIA_Q_TYPE: pymqi.CMQC.MQQT_ALL}
pcf = pymqi.PCFExecute(
queue_manager, response_wait_interval=self.config.timeout, convert=self.config.convert_endianness
)
response = pcf.MQCMD_INQUIRE_Q(args)
except pymqi.MQMIError as e:
# Don't warn if no messages, see:
# https://github.com/dsuch/pymqi/blob/v1.12.0/docs/examples.rst#how-to-wait-for-multiple-messages
if e.comp == pymqi.CMQC.MQCC_FAILED and e.reason == pymqi.CMQC.MQRC_NO_MSG_AVAILABLE:
self.log.debug("No stat messages available for queue %s", queue_name)
else:
self.warning("Error getting queue stats for %s: %s", queue_name, e)
else:
# Response is a list. It likely has only one member in it.
for queue_info in response:
self._submit_queue_stats(queue_info, queue_name, tags)
finally:
if pcf is not None:
pcf.disconnect()
def get_pcf_queue_status_metrics(self, queue_manager, queue_name, tags):
try:
args = {
pymqi.CMQC.MQCA_Q_NAME: ensure_bytes(queue_name),
pymqi.CMQC.MQIA_Q_TYPE: pymqi.CMQC.MQQT_ALL,
pymqi.CMQCFC.MQIACF_Q_STATUS_ATTRS: pymqi.CMQCFC.MQIACF_ALL,
}
pcf = pymqi.PCFExecute(queue_manager)
response = pcf.MQCMD_INQUIRE_Q_STATUS(args)
except pymqi.MQMIError as e:
self.warning("Error getting pcf queue stats for %s: %s", queue_name, e)
else:
# Response is a list. It likely has only one member in it.
for queue_info in response:
for mname, values in iteritems(metrics.pcf_metrics()):
failure_value = values['failure']
pymqi_value = values['pymqi_value']
mname = '{}.queue.{}'.format(self.METRIC_PREFIX, mname)
m = int(queue_info[pymqi_value])
if m > failure_value:
self.gauge(mname, m, tags=tags)
else:
msg = "Unable to get {}, turn on queue level monitoring to access these metrics for {}"
msg = msg.format(mname, queue_name)
log.debug(msg)
def _submit_channel_status(self, queue_manager, search_channel_name, tags, config, channels_to_skip=None):
"""Submit channel status
Note: Error 3065 (MQRCCF_CHL_STATUS_NOT_FOUND) might indicate that the channel has not been used.
More info: https://www.ibm.com/support/knowledgecenter/SSFKSJ_7.1.0/com.ibm.mq.doc/fm16690_.htm
:param search_channel_name might contain wildcard characters
"""
channels_to_skip = channels_to_skip or []
search_channel_tags = tags + ["channel:{}".format(search_channel_name)]
try:
args = {pymqi.CMQCFC.MQCACH_CHANNEL_NAME: ensure_bytes(search_channel_name)}
pcf = pymqi.PCFExecute(queue_manager)
response = pcf.MQCMD_INQUIRE_CHANNEL_STATUS(args)
self.service_check(self.CHANNEL_SERVICE_CHECK, AgentCheck.OK, search_channel_tags)
except pymqi.MQMIError as e:
self.service_check(self.CHANNEL_SERVICE_CHECK, AgentCheck.CRITICAL, search_channel_tags)
if e.comp == pymqi.CMQC.MQCC_FAILED and e.reason == pymqi.CMQCFC.MQRCCF_CHL_STATUS_NOT_FOUND:
self.log.debug("Channel status not found for channel %s: %s", search_channel_name, e)
else:
self.log.warning("Error getting CHANNEL status for channel %s: %s", search_channel_name, e)
else:
for channel_info in response:
channel_name = ensure_unicode(channel_info[pymqi.CMQCFC.MQCACH_CHANNEL_NAME]).strip()
if channel_name in channels_to_skip:
continue
channel_tags = tags + ["channel:{}".format(channel_name)]
self._submit_metrics_from_properties(channel_info, metrics.channel_status_metrics(), channel_tags)
channel_status = channel_info[pymqi.CMQCFC.MQIACH_CHANNEL_STATUS]
self._submit_channel_count(channel_name, channel_status, channel_tags)
self._submit_status_check(channel_name, channel_status, channel_tags, config)
def test_mq_level(self):
""" We should be connecting to an MQ 8.0+ queue manager.
"""
conn = self.get_conn()
pcf = pymqi.PCFExecute(conn)
command_level = pcf.MQCMD_INQUIRE_Q_MGR()[0][CMQC.MQIA_COMMAND_LEVEL]
self.assertGreaterEqual(command_level, 800)
conn.disconnect()
def create_admin_subscription(self, destination_class, subname, queue_name, topic_string):
pcf = pymqi.PCFExecute(self.qmgr)
args = {pymqi.CMQCFC.MQCACF_SUB_NAME: utils.py3str2bytes(subname),
pymqi.CMQC.MQCA_TOPIC_STRING: utils.py3str2bytes(topic_string),
pymqi.CMQCFC.MQIACF_DESTINATION_CLASS: destination_class}
if destination_class is pymqi.CMQC.MQDC_PROVIDED:
args[pymqi.CMQCFC.MQCACF_DESTINATION] = utils.py3str2bytes(queue_name)
pcf.MQCMD_CREATE_SUBSCRIPTION(args)
def delete_channel(self, channel_name):
"""Delete channel."""
pcf = pymqi.PCFExecute(self.qmgr)
attrs = []
attrs.append(
pymqi.CFST(Parameter=pymqi.CMQCFC.MQCACH_CHANNEL_NAME,
String=utils.py3str2bytes(channel_name)))
pcf.MQCMD_DELETE_CHANNEL(attrs)
def channels(prefix):
"""
Show channels.
"""
mqstate.validate(['host', 'port', 'channel'])
args = {pymqi.CMQCFC.MQCACH_CHANNEL_NAME: str(prefix)}
qmgr = pymqi.connect(mqstate.qm_name, mqstate.channel, mqstate.get_host(),
mqstate.username, mqstate.password)
pcf = pymqi.PCFExecute(qmgr)
try:
click.secho(
'Showing channels with prefix: \'{0}\'...\n'.format(prefix),
dim=True)
response = pcf.MQCMD_INQUIRE_CHANNEL(args)
except pymqi.MQMIError as sce:
if sce.comp == pymqi.CMQC.MQCC_FAILED and sce.reason == pymqi.CMQC.MQRC_UNKNOWN_OBJECT_NAME:
click.secho('No channels matched prefix [%s]'.format(prefix),
fg='red')
else:
raise sce
else:
t = get_table_handle([
'Name',
'Type',
'MCA UID',
'Conn Name',
'Xmit Queue',
'Description',
'SSL Cipher',
])
for channel_info in response:
t.append_row([
channel_info.get(pymqi.CMQCFC.MQCACH_CHANNEL_NAME, '').strip(),
channel_type_to_name(
channel_info.get(pymqi.CMQCFC.MQIACH_CHANNEL_TYPE)),
channel_info.get(pymqi.CMQCFC.MQCACH_MCA_USER_ID, ''),
channel_info.get(pymqi.CMQCFC.MQCACH_CONNECTION_NAME,
'').strip(),
channel_info.get(pymqi.CMQCFC.MQCACH_XMIT_Q_NAME, '').strip(),
channel_info.get(pymqi.CMQCFC.MQCACH_DESC, '').strip(),
# channel_info.get(pymqi.CMQCFC.MQCACH_PASSWORD, '(unknown)').strip(),
channel_info.get(pymqi.CMQCFC.MQCACH_SSL_CIPHER_SPEC,
'').strip(),
# channel_info.get(pymqi.CMQCFC.MQCACH_SSL_PEER_NAME, '').strip(),
])
click.secho(t.get_string())
qmgr.disconnect()
def ping():
"""
Ping a queue manager.
"""
mqstate.validate(['host', 'port'])
qmgr = pymqi.connect(mqstate.qm_name, mqstate.channel, mqstate.get_host(),
mqstate.username, mqstate.password)
pcf = pymqi.PCFExecute(qmgr)
pcf.MQCMD_PING_Q_MGR()
click.secho('Queue manager command server is responsive.', fg='green')
# Attempt to determine the MQ command level.
mq_params = pcf.MQCMD_INQUIRE_Q_MGR(
{pymqi.CMQCFC.MQCMD_INQUIRE_SYSTEM: '*'})
# Get the queue manager status
mq_status = pcf.MQCMD_INQUIRE_Q_MGR_STATUS()[0]
# A number of these are not in CMQC, so this comment is a reference:
# MQCA_INSTALLATION_DESC: 2115
# MQCA_INSTALLATION_NAME: 2116
# MQCA_INSTALLATION_PATH: 2117
# MQCACF_LOG_PATH: 3074
# MQCACF_Q_MGR_START_DATE: 3175
# MQCACF_Q_MGR_START_TIME: 3176
click.secho('Queue Manager Status:', bold=True)
click.secho('---------------------', bold=True)
click.secho('Command Level: {0}'.format(
mq_params[0][pymqi.CMQC.MQIA_COMMAND_LEVEL]),
bold=True)
click.secho('Queue Manager Name: {0}'.format(
mq_status.get(pymqi.CMQC.MQCA_Q_MGR_NAME, '(unknown)')),
bold=True)
click.secho('Installation Name: {0}'.format(
mq_status.get(2116, '(unknown)')),
bold=True)
click.secho('Installation Path: {0}'.format(
mq_status.get(2117, '(unknown)')),
bold=True)
click.secho('Installation Description: {0}'.format(
mq_status.get(2115, '(unknown)')),
bold=True)
click.secho('Log Path: {0}'.format(
mq_status.get(3074, '(unknown)')),
bold=True)
click.secho('Queue Manager Start Time: {0}'.format(' '.join(
[mq_status.get(3175, '').strip(),
mq_status.get(3176, '').strip()])),
bold=True)
click.secho('\n')
click.secho('Successfully queried queue manager status.', fg='green')
qmgr.disconnect()
def create_queue(self, queue_name):
queue_type = pymqi.CMQC.MQQT_LOCAL
max_depth = 123456
args = {pymqi.CMQC.MQCA_Q_NAME: utils.py3str2bytes(queue_name),
pymqi.CMQC.MQIA_Q_TYPE: queue_type,
pymqi.CMQC.MQIA_MAX_Q_DEPTH: max_depth}
pcf = pymqi.PCFExecute(self.qmgr)
pcf.MQCMD_CREATE_Q(args)
def create_channel(self, channel_name, args=None):
if args:
args[pymqi.CMQCFC.MQCACH_CHANNEL_NAME] = utils.py3str2bytes(channel_name)
else:
args = {pymqi.CMQCFC.MQCACH_CHANNEL_NAME: utils.py3str2bytes(channel_name),
pymqi.CMQCFC.MQIACH_CHANNEL_TYPE: pymqi.CMQC.MQCHT_SVRCONN,
pymqi.CMQCFC.MQIACF_REPLACE: pymqi.CMQCFC.MQRP_YES}
pcf = pymqi.PCFExecute(self.qmgr)
pcf.MQCMD_CREATE_CHANNEL(args)
def create_queue(self, queue_name, max_depth=5000, args=None):
if args:
args[pymqi.CMQC.MQCA_Q_NAME] = utils.py3str2bytes(queue_name)
else:
args = {pymqi.CMQC.MQCA_Q_NAME: utils.py3str2bytes(queue_name),
pymqi.CMQC.MQIA_Q_TYPE: pymqi.CMQC.MQQT_LOCAL,
pymqi.CMQC.MQIA_MAX_Q_DEPTH: max_depth,
pymqi.CMQCFC.MQIACF_REPLACE: pymqi.CMQCFC.MQRP_YES}
pcf = pymqi.PCFExecute(self.qmgr)
pcf.MQCMD_CREATE_Q(args)
def query_qmgr():
global qmgr, pcf
queue_manager = "QM01"
channel = "CHANNEL.1"
host = "127.0.0.1"
port = "1434"
conn_info = "%s(%s)" % (host, port)
qmgr = pymqi.connect(queue_manager, channel, conn_info)
pcf = pymqi.PCFExecute(qmgr)
query_func()
qmgr.disconnect()
def delete_queue(self, queue_name):
"""Delete queue."""
pcf = pymqi.PCFExecute(self.qmgr)
attrs = []
attrs.append(
pymqi.CFST(Parameter=pymqi.CMQC.MQCA_Q_NAME,
String=utils.py3str2bytes(queue_name)))
attrs.append(
pymqi.CFIN(Parameter=pymqi.CMQCFC.MQIACF_PURGE,
Value=pymqi.CMQCFC.MQPO_YES))
pcf.MQCMD_DELETE_Q(attrs)
def create_queue(self, queue_name):
queue_type = pymqi.CMQC.MQQT_LOCAL
max_depth = 5000
args = {pymqi.CMQC.MQCA_Q_NAME: utils.py3str2bytes(queue_name),
pymqi.CMQC.MQIA_Q_TYPE: queue_type,
pymqi.CMQC.MQIA_MAX_Q_DEPTH: max_depth,
pymqi.CMQCFC.MQIACF_REPLACE: pymqi.CMQCFC.MQRP_YES}
pcf = pymqi.PCFExecute(self.qmgr)
pcf.MQCMD_CREATE_Q(args)
pcf.disconnect
def _submit_channel_status(self, queue_manager, search_channel_name, tags, channels_to_skip=None):
"""Submit channel status
Note: Error 3065 (MQRCCF_CHL_STATUS_NOT_FOUND) might indicate that the channel has not been used.
More info: https://www.ibm.com/support/knowledgecenter/SSFKSJ_7.1.0/com.ibm.mq.doc/fm16690_.htm
:param search_channel_name might contain wildcard characters
"""
channels_to_skip = channels_to_skip or []
search_channel_tags = tags + ["channel:{}".format(search_channel_name)]
pcf = None
try:
args = {pymqi.CMQCFC.MQCACH_CHANNEL_NAME: pymqi.ensure_bytes(search_channel_name)}
pcf = pymqi.PCFExecute(
queue_manager, response_wait_interval=self.config.timeout, convert=self.config.convert_endianness
)
response = pcf.MQCMD_INQUIRE_CHANNEL_STATUS(args)
self.service_check(
self.CHANNEL_SERVICE_CHECK, AgentCheck.OK, search_channel_tags, hostname=self.config.hostname
)
except pymqi.MQMIError as e:
if e.comp == pymqi.CMQC.MQCC_FAILED and e.reason == pymqi.CMQCFC.MQRCCF_CHL_STATUS_NOT_FOUND:
self.service_check(
self.CHANNEL_SERVICE_CHECK, AgentCheck.CRITICAL, search_channel_tags, hostname=self.config.hostname
)
self.log.debug("Channel status not found for channel %s: %s", search_channel_name, e)
elif e.comp == pymqi.CMQC.MQCC_FAILED and e.reason == pymqi.CMQC.MQRC_NO_MSG_AVAILABLE:
self.service_check(
self.CHANNEL_SERVICE_CHECK, AgentCheck.UNKNOWN, search_channel_tags, hostname=self.config.hostname
)
self.log.debug("There are no messages available for channel %s", search_channel_name)
else:
self.service_check(
self.CHANNEL_SERVICE_CHECK, AgentCheck.CRITICAL, search_channel_tags, hostname=self.config.hostname
)
self.log.warning("Error getting CHANNEL status for channel %s: %s", search_channel_name, e)
else:
for channel_info in response:
channel_name = to_string(channel_info[pymqi.CMQCFC.MQCACH_CHANNEL_NAME]).strip()
if channel_name in channels_to_skip:
continue
channel_tags = tags + ["channel:{}".format(channel_name)]
self._submit_metrics_from_properties(
channel_info, channel_name, metrics.channel_status_metrics(), channel_tags
)
channel_status = channel_info[pymqi.CMQCFC.MQIACH_CHANNEL_STATUS]
self._submit_channel_count(channel_name, channel_status, channel_tags)
self._submit_status_check(channel_name, channel_status, channel_tags)
finally:
if pcf is not None:
pcf.disconnect()
def get_pcf_queue_status_metrics(self, queue_manager, queue_name, tags):
pcf = None
try:
args = {
pymqi.CMQC.MQCA_Q_NAME: pymqi.ensure_bytes(queue_name),
pymqi.CMQC.MQIA_Q_TYPE: pymqi.CMQC.MQQT_ALL,
pymqi.CMQCFC.MQIACF_Q_STATUS_ATTRS: pymqi.CMQCFC.MQIACF_ALL,
}
pcf = pymqi.PCFExecute(
queue_manager, response_wait_interval=self.config.timeout, convert=self.config.convert_endianness
)
response = pcf.MQCMD_INQUIRE_Q_STATUS(args)
except pymqi.MQMIError as e:
# Don't warn if no messages, see:
# https://github.com/dsuch/pymqi/blob/v1.12.0/docs/examples.rst#how-to-wait-for-multiple-messages
if e.comp == pymqi.CMQC.MQCC_FAILED and e.reason == pymqi.CMQC.MQRC_NO_MSG_AVAILABLE:
self.log.debug("No PCF queue status messages available for queue %s", queue_name)
else:
self.warning("Error getting pcf queue status for %s: %s", queue_name, e)
else:
# Response is a list. It likely has only one member in it.
for queue_info in response:
for mname, values in iteritems(metrics.pcf_metrics()):
metric_name = '{}.queue.{}'.format(metrics.METRIC_PREFIX, mname)
try:
if callable(values):
metric_value = values(self.config.qm_timezone, queue_info)
if metric_value is not None:
self.send_metric(GAUGE, metric_name, metric_value, tags=tags)
else:
msg = """
Unable to get %s. Turn on queue level monitoring to access these metrics for %s.
Check `DISPLAY QSTATUS(%s) MONITOR`.
"""
self.log.debug(msg, metric_name, queue_name, queue_name)
else:
failure_value = values['failure']
pymqi_value = values['pymqi_value']
metric_value = int(queue_info.get(pymqi_value, None))
if metric_value > failure_value:
self.send_metric(GAUGE, metric_name, metric_value, tags=tags)
else:
msg = "Unable to get {}, turn on queue level monitoring to access these metrics for {}"
msg = msg.format(metric_name, queue_name)
self.log.debug(msg)
except Exception as e:
msg = "Unable to get metric {} from queue {}. Error is {}.".format(metric_name, queue_name, e)
self.log.warning(msg)
finally:
if pcf is not None:
pcf.disconnect()
def get_pcf_queue_reset_metrics(self, queue_manager, queue_name, tags):
try:
args = {pymqi.CMQC.MQCA_Q_NAME: pymqi.ensure_bytes(queue_name)}
pcf = pymqi.PCFExecute(queue_manager, convert=self.config.convert_endianness)
response = pcf.MQCMD_RESET_Q_STATS(args)
except pymqi.MQMIError as e:
self.warning("Error getting pcf queue stats for %s: %s", queue_name, e)
else:
# Response is a list. It likely has only one member in it.
for queue_info in response:
metrics_map = metrics.pcf_status_reset_metrics()
prefix = "{}.queue".format(metrics.METRIC_PREFIX)
self.send_metrics_from_properties(queue_info, metrics_map, prefix, tags)
def get_pcf_queue_reset_metrics(self, queue_manager, queue_name, tags):
try:
args = {pymqi.CMQC.MQCA_Q_NAME: ensure_bytes(queue_name)}
pcf = pymqi.PCFExecute(queue_manager)
response = pcf.MQCMD_RESET_Q_STATS(args)
except pymqi.MQMIError as e:
self.warning("Error getting pcf queue stats for %s: %s", queue_name, e)
else:
# Response is a list. It likely has only one member in it.
for queue_info in response:
for metric_name, (pymqi_type, metric_type) in iteritems(metrics.pcf_status_reset_metrics()):
metric_full_name = '{}.queue.{}'.format(self.METRIC_PREFIX, metric_name)
metric_value = int(queue_info[pymqi_type])
self._send_metric(metric_type, metric_full_name, metric_value, tags)
