def setUp(self): """ Create a new queue manager (TESTPMQI). Must be run as a user that has 'mqm' access. """ self.single_rfh2_message = \ open("messages/single_rfh2.dat", "rb").read() self.single_rfh2_message_not_well_formed = \ self.single_rfh2_message[0:117] + self.single_rfh2_message[121:] self.multiple_rfh2_message = \ open("messages/multiple_rfh2.dat", "rb").read() self.multiple_rfh2_message_not_well_formed = \ self.multiple_rfh2_message[0:117] + self.multiple_rfh2_message[121:] queue_manager = "QM01" channel = "SVRCONN.1" socket = "localhost(31414)" queue_name = "RFH2.TEST" self.qmgr = None try: if pymqi.__mqbuild__ == 'server': self.qmgr = pymqi.QueueManager('QM01') else: self.qmgr = pymqi.QueueManager(None) self.qmgr.connectTCPClient(queue_manager, pymqi.cd(), channel, socket) self.put_queue = pymqi.Queue(self.qmgr, queue_name) self.get_queue = pymqi.Queue(self.qmgr, queue_name) self.clear_queue(self.get_queue) except Exception as e: raise e
def setUp(self): """ Create a new queue manager (TESTPMQI). Must be run as a user that has 'mqm' access. """ self.single_rfh2_message = open( os.path.join(self.messages_dir, "single_rfh2.dat"), "rb").read() self.single_rfh2_message_not_well_formed = \ self.single_rfh2_message[0:117] + self.single_rfh2_message[121:] self.multiple_rfh2_message = open( os.path.join(self.messages_dir, "multiple_rfh2.dat"), "rb").read() self.multiple_rfh2_message_not_well_formed = \ self.multiple_rfh2_message[0:117] + self.multiple_rfh2_message[121:] queue_manager = config.MQ.QM.NAME channel = config.MQ.QM.CHANNEL conn_info = "%s(%s)" % (config.MQ.QM.HOST, config.MQ.QM.PORT) queue_name = config.MQ.QUEUE.QUEUE_NAMES['TestRFH2PutGet'] self.qmgr = None if pymqi.__mqbuild__ == 'server': self.qmgr = pymqi.QueueManager(queue_manager) else: self.qmgr = pymqi.QueueManager(None) self.qmgr.connect_tcp_client(queue_manager, pymqi.cd(), channel, conn_info, user=config.MQ.QM.USER, password=config.MQ.QM.PASSWORD) self.put_queue = pymqi.Queue(self.qmgr, queue_name) self.get_queue = pymqi.Queue(self.qmgr, queue_name) self.clear_queue(self.get_queue)
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 connect(): logger.info('Establising Connection with MQ Server') try: cd = pymqi.CD() cd.ChannelName = MQDetails['CHANNEL'] cd.ConnectionName = conn_info cd.ChannelType = pymqi.CMQC.MQCHT_CLNTCONN cd.TransportType = pymqi.CMQC.MQXPT_TCP # Create an empty SCO object, and optionally set TLS settings # if a cipher is set in the envrionment variables. sco = pymqi.SCO() if MQDetails['CIPHER']: cd.SSLCipherSpec = MQDetails['CIPHER'] sco.KeyRepository = MQDetails['KEY_REPOSITORY'] #options = pymqi.CMQC.MQPMO_NO_SYNCPOINT | pymqi.CMQC.MQPMO_NEW_MSG_ID | pymqi.CMQC.MQPMO_NEW_CORREL_ID options = pymqi.CMQC.MQPMO_NEW_CORREL_ID qmgr = pymqi.QueueManager(None) qmgr.connect_with_options(MQDetails['QMGR'], user=credentials['USER'], password=credentials['PASSWORD'], opts=options, cd=cd, sco=sco) return qmgr except pymqi.MQMIError as e: logger.error("Error connecting") logger.error(e) return None
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) cls.qmgr = pymqi.QueueManager(None) try: cls.qmgr.connectTCPClient(cls.queue_manager, pymqi.CD(), cls.channel, cls.conn_info, cls.user, cls.password) except pymqi.MQMIError as ex: if ex.comp == pymqi.CMQC.MQCC_FAILED: raise ex cls.version = cls.inquire_qmgr_version().decode()
def setUp(self): self.msg_prop_name = b"test_name" self.msg_prop_value_str = "test_valuetest_valuetest_valuetest_valuetest_value" self.msg_prop_value_bytes = b"test_valuetest_valuetest_valuetest_valuetest_value" self.msg_prop_value_bool = True self.msg_prop_value_int8 = -127 self.msg_prop_value_int16 = -32768 self.msg_prop_value_int32 = -2147483647 self.msg_prop_value_int64 = -9223372036854775808 self.msg_prop_value_float32 = 1.1754943508222875e-38 self.msg_prop_value_float64 = 2.2250738585072014e-308 # max length of queue names is 48 characters self.queue_name = "{prefix}MSG.PROP.QUEUE".format( prefix=config.MQ.QUEUE.PREFIX) self.queue_manager = config.MQ.QM.NAME self.channel = config.MQ.QM.CHANNEL self.host = config.MQ.QM.HOST self.port = config.MQ.QM.PORT self.user = config.MQ.QM.USER self.password = config.MQ.QM.PASSWORD self.conn_info = "{0}({1})".format(self.host, self.port) self.qmgr = pymqi.QueueManager(None) self.qmgr.connectTCPClient(self.queue_manager, pymqi.CD(), self.channel, self.conn_info, self.user, self.password) self.create_queue(self.queue_name)
def connect(): global qmgr conn_info = '%s(%s)' % (args.host, args.port) if (not args.use_client_auth and not args.use_ssl): qmgr = pymqi.connect(args.queue_manager, args.channel, conn_info) elif (args.use_client_auth and not args.use_ssl): qmgr = pymqi.connect(args.queue_manager, args.channel, conn_info, args.username, args.password) elif (args.use_ssl): cd = pymqi.CD() cd.ChannelName = bytes(args.channel, encoding='utf8') cd.ConnectionName = bytes(conn_info, encoding='utf8') cd.ChannelType = pymqi.CMQC.MQCHT_CLNTCONN cd.TransportType = pymqi.CMQC.MQXPT_TCP cd.SSLCipherSpec = bytes(args.cipherspec, encoding='utf8') sco = pymqi.SCO() sco.KeyRepository = bytes(args.server_cert, encoding='utf8') qmgr = pymqi.QueueManager(None) if (not args.use_client_auth): qmgr.connect_with_options(args.queue_manager, cd=cd, sco=sco) else: qmgr.connect_with_options(args.queue_manager, cd=cd, sco=sco, user=bytes(args.username, encoding='utf8'), password=bytes(args.password, encoding='utf8')) print("connection succesful")
def test_connection_with_tls(self): """Test connection to QueueManager with TLS.""" qmgr = pymqi.QueueManager(None) conn_info = pymqi.ensure_bytes('{0}({1})'.format(self.host, self.port)) cd = pymqi.CD( Version=pymqi.CMQXC.MQCD_VERSION_7, # pylint: disable=C0103 ChannelName=self.tls_channel_name, ConnectionName=conn_info, SSLCipherSpec=self.cypher_spec) sco = pymqi.SCO(Version=pymqi.CMQC.MQSCO_VERSION_5, KeyRepository=os.path.join( self.key_repo_location_client, self.certificate_label_client), CertificateLabel=self.certificate_label_client) opts = pymqi.CMQC.MQCNO_HANDLE_SHARE_NO_BLOCK qmgr.connectWithOptions(self.queue_manager, cd, sco, opts=opts, user=self.user, password=self.password) is_connected = qmgr.is_connected if is_connected: qmgr.disconnect() self.assertTrue(is_connected)
def main(): qmgr = pymqi.QueueManager() sub = pymqi.Subscription(qmgr) sd = pymqi.SD(Options=CMQC.MQSO_CREATE | CMQC.MQSO_RESUME | CMQC.MQSO_MANAGED | CMQC.MQSO_DURABLE) sd.set_vs('SubName', 'rtExistingTopic') sd.set_vs('ObjectString', 'RT.EXISTING_SECURITY.QA') sub.sub(sd) try: while not run.isSet(): msg = getMessage(sub, syncpoint=True) if msg: try: --%CHANGE HERE% qmgr.commit() except Exception, e: qmgr.backout() raise finally: sub.close(sub_close_options=CMQC.MQCO_KEEP_SUB, close_sub_queue=True) qmgr.disconnect()
def setUp(self): self.topic_string_template = "/UNITTEST/{prefix}/PUBSUB/{{type}}/{{destination}}/{{durable}}".format( prefix=config.MQ.QUEUE.PREFIX) self.subname_template = "{prefix}'s {{type}} {{destination}} {{durable}} Subscription".format( prefix=config.MQ.QUEUE.PREFIX) self.msg_template = "Hello World in the topic string \"{{topic_string}}\"".format( ) # max length of queue names is 48 characters self.queue_name_template = "{prefix}_Q_TEST_PUBSUB_{{type}}_PROVIDED_{{durable}}".format( prefix=config.MQ.QUEUE.PREFIX) self.queue_manager = config.MQ.QM.NAME self.channel = config.MQ.QM.CHANNEL self.host = config.MQ.QM.HOST self.port = config.MQ.QM.PORT self.user = config.MQ.QM.USER self.password = config.MQ.QM.PASSWORD self.conn_info = "{}({})".format(self.host, self.port) self.qmgr = pymqi.QueueManager(None) self.qmgr.connectTCPClient(self.queue_manager, pymqi.CD(), self.channel, self.conn_info, self.user, self.password) # list of tuples (subscription, subscription descriptions) for tearDown() to delete after the test self.sub_desc_list = []
def test_connect(self): # connecting with queue manager name needs MQSERVER set properly print(os.environ['MQSERVER']) qmgr = pymqi.QueueManager(None) self.assertFalse(qmgr.is_connected) qmgr.connect(self.qm_name) self.assertTrue(qmgr.is_connected) qmgr.disconnect()
def test_connect_tcp_client(self): qmgr = pymqi.QueueManager(None) qmgr.connect_tcp_client(self.qm_name, pymqi.cd(), self.channel, self.conn_info, user=self.user, password=self.password) self.assertTrue(qmgr.is_connected) qmgr.disconnect()
def test_get_handle_connected(self): qmgr = pymqi.QueueManager(None) qmgr.connect_tcp_client(self.qm_name, pymqi.cd(), self.channel, self.conn_info, user=self.user, password=self.password) handle = qmgr.get_handle() # assertIsInstance is available >= Python2.7 self.assertTrue(isinstance(handle, int))
def test_connect_tcp_client_conection_list(self): qmgr = pymqi.QueueManager(None) self.conn_info = '127.0.0.1(22),{0}'.format(self.conn_info) qmgr.connect_tcp_client(self.qm_name, pymqi.cd(), self.channel, self.conn_info, user=self.user, password=self.password) self.assertTrue(qmgr.is_connected) qmgr.disconnect()
def get_connection(): queue_manager = config['queue_manager'] connector_descriptor = pymqi.CD() connector_descriptor.ChannelName = config['server_connection'] connector_descriptor.ConnectionName = config['host_port'] connector_descriptor.ChannelType = CMQC.MQCHT_CLNTCONN connector_descriptor.TransportType = CMQC.MQXPT_TCP qmgr = pymqi.QueueManager(None) qmgr.connect_with_options(queue_manager, connector_descriptor) return qmgr
def test_inquire(self): qmgr = pymqi.QueueManager(None) qmgr.connect_tcp_client(self.qm_name, pymqi.cd(), self.channel, self.conn_info, user=self.user, password=self.password) attribute = pymqi.CMQC.MQCA_Q_MGR_NAME expected_value = utils.py3str2bytes(self.qm_name) attribute_value = qmgr.inquire(attribute) self.assertEqual(len(attribute_value), pymqi.CMQC.MQ_Q_MGR_NAME_LENGTH) self.assertEqual(attribute_value.strip(), expected_value)
def get_connection(self): queue_manager = self.config['queue_manager'] connector_descriptor = pymqi.CD() connector_descriptor.ChannelName = self.server_channel connector_descriptor.ConnectionName = self.host_port connector_descriptor.ChannelType = CMQC.MQCHT_CLNTCONN connector_descriptor.TransportType = CMQC.MQXPT_TCP connector_descriptor.WaitInterval = 30 * 60 qmgr = pymqi.QueueManager(None) qmgr.connect_with_options(queue_manager, connector_descriptor) return qmgr
def test_put1(self): qmgr = pymqi.QueueManager(None) qmgr.connect_tcp_client(self.qm_name, pymqi.cd(), self.channel, self.conn_info, user=self.user, password=self.password) input_msg = b'Hello world!' qmgr.put1(self.queue_name, input_msg) # now get the message from the queue queue = pymqi.Queue(qmgr, self.queue_name) result_msg = queue.get() self.assertEqual(input_msg, result_msg)
def get_ssl_connection(config): # type: (IBMMQConfig) -> QueueManager """ Get the connection with SSL """ cd = _get_channel_definition(config) cd.SSLCipherSpec = config.ssl_cipher_spec sco = pymqi.SCO() sco.KeyRepository = config.ssl_key_repository_location queue_manager = pymqi.QueueManager(None) queue_manager.connect_with_options(config.queue_manager_name, cd, sco) return queue_manager
def __init__(self): threading.Thread.__init__(self) self.daemon = True cd = pymqi.CD() cd.ChannelName = channel cd.ConnectionName = listener cd.ChannelType = pymqi.CMQC.MQCHT_CLNTCONN cd.TransportType = pymqi.CMQC.MQXPT_TCP self.qm = pymqi.QueueManager(None) self.qm.connect_with_options(qm_name, opts=pymqi.CMQC.MQCNO_HANDLE_SHARE_NO_BLOCK, cd=cd) self.req_queue = pymqi.Queue(self.qm, request_queue_name) self.replyto_queue = pymqi.Queue(self.qm, replyto_queue_name)
def queue_manager(self): if self._queue_manager is None: queue_manager = pymqi.QueueManager(None) cd = self._connection_options['cd'] self.log.info( 'Connecting to MQ: connection=%s | queue manager=%s | channel=%s | user=%s', cd.ConnectionName.decode('utf-8'), self.config.queue_manager, self.config.channel, self.config.mq_user, ) queue_manager.connect_with_options(self.config.queue_manager, **self._connection_options) self._queue_manager = queue_manager return self._queue_manager
def __init__(self): self.queue_manager = config.queue_manager self.channel = config.channel self.port = config.port self.host = config.host self.conn_info = config.conn_info self.queue_request_name = config.queue_request_name self.queue_response_name = config.queue_response_name cd = pymqi.CD() cd.ChannelName = self.channel cd.ConnectionName = self.conn_info cd.ChannelType = pymqi.CMQC.MQCHT_CLNTCONN cd.TransportType = pymqi.CMQC.MQXPT_TCP self.qmgr = pymqi.QueueManager(None) self.qmgr.connect_with_options(self.queue_manager, opts=pymqi.CMQC.MQCNO_HANDLE_SHARE_NO_BLOCK, cd=cd)
def get_ssl_connection(config): """ Get the connection with SSL """ cd = pymqi.CD() cd.ChannelName = config.channel cd.ConnectionName = config.host_and_port cd.ChannelType = pymqi.CMQC.MQCHT_CLNTCONN cd.TransportType = pymqi.CMQC.MQXPT_TCP cd.SSLCipherSpec = config.ssl_cipher_spec sco = pymqi.SCO() sco.KeyRepository = config.ssl_key_repository_location queue_manager = pymqi.QueueManager(None) queue_manager.connect_with_options(config.queue_manager, cd, sco) return queue_manager
def init_message_queue(cfg): ''' Initialize IBM message queue''' mq_conn_info = "%s(%s)" % (cfg['mq_host'], cfg['mq_port']) cd = pymqi.CD() cd.ChannelName = cfg['mq_channel'] cd.ConnectionName = mq_conn_info cd.ChannelType = pymqi.CMQC.MQCHT_CLNTCONN cd.TransportType = pymqi.CMQC.MQXPT_TCP qmgr = pymqi.QueueManager(None) logger.debug("Initiating connection") qmgr.connect_with_options(cfg['mq_queue_manager'], opts=pymqi.CMQC.MQCNO_HANDLE_SHARE_BLOCK, cd=cd) logger.info("Connected to MQ at [{}]".format(cfg['mq_host'])) return qmgr
def get_normal_connection(config): # type: (IBMMQConfig) -> QueueManager """ Get the connection either with a username and password or without """ channel_definition = _get_channel_definition(config) queue_manager = pymqi.QueueManager(None) if config.username and config.password: log.debug("connecting with username and password") kwargs = {'user': config.username, 'password': config.password, 'cd': channel_definition} queue_manager.connect_with_options(config.queue_manager_name, **kwargs) else: log.debug("connecting without a username and password") queue_manager.connect_with_options(config.queue_manager_name, channel_definition) return queue_manager
def test_is_connected(self): """Makes sure the QueueManager's 'is_connected' property works as expected. """ # uses a mock so no real connection to a queue manager will be # established - the parameters below are basically moot with Replacer() as r: queue_manager = uuid4().hex channel = uuid4().hex host = uuid4().hex port = "1431" conn_info = "%s(%s)" % (host, port) user = "******" password = "******" for expected in (True, False): # noinspection PyUnusedLocal def _connect_tcp_client(*ignored_args, **ignored_kwargs): pass # noinspection PyUnusedLocal def _getattr(self2, name): if expected: class _DummyMethod(object): pass # The mere fact of not raising an exception will suffice # for QueueManager._is_connected to understand it as an # all's OK condition. return _DummyMethod else: raise Exception() r.replace('pymqi.QueueManager.connect_tcp_client', _connect_tcp_client) r.replace('pymqi.PCFExecute.__getattr__', _getattr) qmgr = pymqi.QueueManager(None) qmgr.connect_tcp_client(queue_manager, pymqi.cd(), channel, conn_info, user, password) eq_(qmgr.is_connected, expected)
def connect(): logger.info('Establising Connection with MQ Server') try: cd = None if not EnvStore.ccdtCheck(): logger.info( 'CCDT URL export is not set, will be using json envrionment client connections settings' ) cd = pymqi.CD(Version=pymqi.CMQXC.MQCD_VERSION_11) cd.ChannelName = MQDetails[EnvStore.CHANNEL] cd.ConnectionName = conn_info cd.ChannelType = pymqi.CMQC.MQCHT_CLNTCONN cd.TransportType = pymqi.CMQC.MQXPT_TCP logger.info('Checking Cypher details') # If a cipher is set then set the TLS settings if MQDetails[EnvStore.CIPHER]: logger.info('Making use of Cypher details') cd.SSLCipherSpec = MQDetails[EnvStore.CIPHER] # Key repository is not specified in CCDT so look in envrionment settings # Create an empty SCO object sco = pymqi.SCO() if MQDetails[EnvStore.KEY_REPOSITORY]: logger.info('Setting Key repository') sco.KeyRepository = MQDetails[EnvStore.KEY_REPOSITORY] #options = pymqi.CMQC.MQPMO_NO_SYNCPOINT | pymqi.CMQC.MQPMO_NEW_MSG_ID | pymqi.CMQC.MQPMO_NEW_CORREL_ID options = pymqi.CMQC.MQPMO_NEW_CORREL_ID qmgr = pymqi.QueueManager(None) qmgr.connect_with_options(MQDetails[EnvStore.QMGR], user=credentials[EnvStore.USER], password=credentials[EnvStore.PASSWORD], opts=options, cd=cd, sco=sco) return qmgr except pymqi.MQMIError as e: logger.error("Error connecting") logger.error(e) return None
def setUp(self): # max length of queue names is 48 characters self.queue_name = "{prefix}PCF.QUEUE".format( prefix=config.MQ.QUEUE.PREFIX) self.queue_manager = config.MQ.QM.NAME self.channel = config.MQ.QM.CHANNEL self.host = config.MQ.QM.HOST self.port = config.MQ.QM.PORT self.user = config.MQ.QM.USER self.password = config.MQ.QM.PASSWORD self.conn_info = "{0}({1})".format(self.host, self.port) self.qmgr = pymqi.QueueManager(None) self.qmgr.connectTCPClient(self.queue_manager, pymqi.CD(), self.channel, self.conn_info, self.user, self.password) self.create_queue(self.queue_name)
def setUp(self): self.msg_prop_name = utils.py3str2bytes("test_name") self.msg_prop_value = utils.py3str2bytes("test_valuetest_valuetest_valuetest_valuetest_value") # max length of queue names is 48 characters self.queue_name = "{prefix}.MSG.PROP.QUEUE".format(prefix=config.MQ.QUEUE.PREFIX) self.queue_manager = config.MQ.QM.NAME self.channel = config.MQ.QM.CHANNEL self.host = config.MQ.QM.HOST self.port = config.MQ.QM.PORT self.user = config.MQ.QM.USER self.password = config.MQ.QM.PASSWORD self.conn_info = "{0}({1})".format(self.host, self.port) self.qmgr = pymqi.QueueManager(None) self.qmgr.connectTCPClient(self.queue_manager, pymqi.CD(), self.channel, self.conn_info, self.user, self.password) self.create_queue(self.queue_name)
def connectmq_put(recv_mq, str1): host = recv_mq["ip"] + "(" + recv_mq["port"] + ")" qmgr = pymqi.QueueManager(None) qmgr.connect_tcp_client(recv_mq["recv_queue_manager"], pymqi.CD(), recv_mq["recv_channel"], host, recv_mq["username"], recv_mq["password"]) try: qmgr.connect_tcp_client(recv_mq["recv_queue_manager"], pymqi.CD(), recv_mq["recv_channel"], host, recv_mq["username"], recv_mq["password"]) except pymqi.MQMIError as e: if e.comp == pymqi.CMQC.MQCC_WARNING and e.reason == pymqi.CMQC.MQRC_ALREADY_CONNECTED: pass queue = pymqi.Queue(qmgr, recv_mq["recv_queue"]) queue.put(str1) queue.close() qmgr.disconnect()