def remove(name, **kwargs):
try:
logger.debug(f"remove {name}")
rest_mgr = RestMgr(kwargs)
rest_mgr.delete(suburl, name)
except Exception as ex:
logger.error(f"{ex}")
def cf_update(ctx, name, enable_dup_clientid, client_description, client_id, enable_dynamic_durable,
enable_dynamic_ttl, receive_ack_timeout, receive_reconnect_count, receive_reconnect_wait,
receive_window, receive_window_threshold, send_ack_timeout, send_window,
persistent, dmq_eligible, eliding_eligible, enable_jmx_userid,
text_as_binary, compression_level, connect_retry_count, connect_retry_per_host_count,
connect_timeout, direct_transport, keepalive_count,
enable_keepalive, keepalive_interval,
enable_callback_io_thread, enable_optimize_for_direct, transport_port, read_timeout, receive_buffer_size,
reconnect_retry_count, reconnect_retry_wait, send_buffer_size, tcp_no_delay, xa,
**kwargs):
try:
logging.debug(kwargs)
logging.debug(f'update ')
dict = {}
if enable_dup_clientid is not None: dict['allowDuplicateClientIdEnabled'] = enable_dup_clientid
if client_description is not None: dict['clientDescription'] = client_description
if client_id is not None: dict['clientId'] = client_id
if enable_dynamic_durable is not None: dict['dynamicEndpointCreateDurableEnabled'] = enable_dynamic_durable
if enable_dynamic_ttl is not None: dict['dynamicEndpointRespectTtlEnabled'] = enable_dynamic_ttl
if receive_ack_timeout is not None: dict['guaranteedReceiveAckTimeout'] = receive_ack_timeout
if receive_reconnect_count is not None: dict['guaranteedReceiveReconnectRetryCount'] = receive_reconnect_count
if receive_reconnect_wait is not None: dict['guaranteedReceiveReconnectRetryWait'] = receive_reconnect_wait
if receive_window is not None: dict['guaranteedReceiveWindowSize'] = receive_window
if receive_window_threshold is not None: dict[
'guaranteedReceiveWindowSizeAckThreshold'] = receive_window_threshold
if send_ack_timeout is not None: dict['guaranteedSendAckTimeout'] = send_ack_timeout
if send_window is not None: dict['guaranteedSendWindowSize'] = send_window
if persistent is not None: dict['messagingDefaultDeliveryMode'] = persistent
if dmq_eligible is not None: dict['messagingDefaultDmqEligibleEnabled'] = dmq_eligible
if eliding_eligible is not None: dict['messagingDefaultElidingEligibleEnabled'] = eliding_eligible
if enable_jmx_userid is not None: dict['messagingJmsxUserIdEnabled'] = enable_jmx_userid
if text_as_binary is not None: dict['messagingTextInXmlPayloadEnabled'] = text_as_binary
if compression_level is not None: dict['transportCompressionLevel'] = compression_level
if connect_retry_count is not None: dict['transportConnectRetryCount'] = connect_retry_count
if connect_retry_per_host_count is not None: dict[
'transportConnectRetryPerHostCount'] = connect_retry_per_host_count
if connect_timeout is not None: dict['transportConnectTimeout'] = connect_timeout
if direct_transport is not None: dict['transportDirectTransportEnabled'] = direct_transport
if keepalive_count is not None: dict['transportKeepaliveCount'] = keepalive_count
if enable_keepalive is not None: dict['transportKeepaliveEnabled'] = enable_keepalive
if keepalive_interval is not None: dict['transportKeepaliveInterval'] = keepalive_interval
if enable_callback_io_thread is not None: dict[
'transportMsgCallbackOnIoThreadEnabled'] = enable_callback_io_thread
if enable_optimize_for_direct is not None: dict['transportOptimizeDirectEnabled'] = enable_optimize_for_direct
if transport_port is not None: dict['transportPort'] = transport_port
if read_timeout is not None: dict['transportReadTimeout'] = read_timeout
if receive_buffer_size is not None: dict['transportReceiveBufferSize'] = receive_buffer_size
if reconnect_retry_count is not None: dict['transportReconnectRetryCount'] = reconnect_retry_count
if reconnect_retry_wait is not None: dict['transportReconnectRetryWait'] = reconnect_retry_wait
if send_buffer_size is not None: dict['transportSendBufferSize'] = send_buffer_size
if tcp_no_delay is not None: dict['transportTcpNoDelayEnabled'] = tcp_no_delay
if xa is not None: dict['xaEnabled'] = xa
rest_mgr = RestMgr(kwargs)
rest_mgr.patch('jndiConnectionFactories', name, dict)
except Exception as ex:
logger.error(f"END + {ex}")
def remove(ctx, name, **kwargs):
try:
logger.debug(f"remove {name}")
rest_mgr = RestMgr(kwargs)
rest_mgr.delete('jndiConnectionFactories', name)
except Exception as ex:
print('ERRROR')
logger.error(f"create - END + {ex}")
def cf_create(ctx, name, enable_dup_clientid, client_description, client_id, enable_dynamic_durable,
enable_dynamic_ttl, receive_ack_timeout, receive_reconnect_count, receive_reconnect_wait,
receive_window, receive_window_threshold, send_ack_timeout, send_window,
persistent, dmq_eligible, eliding_eligible, enable_jmx_userid,
text_as_binary, compression_level, connect_retry_count, connect_retry_per_host_count,
connect_timeout, direct_transport, keepalive_count,
enable_keepalive, keepalive_interval,
enable_callback_io_thread, enable_optimize_for_direct, transport_port, read_timeout, receive_buffer_size,
reconnect_retry_count, reconnect_retry_wait, send_buffer_size, tcp_no_delay, xa,
**kwargs):
try:
logging.debug(f'cf_create {name} {kwargs}')
dict = {
'allowDuplicateClientIdEnabled': enable_dup_clientid,
'clientDescription': client_description,
'clientId': client_id,
'connectionFactoryName': name,
'dynamicEndpointCreateDurableEnabled': enable_dynamic_durable,
'dynamicEndpointRespectTtlEnabled': enable_dynamic_ttl,
'guaranteedReceiveAckTimeout': receive_ack_timeout,
'guaranteedReceiveReconnectRetryCount': receive_reconnect_count,
'guaranteedReceiveReconnectRetryWait': receive_reconnect_wait,
'guaranteedReceiveWindowSize': receive_window,
'guaranteedReceiveWindowSizeAckThreshold': receive_window_threshold,
'guaranteedSendAckTimeout': send_ack_timeout,
'guaranteedSendWindowSize': send_window,
'messagingDefaultDeliveryMode': 'persistent' if persistent else 'non-persistent',
'messagingDefaultDmqEligibleEnabled': dmq_eligible,
'messagingDefaultElidingEligibleEnabled': eliding_eligible,
'messagingJmsxUserIdEnabled': enable_jmx_userid,
'messagingTextInXmlPayloadEnabled': text_as_binary,
'transportCompressionLevel': compression_level,
'transportConnectRetryCount': connect_retry_count,
'transportConnectRetryPerHostCount': connect_retry_per_host_count,
'transportConnectTimeout': connect_timeout,
'transportDirectTransportEnabled': direct_transport,
'transportKeepaliveCount': keepalive_count,
'transportKeepaliveEnabled': enable_keepalive,
'transportKeepaliveInterval': keepalive_interval,
'transportMsgCallbackOnIoThreadEnabled': enable_callback_io_thread,
'transportOptimizeDirectEnabled': enable_optimize_for_direct,
'transportPort': transport_port,
'transportReadTimeout': read_timeout,
'transportReceiveBufferSize': receive_buffer_size,
'transportReconnectRetryCount': reconnect_retry_count,
'transportReconnectRetryWait': reconnect_retry_wait,
'transportSendBufferSize': send_buffer_size,
'transportTcpNoDelayEnabled': tcp_no_delay,
'xaEnabled': xa,
}
rest_mgr = RestMgr(kwargs)
rest_mgr.post('jndiConnectionFactories', dict)
logger.debug("create - END")
except Exception as ex:
logger.error(f"cf_create - END + {ex}")
def update(name, default_connect, default_publish, default_subscribe,
default_share, **kwargs):
'''Update an existing ACL Profile'''
dict = {}
add_if(dict, default_connect, 'clientConnectDefaultAction', 'allow',
'disallow')
add_if(dict, default_publish, 'publishTopicDefaultAction', 'allow',
'disallow')
add_if(dict, default_subscribe, 'subscribeTopicDefaultAction', 'allow',
'disallow')
add_if(dict, default_share, 'subscribeShareNameDefaultAction', 'allow',
'disallow')
rest_mgr = RestMgr(kwargs)
res = rest_mgr.patch(suburl, name, dict)
send_response(res)
def create(name, default_connect, default_publish, default_subscribe,
default_share, **kwargs):
'''Create a new ACL Profile'''
dict = {
'aclProfileName':
name,
'clientConnectDefaultAction':
'allow' if default_connect else 'disallow',
'publishTopicDefaultAction':
'allow' if default_publish else 'disallow',
'subscribeTopicDefaultAction':
'allow' if default_subscribe else 'disallow',
'subscribeShareNameDefaultAction':
'allow' if default_share else 'disallow',
}
rest_mgr = RestMgr(kwargs)
res = rest_mgr.post(suburl, dict)
send_response(res)
def upsert(is_post, name, acl_profile, client_profile, enable,
gm_perm_override, password, subscription_manager, **kwargs):
dict = {}
add_if(dict, acl_profile, 'clientUsername', name)
add_if(dict, acl_profile, 'aclProfileName', acl_profile)
add_if(dict, client_profile, 'clientProfileName', client_profile)
add_if(dict, enable, 'enabled')
add_if(dict, gm_perm_override,
'guaranteedEndpointPermissionOverrideEnabled')
add_if(dict, password, 'password', password)
add_if(dict, subscription_manager, 'subscriptionManagerEnabled')
rest_mgr = RestMgr(kwargs)
if is_post:
res = rest_mgr.post('clientUsernames', dict)
else:
res = rest_mgr.patch('clientUsernames', name, dict)
send_response(res)
def upsert(is_post, name, password, username, auth_scheme, enable, interface,
timeout, pool_size, host, port, retry_delay, tls_cipher_suite,
enable_tls, rdp, **kwargs):
try:
logging.debug('start')
dict = {}
add_if(dict, password, 'authenticationHttpBasicPassword', password)
add_if(dict, username, 'authenticationHttpBasicUsername', username)
add_if(dict, auth_scheme, 'authenticationScheme', auth_scheme)
add_if(dict, enable, 'enabled')
add_if(dict, interface, 'localInterface', interface)
add_if(dict, timeout, 'maxPostWaitTime', timeout)
add_if(dict, pool_size, 'outgoingConnectionCount', pool_size)
add_if(dict, host, 'remoteHost', host)
add_if(dict, port, 'remotePort', port)
add_if(dict, name, 'restConsumerName', name)
add_if(dict, rdp, 'restDeliveryPointName', rdp)
add_if(dict, retry_delay, 'retryDelay', retry_delay)
add_if(dict, tls_cipher_suite, 'tlsCipherSuiteList', tls_cipher_suite)
add_if(dict, enable_tls, 'tlsEnabled')
rest_mgr = RestMgr(kwargs)
if is_post:
rest_mgr.post(f'{suburl1}/{rdp}/{suburl}', dict)
else:
rest_mgr.patch(f'{suburl1}/{rdp}/{suburl}', name, dict)
except Exception as ex:
logger.error(f"upsert Exception: {ex}")
def upsert(is_post, qname, exclusive, ack_propagation, dmq, egress, ingress,
max_bind, max_unacked, max_msg_size, max_spool, max_redelivery, ttl,
owner, perm, low_priority, low_priority_msg_limit,
reject_on_discard, respect_priority, respect_ttl, **kwargs):
# try:
dict = {}
add_if(dict, qname, 'queueName', qname)
add_if(dict, exclusive, 'accessType', 'exclusive', 'non-exclusive')
add_if(dict, ack_propagation, 'consumerAckPropagationEnabled',
ack_propagation)
add_if(dict, dmq, 'deadMsgQueue', dmq)
add_if(dict, egress, 'egressEnabled', egress)
add_if(dict, ingress, 'ingressEnabled', ingress)
add_if(dict, max_bind, 'maxBindCount', max_bind, 0)
add_if(dict, max_unacked, 'maxDeliveredUnackedMsgsPerFlow', max_unacked, 0)
add_if(dict, max_msg_size, 'maxMsgSize', max_msg_size, 0)
add_if(dict, max_spool, 'maxMsgSpoolUsage', max_spool, 0)
add_if(dict, max_redelivery, 'maxRedeliveryCount', max_redelivery, 0)
add_if(dict, ttl, 'maxTtl', ttl, 0)
add_if(dict, owner, 'owner', owner, '')
add_if(dict, perm, 'permission', perm_map[perm] if perm else '', '')
add_if(dict, low_priority, 'rejectLowPriorityMsgEnabled', low_priority)
add_if(dict, low_priority_msg_limit, 'rejectLowPriorityMsgLimit',
low_priority_msg_limit, 0)
add_if(dict, reject_on_discard, 'rejectMsgToSenderOnDiscardBehavior',
reject_on_discard)
add_if(dict, respect_priority, 'respectMsgPriorityEnabled',
respect_priority)
add_if(dict, respect_ttl, 'respectTtlEnabled', respect_ttl)
# logging.debug(dict)
rest_mgr = RestMgr(kwargs)
if is_post:
res = rest_mgr.post(suburl, dict)
else:
res = rest_mgr.patch(suburl, qname, dict)
send_response(res)
def upsert(is_post, name, client_profile, enable, **kwargs):
try:
logging.debug('start')
dict = {}
add_if(dict, client_profile, 'clientProfileName', client_profile)
add_if(dict, enable, 'enabled')
add_if(dict, name, 'restDeliveryPointName', name)
rest_mgr = RestMgr(kwargs)
if is_post:
rest_mgr.post(suburl, dict)
else:
rest_mgr.patch(suburl, name, dict)
except Exception as ex:
logger.error(f"upsert Exception: {ex}")
def upsert(is_post, name, enable_egress, enable_ingress, max_spool, **kwargs):
try:
logging.debug('start')
dict = {}
add_if(dict, enable_egress, 'egressEnabled')
add_if(dict, enable_ingress, 'ingressEnabled')
add_if(dict, max_spool, 'maxSpoolUsage', max_spool, 0)
add_if(dict, name, 'replayLogName', name)
rest_mgr = RestMgr(kwargs)
if is_post:
rest_mgr.post(suburl, dict)
else:
rest_mgr.patch(suburl, name, dict)
except Exception as ex:
logger.error(f"upsert Exception: {ex}")
def upsert(is_post, name,
replace_request_target, request_target, rdp,
**kwargs):
try:
logging.debug('start')
dict = {}
add_if(dict, replace_request_target, 'gatewayReplaceTargetAuthorityEnabled')
add_if(dict, request_target, 'postRequestTarget', request_target)
add_if(dict, name, 'queueBindingName', name)
add_if(dict, rdp, 'restDeliveryPointName', rdp)
rest_mgr = RestMgr(kwargs)
if is_post:
rest_mgr.post(f'{suburl1}/{rdp}/{suburl}', dict)
else:
rest_mgr.patch(f'{suburl1}/{rdp}/{suburl}', name, dict)
except Exception as ex:
logger.error(f"upsert Exception: {ex}")
def show(name, **kwargs):
'''Show the details of an existing ACL Profile'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get(suburl, name)
send_response(res)
def list(ctx, **kwargs):
try:
rest_mgr = RestMgr(kwargs)
rest_mgr.get(suburl)
except Exception as ex:
logger.error(f"{ex}")
def show(name, **kwargs):
try:
rest_mgr = RestMgr(kwargs)
rest_mgr.get(suburl, name)
except Exception as ex:
logger.error(f"{ex}")
def show(qname, **kwargs):
'''Dump the properties of an existing queue'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get(suburl, qname)
send_response(res)
def cf_show(ctx, name, **kwargs):
# try:
logging.debug(ctx.obj)
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get('jndiConnectionFactories', name)
logger.debug(res)
def remove(name, **kwargs):
'''Remove a client username'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.delete(suburl, name)
send_response(res)
def remove(qname, **kwargs):
'''Remove an existing queue'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.delete(suburl, qname)
send_response(res)
def list(**kwargs):
'''List all client usernames in the Message VPN'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get(suburl)
send_response(res)
def show(name, **kwargs):
'''Show details of an existing client username'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get(suburl, name)
send_response(res)
def show(name, **kwargs):
'''Show the properties of a client profile'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get(suburl, name)
send_response(res)
def list(**kwargs):
'''List all the queues'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get(f'{suburl}', None)
send_response(res)
def list(**kwargs):
'''List all the ACL Profiles in the Message VPN'''
rest_mgr = RestMgr(kwargs)
res = rest_mgr.get(suburl)
send_response(res)
def remove(name, **kwargs):
'''Remove an ACL Profile'''
logger.debug(f"remove {name}")
rest_mgr = RestMgr(kwargs)
res = rest_mgr.delete(suburl, name)
send_response(res)
def show(name, rdp, **kwargs):
try:
rest_mgr = RestMgr(kwargs)
rest_mgr.get(f'{suburl1}/{rdp}/{suburl}', name)
except Exception as ex:
logger.error(f"{ex}")
def list(rdp, **kwargs):
try:
rest_mgr = RestMgr(kwargs)
rest_mgr.get(f'{suburl1}/{rdp}/{suburl}')
except Exception as ex:
logger.error(f"{ex}")
def clientprofile_upsert(
is_post, name, enable_bridge, enable_cut_through,
client_create_durability, enable_client_endpoint, enable_gm_receive,
enable_gm_send, enable_shared, enable_tx, template_queue,
template_topic_endpoint, compress, eliding_delay, enable_eliding,
eliding_max_topics, max_client_connects, max_egress_flows,
max_client_created_endpoints, max_ingress_flows, max_subscriptions,
max_tx_sessions, max_client_tx, reject_no_subscription,
enable_connect_standby, max_client_smf_connects, web_inactive_timeout,
max_client_web_connects, max_web_payload, tcp_congestion_size,
tcp_keepalive, tcp_keepalive_idle, tcp_keepalive_interval,
tcp_max_segment_size, tcp_max_window_size, allow_tls_downgrade,
**kwargs):
dict = {}
add_if(dict, enable_bridge, 'allowBridgeConnectionsEnabled')
add_if(dict, enable_cut_through, 'allowCutThroughForwardingEnabled')
add_if(dict, client_create_durability,
'allowGuaranteedEndpointCreateDurability', client_create_durability)
add_if(dict, enable_client_endpoint,
'allowGuaranteedEndpointCreateEnabled')
add_if(dict, enable_gm_receive, 'allowGuaranteedMsgReceiveEnabled')
add_if(dict, enable_gm_send, 'allowGuaranteedMsgSendEnabled')
add_if(dict, enable_shared, 'allowSharedSubscriptionsEnabled')
add_if(dict, enable_tx, 'allowTransactedSessionsEnabled')
add_if(dict, template_queue,
'apiQueueManagementCopyFromOnCreateTemplateName', template_queue)
add_if(dict, template_topic_endpoint,
'apiTopicEndpointManagementCopyFromOnCreateTemplateName',
template_topic_endpoint)
add_if(dict, name, 'clientProfileName', name)
add_if(dict, compress, 'compressionEnabled')
add_if(dict, eliding_delay, 'elidingDelay', eliding_delay, 0)
add_if(dict, enable_eliding, 'elidingEnabled')
add_if(dict, eliding_max_topics, 'elidingMaxTopicCount',
eliding_max_topics, 0)
add_if(dict, max_client_connects, 'maxConnectionCountPerClientUsername',
max_client_connects, 0)
add_if(dict, max_egress_flows, 'maxEgressFlowCount', max_egress_flows, 0)
add_if(dict, max_client_created_endpoints,
'maxEndpointCountPerClientUsername', max_client_created_endpoints,
0)
add_if(dict, max_ingress_flows, 'maxIngressFlowCount', max_ingress_flows,
0)
add_if(dict, max_subscriptions, 'maxSubscriptionCount', max_subscriptions,
0)
add_if(dict, max_tx_sessions, 'maxTransactedSessionCount', max_tx_sessions,
0)
add_if(dict, max_client_tx, 'maxTransactionCount', max_client_tx, 0)
add_if(dict, reject_no_subscription,
'rejectMsgToSenderOnNoSubscriptionMatchEnabled')
add_if(dict, enable_connect_standby,
'replicationAllowClientConnectWhenStandbyEnabled')
add_if(dict, max_client_smf_connects,
'serviceSmfMaxConnectionCountPerClientUsername',
max_client_smf_connects, 0)
add_if(dict, web_inactive_timeout, 'serviceWebInactiveTimeout',
web_inactive_timeout, 0)
add_if(dict, max_client_web_connects,
'serviceWebMaxConnectionCountPerClientUsername',
max_client_web_connects, 0)
add_if(dict, max_web_payload, 'serviceWebMaxPayload', max_web_payload, 0)
add_if(dict, tcp_congestion_size, 'tcpCongestionWindowSize',
tcp_congestion_size, 0)
add_if(dict, tcp_keepalive, 'tcpKeepaliveCount', tcp_keepalive, 0)
add_if(dict, tcp_keepalive_idle, 'tcpKeepaliveIdleTime',
tcp_keepalive_idle, 0)
add_if(dict, tcp_keepalive_interval, 'tcpKeepaliveInterval',
tcp_keepalive_interval, 0)
add_if(dict, tcp_max_segment_size, 'tcpMaxSegmentSize',
tcp_max_segment_size, 0)
add_if(dict, tcp_max_window_size, 'tcpMaxWindowSize', tcp_max_window_size,
0)
add_if(dict, allow_tls_downgrade, 'tlsAllowDowngradeToPlainTextEnabled')
rest_mgr = RestMgr(kwargs)
if is_post:
res = rest_mgr.post(suburl, dict)
else:
res = rest_mgr.patch(suburl, name, dict)
send_response(res)