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 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_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 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_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 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 list_vpns(self, **kwargs):
"""Returns a list of vpns from first / primary node only
:param vpn_name: the vpn_name or search pattern
:type vpn_name: str
:return:
Example:
>>> api = SolaceAPI("dev")
>>> list_dict = api.manage("SolaceVPN").list_vpns(vpn_name="*")
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Getting list of VPNS",
version=self.api.version)
self.api.x.show.message_vpn.vpn_name = vpn_name
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
response = self.api.rpc(PluginResponse(str(self.api.x), **kwargs))
# response = SolaceReplyHandler(self.api.rpc(str(self.api.x), primaryOnly=True))
# logger.info(response)
return [
vpn['name'] for vpn in response[0]['rpc-reply']['rpc']['show']
['message-vpn']['vpn']
]
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 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 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 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 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 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 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)
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 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 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 shutdown_ingress(self, **kwargs):
"""Shutdown the ingress of a queue
:param shutdown_on_apply: is shutdown permitted boolean or char
:param vpn_name: name of the vpn
:param queue_name: name of the queue
:type shutdown_on_apply: char or bool
:type queue_name: str
:type vpn_name: str
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example 1: Instant Execution:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").shutdown_ingress(shutdown_on_apply=True, vpn_name="dev_testvpn", queue_name="testqueue1")
>>> # response = api.rpc(request)
Example 2: Create Request, then Execute
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").shutdown_ingress(shutdown_on_apply=True, vpn_name="dev_testvpn", queue_name="testqueue1")
>>> # api.rpc(request)
"""
shutdown_on_apply = get_key_from_kwargs("shutdown_on_apply", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
if (shutdown_on_apply
== 'b') or (shutdown_on_apply
== 'q') or (shutdown_on_apply is True):
# Lets only shutdown the egress of the queue
self.api.x = SolaceXMLBuilder("Shutting down egress for 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.shutdown.ingress
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
else:
logger.warning(
"Not disabling Queue, commands could fail since shutdown_on_apply = %s"
% shutdown_on_apply)
def exclusive(self, **kwargs):
"""Set queue exclusivity
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:param exclusive: state
:type vpn_name: str
:type queue_name: str
:type exclusive: bool
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example: Shutdown, Set Exclusive, Start
>>> api = SolaceAPI("dev")
>>> requests = []
>>> requests.append(api.manage("SolaceQueue").shutdown_ingress(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True))
>>> requests.append(api.manage("SolaceQueue").exclusive(queue_name="testqueue1", vpn_name="dev_testvpn", exclusive=False, shutdown_on_apply=True))
>>> requests.append(api.manage("SolaceQueue").enable(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True))
>>> # [api.rpc(x) for x in requests]
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
exclusive = get_key_from_kwargs("exclusive", kwargs)
# Default to NON Exclusive queue
if not exclusive:
self.api.x = SolaceXMLBuilder("Set Queue %s to Non Exclusive " %
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.access_type.non_exclusive
else:
# Non Exclusive queue
self.api.x = SolaceXMLBuilder("Set Queue %s to Exclusive " %
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.access_type.exclusive
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def permission(self, **kwargs):
"""Sets permission on a queue
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:param permission: which permission to grant non-owner users. e.g. "consume", "delete", "modify-topic", "read-only"
:type vpn_name: str
:type queue_name: str
:type permission: str
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").permission(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True, permission="consume")
>>> # api.rpc(request)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
permission = get_key_from_kwargs("permission", kwargs)
# Open Access
self.api.x = SolaceXMLBuilder("Settings Queue %s Permission to %s" %
(queue_name, permission),
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.permission.all
if permission == "consume":
self.api.x.message_spool.queue.permission.consume
elif permission == "delete":
self.api.x.message_spool.queue.permission.delete
elif permission == "modify-topic":
self.api.x.message_spool.queue.permission.modify_topic
elif permission == "read-only":
self.api.x.message_spool.queue.permission.read_only
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def create_user(self, **kwargs):
"""
Create the user
:param username: the username
:type username: str
:param vpn_name: the vpn name
:type vpn_name: str
:rtype: plugin.PluginResponse
:return: SEMP request
"""
username = get_key_from_kwargs('username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
self.api.x = SolaceXMLBuilder("Creating User %s" % username, version=self.api.version)
self.api.x.create.client_username.username = username
self.api.x.create.client_username.vpn_name = vpn_name
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def owner(self, **kwargs):
""" Set the owner
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:param owner: the owner client-username
:type vpn_name: str
:type queue_name: str
:type owner: str
:rtype: plugin.PluginResponse
:returns: single SEMP request
Example:
>>> api = SolaceAPI("dev")
>>> requests = []
>>> requests.append(api.manage("SolaceQueue").shutdown_ingress(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True))
>>> requests.append(api.manage("SolaceQueue").shutdown_egress(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True))
>>> requests.append(api.manage("SolaceQueue").owner(vpn_name="dev_testvpn", queue_name="testqueue1", owner_username="******"))
>>> requests.append(api.manage("SolaceQueue").enable(queue_name="testqueue1", vpn_name="dev_testvpn"))
>>> # [api.rpc(x) for x in requests]
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
owner = get_key_from_kwargs("owner_username", kwargs)
if owner == "%lsVPN":
owner = vpn_name
logger.info("Owner being set to VPN itself: %s" % owner)
# Queue Owner
self.api.x = SolaceXMLBuilder("Set Queue %s owner to %s" %
(queue_name, vpn_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.owner.owner = owner
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def no_subscription_manager(self, **kwargs):
"""
no subscription manager
:param username: the username
:type username: str
:param vpn_name: the vpn name
:type vpn_name: str
:rtype: plugin.PluginResponse
:return: SEMP request
"""
username = get_key_from_kwargs('username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
# No Subscription Managemer
self.api.x = SolaceXMLBuilder("Default User %s subscription manager" % 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.no.subscription_manager
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def consume(self, **kwargs):
"""Sets consume permission. add `consume` kwarg to allow non-owner users to consume.
:param vpn_name: the name of the vpn
:param queue_name: the queue name
:param consume: set to "all" to allow ALL appliance client-users to "consume"
:type vpn_name: str
:type queue_name: str
:type consume: str
:rtype: plugin.PluginResponse
:returns: single SEMP request
.. deprecated:: 2.0
Use :func:`permission` instead.
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").consume(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True, consume="all")
>>> # response = api.rpc(request)
""
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
queue_name = get_key_from_kwargs("queue_name", kwargs)
consume = get_key_from_kwargs("consume", kwargs)
# Open Access
self.api.x = SolaceXMLBuilder(
"Settings Queue %s Permission to Consume" % queue_name,
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.queue.name = queue_name
if consume == "all":
self.api.x.message_spool.queue.permission.all
self.api.x.message_spool.queue.permission.consume
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def no_guarenteed_endpoint(self, **kwargs):
"""
no guaranteed endpoint
:param username: the username
:type username: str
:param vpn_name: the vpn name
:type vpn_name: str
:rtype: plugin.PluginResponse
:return: SEMP request
"""
username = get_key_from_kwargs('username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
# No Guarenteed Endpoint
self.api.x = SolaceXMLBuilder("Default User %s guaranteed endpoint override" % 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.no.guaranteed_endpoint_permission_override
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def new_acl(self, **kwargs):
"""Returns a SEMP request for new ACL profile.
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceACLProfile").new_acl(name="myprofile", vpn_name="dev_testvpn")
>>> # response = api.rpc(request)
:param name: name of the profile
:param vpn_name: vpn name
:rtype: PluginResponse
:returns: single SEMP request
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Profile %s" % name, version=self.api.version)
self.api.x.create.acl_profile.name = name
self.api.x.create.acl_profile.vpn_name = vpn_name
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def get(self, **kwargs):
"""Returns the ACL immediately as a dictionary
:param name: name of the profile
:param vpn_name: vpn name
:returns: tuple SEMP request and kwargs
:rtype: dict
:returns: the acl profile
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Profile %s" % name, version=self.api.version)
self.api.x.show.acl_profile.name = name
self.api.x.show.acl_profile.vpn_name = vpn_name
self.commands.enqueue(self.api.x)
return self.api.rpc(PluginResponse(str(self.api.x), **kwargs))
def test_plugin_response_rpc(self):
p = PluginResponse(
'<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>',
primaryOnly=True)
x = self.solace.rpc(p)
self.assertIsInstance(x, list)
