def allow_bridging(self, **kwargs):
"""Allow bridging
Example:
>>> import libsolace.settingsloader as 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:
>>> import libsolace.settingsloader as 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 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 set_password(self, **kwargs):
"""
Sets the client-user's password
:param client_username: the username
:type client_username: str
:param vpn_name: the vpn name
:type vpn_name: str
:param password: the vpn name
:type password: str
:rtype: plugin.PluginResponse
:returns: SEMP request
"""
client_username = get_key_from_kwargs('client_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" % client_username, version=self.api.version)
self.api.x.client_username.username = client_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 get(self, **kwargs):
"""Returns a VPN from the appliance immediately. This method calls the api instance so it MUST be referenced through the SolaceAPI instance, or passed a `api` kwarg.
:param vpn_name: The name of the VPN
:param detail: return details
:type vpn_name: str
:type detail: bool
:return: dict
Example:
>>> api = SolaceAPI("dev")
>>> dict_vpn = api.manage("SolaceVPN").get(vpn_name="my_vpn", detail=True)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
detail = get_key_from_kwargs("detail", kwargs, default=False)
logging.info("Getting VPN: %s" % vpn_name)
self.api.x = SolaceXMLBuilder("Getting VPN %s" % vpn_name, version=self.api.version)
self.api.x.show.message_vpn.vpn_name = vpn_name
if detail:
self.api.x.show.message_vpn.detail
self.commands.enqueue(self.api.x, **kwargs)
return self.api.rpc(str(self.api.x))
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 delete(self, **kwargs):
"""Delete a client profile
Example:
>>> import libsolace.settingsloader as 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 set_logger_tag(self, **kwargs):
"""Sets the VPN logger tag, default = vpn_name
:param vpn_name: The name of the VPN
:param tag: string to use in logger tag
:type vpn_name: str
:type tag: str
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> request_tuple = api.manage("SolaceVPN").set_logger_tag(vpn_name="my_vpn", tag="my_vpn_string")
>>> response = api.rpc(request_tuple)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
tag = get_key_from_kwargs("tag", kwargs, default=vpn_name)
# logger Tag for this VPN
self.api.x = SolaceXMLBuilder("VPN %s Setting logger tag to %s" %
(vpn_name, vpn_name),
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.event.log_tag.tag_string = tag
self.commands.enqueue(self.api.x, **kwargs)
return (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 set_spool_size(self, **kwargs):
"""Set the maximun spool size for the VPN
:param vpn_name: The name of the VPN
:param max_spool_usage: size in mb
:type vpn_name: str
:type max_spool_usage: int
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> request_tuple = api.manage("SolaceVPN").set_spool_size(vpn_name="my_vpn", max_spool_usage=4096)
>>> response = api.rpc(request_tuple)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
max_spool_usage = get_key_from_kwargs(
"max_spool_usage", kwargs,
self.default_settings['max_spool_usage'])
logger.debug("Setting spool size to %s" % max_spool_usage)
# Set the Spool Size
self.api.x = SolaceXMLBuilder("VPN %s Set spool size to %s" %
(vpn_name, max_spool_usage),
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.max_spool_usage.size = max_spool_usage
self.commands.enqueue(self.api.x, **kwargs)
return (str(self.api.x), kwargs)
def set_large_message_threshold(self, **kwargs):
"""Sets the large message threshold
:param vpn_name: The name of the VPN
:param large_message_threshold: size in bytes
:type vpn_name: str
:type large_message_threshold: int
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> request_tuple = api.manage("SolaceVPN").set_large_message_threshold(vpn_name="my_vpn", large_message_threshold=4096)
>>> response = api.rpc(request_tuple)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
large_message_threshold = get_key_from_kwargs(
"large_message_threshold", kwargs,
self.default_settings["large_message_threshold"])
# Large Message Threshold
self.api.x = SolaceXMLBuilder(
"VPN %s Settings large message threshold event to %s" %
(vpn_name, large_message_threshold),
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.event.large_message_threshold.size = large_message_threshold
self.commands.enqueue(self.api.x, **kwargs)
return (str(self.api.x), kwargs)
def create_user(self, **kwargs):
"""
Create client-user
Example
>>> api = SolaceAPI("dev")
>>> xml = api.manage("SolaceUser").create_user(client_username="******", vpn_name="bar", force=True)
>>> xml.xml
'<rpc semp-version="soltr/7_1_1"><create><client-username><username>foo</username><vpn-name>bar</vpn-name></client-username></create></rpc>'
:param client_username: the username
:type client_username: str
:param vpn_name: the vpn name
:type vpn_name:str
:rtype: plugin.PluginResponse
:returns: SEMP request
"""
client_username = get_key_from_kwargs('client_username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
self.api.x = SolaceXMLBuilder("New User %s" % client_username, version=self.api.version)
self.api.x.create.client_username.username = client_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 delete(self, **kwargs):
"""
Delete a client user
Example
>>> connection = SolaceAPI("dev")
>>> connection.manage("SolaceUser").delete(client_username="******", vpn_name="bar", force=True, skip_before=True).xml
'<rpc semp-version="soltr/7_1_1"><no><client-username><username>foo</username><vpn-name>bar</vpn-name></client-username></no></rpc>'
:param client_username: the username
:type client_username: str
:param vpn_name: the vpn name
:type vpn_name: str
:rtype: plugin.PluginResponse
:returns: SEMP request
"""
client_username = get_key_from_kwargs("client_username", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Delete User %s" % client_username, version=self.api.version)
self.api.x.no.client_username.username = client_username
self.api.x.no.client_username.vpn_name = vpn_name
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 permission override
Example:
>>> api = SolaceAPI("dev", version="soltr/7_1_1")
>>> request = api.manage("SolaceUser").no_guarenteed_endpoint(client_username="******", vpn_name="bar")
>>> request.xml
'<rpc semp-version="soltr/7_1_1"><client-username><username>foo</username><vpn-name>bar</vpn-name><no><guaranteed-endpoint-permission-override/></no></client-username></rpc>'
:param client_username: the username
:type client_username: str
:param vpn_name: the vpn name
:type vpn_name: str
:rtype: plugin.PluginResponse
:returns: SEMP request
"""
client_username = get_key_from_kwargs('client_username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
# No Guarenteed Endpoint
self.api.x = SolaceXMLBuilder("Default User %s guaranteed endpoint override" % client_username,
version=self.api.version)
self.api.x.client_username.username = client_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 get(self, **kwargs):
"""Returns a VPN from the appliance immediately. This method calls the api instance so it MUST be referenced through the SolaceAPI instance, or passed a `api` kwarg.
:param vpn_name: The name of the VPN
:param detail: return details
:type vpn_name: str
:type detail: bool
:return: dict
Example:
>>> api = SolaceAPI("dev")
>>> dict_vpn = api.manage("SolaceVPN").get(vpn_name="my_vpn", detail=True)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
detail = get_key_from_kwargs("detail", kwargs, default=False)
logger.info("Getting VPN: %s" % vpn_name)
self.api.x = SolaceXMLBuilder("Getting VPN %s" % vpn_name,
version=self.api.version)
self.api.x.show.message_vpn.vpn_name = vpn_name
if detail:
self.api.x.show.message_vpn.detail
self.commands.enqueue(self.api.x, **kwargs)
return self.api.rpc(str(self.api.x))
def no_subscription_manager(self, **kwargs):
"""
No subscription manager
Example:
>>> api = SolaceAPI("dev", version="soltr/7_1_1")
>>> request = api.manage("SolaceUser").no_subscription_manager(client_username="******", vpn_name="bar")
>>> request.xml
'<rpc semp-version="soltr/7_1_1"><client-username><username>foo</username><vpn-name>bar</vpn-name><no><subscription-manager/></no></client-username></rpc>'
:param client_username: the username
:type client_username: str
:param vpn_name: the vpn name
:type vpn_name: str
:rtype: plugin.PluginResponse
:returns: SEMP request
"""
client_username = get_key_from_kwargs('client_username', kwargs)
vpn_name = get_key_from_kwargs('vpn_name', kwargs)
# No Subscription Managemer
self.api.x = SolaceXMLBuilder("Default User %s subscription manager" % client_username,
version=self.api.version)
self.api.x.client_username.username = client_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 set_logging_tag(self, **kwargs):
"""Sets the VPN logging tag, default = vpn_name
:param vpn_name: The name of the VPN
:param tag: string to use in logging tag
:type vpn_name: str
:type tag: str
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> request_tuple = api.manage("SolaceVPN").set_logging_tag(vpn_name="my_vpn", tag="my_vpn_string")
>>> response = api.rpc(request_tuple)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
tag = get_key_from_kwargs("tag", kwargs, default=vpn_name)
# Logging Tag for this VPN
self.api.x = SolaceXMLBuilder("VPN %s Setting logging tag to %s" % (vpn_name, vpn_name),
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.event.log_tag.tag_string = tag
self.commands.enqueue(self.api.x, **kwargs)
return (str(self.api.x), kwargs)
def set_large_message_threshold(self, **kwargs):
"""Sets the large message threshold
:param vpn_name: The name of the VPN
:param large_message_threshold: size in bytes
:type vpn_name: str
:type large_message_threshold: int
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> request_tuple = api.manage("SolaceVPN").set_large_message_threshold(vpn_name="my_vpn", large_message_threshold=4096)
>>> response = api.rpc(request_tuple)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
large_message_threshold = get_key_from_kwargs("large_message_threshold", kwargs,
self.default_settings["large_message_threshold"])
# Large Message Threshold
self.api.x = SolaceXMLBuilder(
"VPN %s Settings large message threshold event to %s" % (vpn_name, large_message_threshold),
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.event.large_message_threshold.size = large_message_threshold
self.commands.enqueue(self.api.x, **kwargs)
return (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 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 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))
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 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 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 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 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 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 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 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 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 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 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:
logging.warning(
"Not disabling User, commands could fail since shutdown_on_apply = %s" % self.shutdown_on_apply)
return None
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 allow_transacted_sessions(self, **kwargs):
"""Allow transaction sessions permission
Example:
>>> import libsolace.settingsloader as 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 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_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 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 get(self, **kwargs):
"""Returns a ClientProfile immediately from both appliances
Example:
>>> import libsolace.settingsloader as 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 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_spool_size(self, **kwargs):
"""Set the maximun spool size for the VPN
:param vpn_name: The name of the VPN
:param max_spool_usage: size in mb
:type vpn_name: str
:type max_spool_usage: int
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> request_tuple = api.manage("SolaceVPN").set_spool_size(vpn_name="my_vpn", max_spool_usage=4096)
>>> response = api.rpc(request_tuple)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
max_spool_usage = get_key_from_kwargs("max_spool_usage", kwargs, self.default_settings['max_spool_usage'])
logging.debug("Setting spool size to %s" % max_spool_usage)
# Set the Spool Size
self.api.x = SolaceXMLBuilder("VPN %s Set spool size to %s" % (vpn_name, max_spool_usage),
version=self.api.version)
self.api.x.message_spool.vpn_name = vpn_name
self.api.x.message_spool.max_spool_usage.size = max_spool_usage
self.commands.enqueue(self.api.x, **kwargs)
return (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 __init__(self, **kwargs):
"""Initialize in Query or Batch mode
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> client = SolaceAPI("dev")
>>> client.manage("SolaceClientProfile", name="myprofile", vpn_name="testvpn").commands.commands
[XML, XML, XML]
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
Optional (Batch/Provision) Mode
:param name: the name of the profile
:param vpn_name: name of the VPN to scope the ACL to
:param defaults: dictionary of defaults
:param max_clients: max clients sharing a username connection limit
:type api: SolaceAPI
:type name: str
:type vpn_name: str
:type defaults: dict
:type max_clients: int
:returns: instance with batch requests on SolaceACLProfile.commands.commands
:rtype: SolaceClientProfile
"""
self.api = get_key_from_kwargs("api", kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
return
if not "name" in kwargs:
logger.info("No name kwarg, assuming query mode")
return
self.name = get_key_from_kwargs('name', kwargs)
self.vpn_name = get_key_from_kwargs('vpn_name', kwargs)
self.defaults = get_key_from_kwargs('defaults',
kwargs,
default=self.defaults)
self.max_clients = get_key_from_kwargs(
'max_clients', kwargs, default=self.defaults.get("max_clients"))
if kwargs.get('options', None) is None:
logger.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance"
)
self.new_client_profile(**kwargs)
self.allow_consume(**kwargs)
self.allow_send(**kwargs)
self.allow_endpoint_create(**kwargs)
self.allow_transacted_sessions(**kwargs)
def __init__(self, **kwargs):
if kwargs == {}:
return
# decorator, for caching decorator creates and set this property, Missing exception is used also, so leave
# completely unassigned. this line is just here for reference.
# self.exists = None
# get the connection SolaceAPI instance
self.api = get_key_from_kwargs("api", kwargs)
# create a commandqueue instance for queuing up XML and validating
self.commands = SolaceCommandQueue(version=self.api.version)
if not "vpn_name" in kwargs:
logger.info("No vpn_name kwarg, assuming query mode")
else:
self.vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.owner_username = get_key_from_kwargs("owner_username",
kwargs,
default=self.vpn_name)
self.acl_profile = get_key_from_kwargs("acl_profile",
kwargs,
default=self.vpn_name)
self.options = None
logger.debug("Creating vpn in env: %s vpn: %s, kwargs: %s" %
(self.api.environment, self.vpn_name, kwargs))
# set defaults
for k, v in self.default_settings.items():
logger.info("Setting Key: %s to %s" % (k, v))
setattr(self, k, v)
# use kwargs to tune defaults
for k, v in self.default_settings.items():
if k in kwargs:
logger.info("Overriding Key: %s to %s" % (k, kwargs[k]))
setattr(self, k, kwargs[k])
# backwards compatibility for None options passed to still execute "add" code
if self.options is None:
logger.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance"
)
# stack the commands
self.create_vpn(**kwargs)
self.clear_radius(**kwargs)
self.set_internal_auth(**kwargs)
self.set_spool_size(**kwargs)
self.set_large_message_threshold(**kwargs)
self.set_logger_tag(**kwargs)
self.enable_vpn(**kwargs)
def __init__(self, **kwargs):
"""Initialize in Query or Batch mode
Example:
>>> import libsolace.settingsloader as settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> client = SolaceAPI("dev")
>>> client.manage("SolaceClientProfile", name="myprofile", vpn_name="testvpn").commands.commands
[XML, XML, XML]
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
Optional (Batch/Provision) Mode
:param name: the name of the profile
:param vpn_name: name of the VPN to scope the ACL to
:param defaults: dictionary of defaults
:param max_clients: max clients sharing a username connection limit
:type api: SolaceAPI
:type name: str
:type vpn_name: str
:type defaults: dict
:type max_clients: int
:returns: instance with batch requests on SolaceACLProfile.commands.commands
:rtype: SolaceClientProfile
"""
self.api = get_key_from_kwargs("api", kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
return
if not "name" in kwargs:
logging.info("No name kwarg, assuming query mode")
return
self.name = get_key_from_kwargs("name", kwargs)
self.vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.defaults = get_key_from_kwargs("defaults", kwargs, default=self.defaults)
self.max_clients = get_key_from_kwargs("max_clients", kwargs, default=self.defaults.get("max_clients"))
if kwargs.get("options", None) is None:
logging.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance"
)
self.new_client_profile(**kwargs)
self.allow_consume(**kwargs)
self.allow_send(**kwargs)
self.allow_endpoint_create(**kwargs)
self.allow_transacted_sessions(**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))
# logging.info(response)
return [vpn['name'] for vpn in response[0]['rpc-reply']['rpc']['show']['message-vpn']['vpn']]
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 clear_radius(self, **kwargs):
"""Clears radius authentication mechanism
: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").clear_radius(vpn_name="my_vpn")
>>> response = api.rpc(tuple_request)
Example 2:
>>> api = SolaceAPI("dev")
>>> response = api.rpc(api.manage("SolaceVPN").clear_radius(vpn_name="my_vpn"))
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
# Switch Radius Domain to nothing
self.api.x = SolaceXMLBuilder("VPN %s Clearing Radius" % vpn_name,
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.authentication.user_class.client
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.message_vpn.authentication.user_class.basic.radius_domain.radius_domain
else:
self.api.x.message_vpn.authentication.user_class.radius_domain.radius_domain
self.commands.enqueue(self.api.x, **kwargs)
return (str(self.api.x), kwargs)
def create_vpn(self, **kwargs):
"""New VPN SEMP Request generator.
: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").create_vpn(vpn_name="my_vpn")
>>> response = api.rpc(tuple_request)
Example2:
>>> api = SolaceAPI("dev")
>>> response = api.rpc(api.manage("SolaceVPN").create_vpn(vpn_name="my_vpn"))
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
# Create domain-event VPN, this can fail if VPN exists, but thats ok.
self.api.x = SolaceXMLBuilder('VPN Create new VPN %s' % vpn_name,
version=self.api.version)
self.api.x.create.message_vpn.vpn_name = vpn_name
self.commands.enqueue(self.api.x, **kwargs)
self.set_exists(True)
return (str(self.api.x), kwargs)
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 check_acl_profile_exists(self, **kwargs):
"""
Checks if a acl_profiles exists on the appliance.
Example:
>>> api = SolaceAPI("dev")
>>> client = api.manage("SolaceUser")
>>> client.check_acl_profile_exists(acl_profile="myacl")
False
:param acl_profile: the client profile to check
:type acl_profile: str
:rtype: bool
:returns: true or false
"""
acl_profile = get_key_from_kwargs('acl_profile', kwargs)
logging.info('Checking if acl_profile is present on devices')
self.api.x = SolaceXMLBuilder("Checking acl_profile %s is present on device" % acl_profile,
version=self.api.version)
self.api.x.show.acl_profile.name = acl_profile
response = self.api.rpc(str(self.api.x), allowfail=False)
# logging.info(response)
for v in response:
if v['rpc-reply']['rpc']['show']['acl-profile']['acl-profiles'] == None:
logging.warning('acl_profile: %s missing from appliance' % acl_profile)
return False
return True
def enable_vpn(self, **kwargs):
"""Enable a VPN
:param vpn_name: The name of the VPN
:type vpn_name: str
:return: tuple SEMP request and kwargs
Example:
>>> api = SolaceAPI("dev")
>>> request_tuple = api.manage("SolaceVPN").enable_vpn(vpn_name="my_vpn")
>>> response = api.rpc(request_tuple)
"""
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
# Enable the VPN
self.api.x = SolaceXMLBuilder("VPN %s Enabling the vpn" % vpn_name,
version=self.api.version)
self.api.x.message_vpn.vpn_name = vpn_name
self.api.x.message_vpn.no.shutdown
self.commands.enqueue(self.api.x, **kwargs)
return (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 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)
logging.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':
logging.warning('client_profile: %s missing from appliance' % client_profile)
raise BaseException("no such client_profile %s" % client_profile)
return False
return True
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 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)