def delete_users(connection, vpn_name):
s_cmd = SolaceXMLBuilder("Retrieving list of client-usernames")
s_cmd.show.client_username.name = '*'
s_cmd.show.client_username.vpn_name = vpn_name
reply = connection.rpc(str(s_cmd))
for host in reply:
try:
host['rpc-reply']['rpc']['show']['client-username'][
'client-usernames']['client-username']
except:
# skip passive node
continue
for user in host['rpc-reply']['rpc']['show']['client-username'][
'client-usernames']['client-username']:
client_username = user['client-username']
# Shutdown the user
s_cmd = SolaceXMLBuilder("Shutdown User %s" % client_username)
s_cmd.client_username.username = client_username
s_cmd.client_username.vpn_name = vpn_name
s_cmd.client_username.shutdown
connection.rpc(str(s_cmd))
# Delete the user
s_cmd = SolaceXMLBuilder("Delete User %s" % client_username)
s_cmd.no.client_username.username = client_username
s_cmd.no.client_username.vpn_name = vpn_name
connection.rpc(str(s_cmd))
def _bridge_set_remote_queue_addr(self, api, bridgeName, vpn, backup_addr,
phys_intf, queueName, **kwargs):
api.x = SolaceXMLBuilder(
"%s primary bridge: %s set remote queue: %s on primary appliance" %
(api.primaryRouter, bridgeName, queueName),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.primary
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.connect_via
api.x.bridge.remote.message_vpn.addr = backup_addr
api.x.bridge.remote.message_vpn.interface
api.x.bridge.remote.message_vpn.phys_intf = phys_intf
api.x.bridge.remote.message_vpn.message_spool.queue.name = queueName
api.cq.enqueueV2(str(api.x), primaryOnly=True)
api.x = SolaceXMLBuilder(
"%s backup bridge: %s set remote queue: %s on backup appliance" %
(api.backupRouter, bridgeName, queueName),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.backup
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.connect_via
api.x.bridge.remote.message_vpn.addr = backup_addr
api.x.bridge.remote.message_vpn.interface
api.x.bridge.remote.message_vpn.phys_intf = phys_intf
api.x.bridge.remote.message_vpn.message_spool.queue.name = queueName
api.cq.enqueueV2(str(api.x), backupOnly=True)
def set_internal_auth(self, **kwargs):
"""Set authentication method to internal
:param vpn_name: The name of the VPN
:type vpn_name: str
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> tuple_request = api.manage("SolaceVPN").set_internal_auth(vpn_name="my_vpn")
>>> response = api.rpc(tuple_request)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
# Switch to Internal Auth
if self.api.version == "soltr/7_1_1" or self.api.version == "soltr/7_0" or self.api.version == "soltr/6_2":
self.api.x = SolaceXMLBuilder("VPN %s Enable Internal Auth" %
vpn_name,
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.authentication.user_class.client
self.api.x.message_vpn.authentication.user_class.basic.auth_type.internal
else:
self.api.x = SolaceXMLBuilder("VPN %s Enable Internal Auth" %
vpn_name,
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.authentication.user_class.client
self.api.x.message_vpn.authentication.user_class.auth_type.internal
self.commands.enqueue(self.api.x, **kwargs)
return (str(self.api.x), kwargs)
def _bridge_set_remote_queue_vrouter(self, api, bridgeName, vpn, vrouter,
queueName, **kwargs):
api.x = SolaceXMLBuilder(
"%s primary bridge: %s set remote queue: %s on primary appliance" %
(api.primaryRouter, bridgeName, queueName),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.primary
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.router
api.x.bridge.remote.message_vpn.virtual_router_name = "v:%s" % vrouter
api.x.bridge.remote.message_vpn.message_spool.queue.name = queueName
api.cq.enqueueV2(str(api.x), primaryOnly=True)
api.x = SolaceXMLBuilder(
"%s backup bridge: %s set remote queue: %s on backup appliance" %
(api.backupRouter, bridgeName, queueName),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.backup
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.router
api.x.bridge.remote.message_vpn.virtual_router_name = "v:%s" % vrouter
api.x.bridge.remote.message_vpn.message_spool.queue.name = queueName
api.cq.enqueueV2(str(api.x), backupOnly=True)
def _bridge_disable_remote_addr(self, api, bridgeName, vpn, backup_addr,
phys_intf, **kwargs):
api.x = SolaceXMLBuilder(
"%s disable primary bridge: %s remote addr: %s phys_intf: %s on primary appliance"
% (api.primaryRouter, bridgeName, backup_addr, phys_intf),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.primary
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.connect_via
api.x.bridge.remote.message_vpn.addr = backup_addr
api.x.bridge.remote.message_vpn.interface
api.x.bridge.remote.message_vpn.phys_intf = phys_intf
api.x.bridge.remote.message_vpn.shutdown
api.cq.enqueueV2(str(api.x), primaryOnly=True)
api.x = SolaceXMLBuilder(
"%s disable backup bridge: %s remote addr: %s phys_intf: %s on backup appliance"
% (api.backupRouter, bridgeName, backup_addr, phys_intf),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.backup
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.connect_via
api.x.bridge.remote.message_vpn.addr = backup_addr
api.x.bridge.remote.message_vpn.interface
api.x.bridge.remote.message_vpn.phys_intf = phys_intf
api.x.bridge.remote.message_vpn.shutdown
api.cq.enqueueV2(str(api.x), backupOnly=True)
def _bridge_disable_remote_vrouter(self, api, bridgeName, vpn, vrouter,
**kwargs):
api.x = SolaceXMLBuilder("%s enable primary bridge: %s vrouter: %s" %
(api.primaryRouter, bridgeName, vrouter),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.primary
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.router
api.x.bridge.remote.message_vpn.virtual_router_name = "v:%s" % vrouter
api.x.bridge.remote.message_vpn.shutdown
api.cq.enqueueV2(str(api.x), primaryOnly=True)
api.x = SolaceXMLBuilder("%s enable backup bridge: %s vrouter: %s" %
(api.backupRouter, bridgeName, vrouter),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.backup
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.router
api.x.bridge.remote.message_vpn.virtual_router_name = "v:%s" % vrouter
api.x.bridge.remote.message_vpn.shutdown
api.cq.enqueueV2(str(api.x), backupOnly=True)
def _bridge_username_addr(self, api, bridgeName, vpn, backup_addr,
phys_intf, username, password, **kwargs):
api.x = SolaceXMLBuilder(
"%s primary bridge: %s remote username: %s on primary appliance" %
(api.primaryRouter, bridgeName, username),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.primary
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.connect_via
api.x.bridge.remote.message_vpn.addr = backup_addr
api.x.bridge.remote.message_vpn.interface
api.x.bridge.remote.message_vpn.phys_intf = phys_intf
api.x.bridge.remote.message_vpn.client_username.name = username
api.x.bridge.remote.message_vpn.client_username.password = password
api.cq.enqueueV2(str(api.x), primaryOnly=True)
api.x = SolaceXMLBuilder(
"%s backup bridge: %s remote username: %s on backup appliance" %
(api.backupRouter, bridgeName, username),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.backup
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.connect_via
api.x.bridge.remote.message_vpn.addr = backup_addr
api.x.bridge.remote.message_vpn.interface
api.x.bridge.remote.message_vpn.phys_intf = phys_intf
api.x.bridge.remote.message_vpn.client_username.name = username
api.x.bridge.remote.message_vpn.client_username.password = password
api.cq.enqueueV2(str(api.x), backupOnly=True)
def _bridge_username_vrouter(self, api, bridgeName, vpn, vrouter, username,
password, **kwargs):
api.x = SolaceXMLBuilder(
"%s primary bridge: %s remote username: %s on primary appliance" %
(api.primaryRouter, bridgeName, username),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.primary
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.router
api.x.bridge.remote.message_vpn.virtual_router_name = "v:%s" % vrouter
api.x.bridge.remote.message_vpn.client_username.name = username
api.x.bridge.remote.message_vpn.client_username.password = password
api.cq.enqueueV2(str(api.x), primaryOnly=True)
api.x = SolaceXMLBuilder(
"%s backup bridge: %s remote username: %s on backup appliance" %
(api.backupRouter, bridgeName, username),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.backup
api.x.bridge.remote.message_vpn.vpn_name = vpn
api.x.bridge.remote.message_vpn.router
api.x.bridge.remote.message_vpn.virtual_router_name = "v:%s" % vrouter
api.x.bridge.remote.message_vpn.client_username.name = username
api.x.bridge.remote.message_vpn.client_username.password = password
api.cq.enqueueV2(str(api.x), backupOnly=True)
def _create_bridge_remote_vrouter(self, api, bridgeName, vpn,
virtual_router, **kwargs):
api.x = SolaceXMLBuilder(
"%s configure primary bridge: %s vrouter: %s on primary appliance"
% (api.primaryRouter, bridgeName, virtual_router),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.primary
api.x.bridge.remote.create.message_vpn.vpn_name = vpn
api.x.bridge.remote.create.message_vpn.router
api.x.bridge.remote.create.message_vpn.virtual_router_name = "v:%s" % virtual_router
api.cq.enqueueV2(str(api.x), primaryOnly=True)
api.x = SolaceXMLBuilder(
"%s configure backup bridge: %s vrouter: %s on backup appliance" %
(api.backupRouter, bridgeName, virtual_router),
version=api.version)
api.x.bridge.bridge_name = bridgeName
api.x.bridge.vpn_name = vpn
api.x.bridge.backup
api.x.bridge.remote.create.message_vpn.vpn_name = vpn
api.x.bridge.remote.create.message_vpn.router
api.x.bridge.remote.create.message_vpn.virtual_router_name = "v:%s" % virtual_router
api.cq.enqueueV2(str(api.x), backupOnly=True)
def delete_queues(connection, vpn_name):
logging.info("Deleting Queues")
s_cmd = SolaceXMLBuilder("Retrieving list of queues")
s_cmd.show.queue.name = '*'
s_cmd.show.queue.vpn_name = vpn_name
reply = connection.rpc(str(s_cmd))
for host in reply:
logging.debug("Checking Reply: %s" % reply)
try:
host['rpc-reply']['rpc']['show']['queue']['queues']['queue']
except:
# skip passive node
continue
for queue in host['rpc-reply']['rpc']['show']['queue']['queues'][
'queue']:
# Shutdown the Queue
logging.debug("Found Queue: %s" % queue)
queue_name = queue['name']
logging.debug("Queue to delete: %s" % queue_name)
s_cmd = SolaceXMLBuilder("Shutdown Queue %s" % queue_name)
s_cmd.message_spool.vpn_name = vpn_name
s_cmd.message_spool.queue.name = queue_name
s_cmd.message_spool.queue.shutdown
connection.rpc(str(s_cmd))
s_cmd = SolaceXMLBuilder("Delete Queue %s" % queue_name)
s_cmd.message_spool.vpn_name = vpn_name
s_cmd.message_spool.no.queue.name = queue_name
connection.rpc(str(s_cmd))
def solace_provision_user(options=None):
""" Creates a user within solace appliance cluster
1. Connects to a both appliances in cluster
2. Creates new user
3. Assigns rights to user
:param options: dictionary containig user details
{'environment': 'ci1',
'global_access_level': 'read-only',
'password': '******',
'username': '******'}
:example of xml produced:
<rpc xmlns="http://www.solacesystems.com/semp/topic_routing/6_0">
<create>
<username>
<name>readonly</name>
<password>readonly</password>
</username>
</create>
</rpc>
<rpc xmlns="http://www.solacesystems.com/semp/topic_routing/6_0">
<username>
<name>readonly</name>
<global-access-level>
<access-level>read-only</access-level>
</global-access-level>
</username>
</rpc>
"""
try:
pprint.pprint(options.__dict__)
# Create a client to the PT1 unit ( Update to connect to both devices and create USERS, ACL, CLIENT PROFILE )
# only queues are replicated and JNDI
print(options.__dict__)
for environment in options.environment:
solace = SolaceAPI(environment)
if options.remove:
cmd = SolaceXMLBuilder("Removing User %s" % options.username)
cmd.no.username.name = options.username
solace.rpc(str(cmd))
else:
# ACLS / Users
cmd = SolaceXMLBuilder("Creating User %s" % options.username)
cmd.create.username.name = options.username
cmd.create.username.password = options.password
solace.rpc(str(cmd))
# Allow acl profile to publish
cmd = SolaceXMLBuilder("Setting Permissions to %s" % options.global_access_level)
cmd.username.name = options.username
cmd.username.global_access_level.access_level = options.global_access_level
solace.rpc(str(cmd))
except:
raise
def set_password(self, **kwargs):
"""
Set the user password
:param username: the username
:type username: str
:param vpn_name: the vpn name
:type vpn_name: str
:param password: the password
:type password: str
:rtype: plugin.PluginResponse
:return: SEMP request
"""
username = get_key_from_kwargs('username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
password = get_key_from_kwargs('password', kwargs)
# Set User Password
self.api.x = SolaceXMLBuilder("Set User %s password" % username, version=self.api.version)
self.api.x.client_username.username = username
self.api.x.client_username.vpn_name = vpn_name
self.api.x.client_username.password.password = password
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def set_acl_profile(self, **kwargs):
"""
set acl profile
:param username: the username
:type username: str
:param vpn_name: the vpn name
:type vpn_name: str
:param acl_profile: name of the profile
:type acl_profile: str
:rtype: plugin.PluginResponse
:return: SEMP request
"""
username = get_key_from_kwargs('username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
acl_profile = get_key_from_kwargs('acl_profile', kwargs)
# Set client user profile
self.api.x = SolaceXMLBuilder("Set User %s ACL Profile to %s" % (username, vpn_name), version=self.api.version)
self.api.x.client_username.username = username
self.api.x.client_username.vpn_name = vpn_name
self.api.x.client_username.acl_profile.name = acl_profile
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def set_client_profile(self, **kwargs):
"""
set client profile
:param username: the username
:type username: str
:param vpn_name: the vpn name
:type vpn_name: str
:param client_profile: name of the profile
:type client_profile: str
:rtype: plugin.PluginResponse
:return: SEMP request
"""
username = get_key_from_kwargs('username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
client_profile = get_key_from_kwargs('client_profile', kwargs)
# Client Profile
self.api.x = SolaceXMLBuilder("Setting User %s client profile to %s" % (username, client_profile),
version=self.api.version)
self.api.x.client_username.username = username
self.api.x.client_username.vpn_name = vpn_name
self.api.x.client_username.client_profile.name = client_profile
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def disable_user(self, **kwargs):
"""
Disable the user ( suspending pub/sub )
:param username: the username
:type username: str
:param vpn_name: the vpn name
:type vpn_name: str
:param shutdown_on_apply: see :func:`Kwargs.shutdown_on_apply`
:type shutdown_on_apply: bool / char
:rtype: plugin.PluginResponse
:return: SEMP request
"""
username = get_key_from_kwargs('username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
shutdown_on_apply = get_key_from_kwargs('shutdown_on_apply', kwargs)
if (shutdown_on_apply == 'b') or (shutdown_on_apply == 'u') or (shutdown_on_apply == True):
# Disable / Shutdown User ( else we cant change profiles )
self.api.x = SolaceXMLBuilder("Disabling User %s" % username, version=self.api.version)
self.api.x.client_username.username = username
self.api.x.client_username.vpn_name = vpn_name
self.api.x.client_username.shutdown
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
else:
logger.warning(
"Not disabling User, commands could fail since shutdown_on_apply = %s" % self.shutdown_on_apply)
return None
def check_client_profile_exists(self, **kwargs):
"""
Checks if a client_profile exists on the appliance for linking.
Example:
>>> from libsolace.SolaceAPI import SolaceAPI
>>> apic = SolaceAPI("dev")
>>> foo = apic.manage("SolaceUser")
>>> foo.check_client_profile_exists(client_profile="default")
True
:param client_profile: the client profile name
:type client_profile: str
:return: boolean
:rtype: bool
"""
client_profile = get_key_from_kwargs('client_profile', kwargs)
logger.info('Checking if client_profile is present on devices')
self.api.x = SolaceXMLBuilder("Checking client_profile %s is present on device" % client_profile,
version=self.api.version)
self.api.x.show.client_profile.name = client_profile
response = self.api.rpc(str(self.api.x), allowfail=False)
for v in response:
if v['rpc-reply']['execute-result']['@code'] == 'fail':
logger.warning('client_profile: %s missing from appliance' % client_profile)
raise BaseException("no such client_profile %s" % client_profile)
return False
return True
def allow_subscribe(self, **kwargs):
""" Allow subscribe
:param name: name of the profile
:param vpn_name: vpn name
:rtype: PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceACLProfile").allow_subscribe(name="myprofile", vpn_name="dev_testvpn")
>>> # api.rpc(request)
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("VPN %s Allowing ACL Profile to subscribe to VPN" % name,
version=self.api.version)
self.api.x.acl_profile.name = name
self.api.x.acl_profile.vpn_name = vpn_name
self.api.x.acl_profile.subscribe_topic.default_action.allow
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def retries(self, **kwargs):
"""Delivery retries before failing the message
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:param retries: number of retries
:type vpn_name: str
:type queue_name: str
:type retries: int
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").retries(vpn_name="dev_testvpn", queue_name="testqueue1", retries=5)
>>> # response = api.rpc(request)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
retries = get_key_from_kwargs("retries", kwargs, default=0)
self.api.x = SolaceXMLBuilder(
"Tuning max-redelivery retries for %s to %s" %
(queue_name, retries),
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.queue.name = queue_name
self.api.x.message_spool.queue.max_redelivery.value = retries
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def spool_size(self, **kwargs):
"""Set the spool size
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:param queue_size: size of the spool in mb
:type vpn_name: str
:type queue_name: str
:type queue_size: int
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").spool_size(vpn_name="dev_testvpn", queue_name="testqueue1", queue_size=64)
>>> # response = api.rpc(request)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
queue_size = get_key_from_kwargs("queue_size", kwargs)
# Configure Queue Spool Usage
self.api.x = SolaceXMLBuilder("Set Queue %s spool size: %s" %
(queue_name, queue_size),
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.queue.name = queue_name
self.api.x.message_spool.queue.max_spool_usage.size = queue_size
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def max_bind_count(self, **kwargs):
"""Limit the max bind count
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:param max_bind_count: max bind count
:type vpn_name: str
:type queue_name: str
:type max_bind_count: int
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> requests = api.manage("SolaceQueue").max_bind_count(vpn_name="dev_testvpn", queue_name="testqueue1", max_bind_count=50)
>>> # response = api.rpc(requests)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
max_bind_count = get_key_from_kwargs("max_bind_count", kwargs)
self.api.x = SolaceXMLBuilder(
"Settings Queue %s max bind count to %s" %
(queue_name, str(max_bind_count)),
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.queue.name = queue_name
self.api.x.message_spool.queue.max_bind_count.value = max_bind_count
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def create_queue(self, **kwargs):
"""Create a queue / endpoint only if it doesnt exist.
:param queue_name: the queue name
:param vpn_name: the vpn name
:type queue_name: str
:type vpn_name: str
:type: plugin.PluginResponse
:returns: single SEMP request
Example 1: Create Request, then Execute
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").create_queue(vpn_name="dev_testvpn", queue_name="my_test_queue")
>>> # response = api.rpc(request)
"""
queue_name = get_key_from_kwargs("queue_name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
# Create a queue
self.api.x = SolaceXMLBuilder("Creating Queue %s in vpn: %s" %
(queue_name, vpn_name),
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.create.queue.name = queue_name
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
self.exists = True
return PluginResponse(str(self.api.x), **kwargs)
def get(self, **kwargs):
"""Fetch a queue from the appliance
:type queue_name: str
:type vpn_name: str
:param queue_name: Queue name or filter
:param vpn_name: name of the VPN
:rtype: plugin.PluginResponse
:returns: the queue(s)
Examples:
>>> api = SolaceAPI("dev")
>>> list_queues = api.manage("SolaceQueue").get(queue_name='*', vpn_name='dev_testvpn')
"""
queue_name = get_key_from_kwargs("queue_name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
detail = get_key_from_kwargs("detail", kwargs, default=False)
# if this request is not specifically targeted at the backup, default to primary
if get_key_from_kwargs("backupOnly", kwargs, default=False) is False:
kwargs["primaryOnly"] = True
self.api.x = SolaceXMLBuilder("Querying Queue %s" % queue_name,
version=self.api.version)
self.api.x.show.queue.name = queue_name
self.api.x.show.queue.vpn_name = vpn_name
if detail:
self.api.x.show.queue.detail
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return self.api.rpc(PluginResponse(str(self.api.x), **kwargs))
def set_max_clients(self, **kwargs):
"""Set max clients for profile
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceClientProfile").set_max_clients(name="default", vpn_name="default", max_clients=500)
>>> # response = api.rpc(request)
:param name: name of the profile
:param vpn_name: the name of the vpn to scope the request to
:param max_clients: max number of clients
:type name: str
:type vpn_name: str
:type max_clients: int
:returns: SEMP request
:rtype: plugin.PluginResponse
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
max_clients = get_key_from_kwargs("max_clients", kwargs)
self.api.x = SolaceXMLBuilder("Setting Max Clients",
version=self.api.version)
self.api.x.client_profile.name = name
if version_equal_or_greater_than('soltr/6_2', self.api.version):
self.api.x.client_profile.vpn_name = vpn_name
self.api.x.client_profile.max_connections_per_client_username.value = max_clients
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def allow_bridging(self, **kwargs):
"""Allow bridging
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> plugin = SolaceAPI("dev", version="soltr/7_1_1").manage("SolaceClientProfile")
>>> request = plugin.allow_bridging(name="default", vpn_name="default")
>>> request.xml
'<rpc semp-version="soltr/7_1_1"><client-profile><name>default</name><vpn-name>default</vpn-name><allow-bridge-connections/></client-profile></rpc>'
>>> # api.rpc(request)
:param name: name of the profile
:param vpn_name: the name of the vpn to scope the request to
:type name: str
:type vpn_name: str
:returns: SEMP request
:rtype: plugin.PluginResponse
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Setting Bridging",
version=self.api.version)
self.api.x.client_profile.name = name
if version_equal_or_greater_than('soltr/6_2', self.api.version):
self.api.x.client_profile.vpn_name = vpn_name
self.api.x.client_profile.allow_bridge_connections
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def delete(self, **kwargs):
"""Delete a client profile
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> plugin_response = api.manage("SolaceClientProfile").delete(name="default", vpn_name="default")
:param name: name of the profile
:param vpn_name: the name of the vpn to scope the request to
:type name: str
:type vpn_name: str
:returns: SEMP request
:rtype: plugin.PluginResponse
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Delete Client Profile",
version=self.api.version)
self.api.x.no.client_profile.name = name
if version_equal_or_greater_than('soltr/6_2', self.api.version):
self.api.x.no.client_profile.vpn_name = vpn_name
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def allow_transacted_sessions(self, **kwargs):
"""Allow transaction sessions permission
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceClientProfile").allow_transacted_sessions(name="default", vpn_name="default")
>>> # response = api.rpc(request)
:param name: name of the profile
:param vpn_name: the name of the vpn to scope the request to
:type name: str
:type vpn_name: str
:returns: SEMP request
:rtype: plugin.PluginResponse
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Allow profile transacted sessions",
version=self.api.version)
self.api.x.client_profile.name = name
if version_equal_or_greater_than('soltr/6_2', self.api.version):
self.api.x.client_profile.vpn_name = vpn_name
self.api.x.client_profile.message_spool.allow_transacted_sessions
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def enable(self, **kwargs):
"""Enable a the queue
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:type vpn_name: str
:type queue_name: str
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").enable(queue_name="testqueue1", vpn_name="dev_testvpn")
>>> # response = api.rpc(request)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
# Enable the Queue
self.api.x = SolaceXMLBuilder("Enabling Queue %s" % queue_name,
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.queue.name = queue_name
self.api.x.message_spool.queue.no.shutdown.full
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def get(self, **kwargs):
"""Returns a ClientProfile immediately from both appliances
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> response = api.manage("SolaceClientProfile").get(name="default", vpn_name="default")
:param name: name of the profile
:param vpn_name: the name of the vpn to scope the request to
:param details: get more details boolean
:type name: str
:type vpn_name: str
:type details: bool
:rtype: libsolace.SolaceReplyHandler
:returns: dictionary representation of client profile
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
details = get_key_from_kwargs("details", kwargs, default=False)
self.api.x = SolaceXMLBuilder("Get Client Profile",
version=self.api.version)
self.api.x.show.client_profile.name = name
if version_equal_or_greater_than('soltr/6_2', self.api.version):
self.api.x.show.client_profile.vpn_name = vpn_name
if details:
self.api.x.show.client_profile.details
# enqueue to validate
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return self.api.rpc(PluginResponse(str(self.api.x), **kwargs))
def delete_msgs_request(connection=None, queue=None, vpn_name=None):
connection.x = SolaceXMLBuilder("Delete messages in Queue: %s of VPN: %s" %
(queue.strip(), vpn_name),
version=connection.version)
connection.x.admin.message_spool.vpn_name = vpn_name
connection.x.admin.message_spool.delete_messages.queue_name = queue.strip()
return connection.x
def reject_on_discard(self, **kwargs):
""" Reject to sender on discard
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:type vpn_name: str
:type queue_name: str
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").reject_on_discard(vpn_name="dev_testvpn", queue_name="testqueue1")
>>> # response = api.rpc(request)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
self.api.x = SolaceXMLBuilder("Setting Queue to Reject Drops",
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.queue.name = queue_name
self.api.x.message_spool.queue.reject_msg_to_sender_on_discard
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)