def generateXML(vpn_name=None, queues=None):
"""
:param vpn_name: string name of vpn
:param queues: list of queues to manipulate
:return: commands
"""
# commandQueue is used to stack and validate solace commands
commands = SolaceCommandQueue()
try:
for queue in queues:
# Full Shutdown
'''
<rpc xmlns="http://www.solacesystems.com/semp/topic_routing/6_0">
<admin>
<message-spool>
<vpn-name>dev_domainevent</vpn-name>
<delete-messages>
<queue-name>testqueue</queue-name>
</delete-messages>
</message-spool>
</admin>
</rpc>
'''
cmd = SolaceXMLBuilder("Delete messages in Queue: %s of VPN: %s" % (queue.strip(), vpn_name))
cmd.admin.message_spool.vpn_name = vpn_name
cmd.admin.message_spool.delete_messages.queue_name = queue.strip()
commands.enqueue(cmd)
except Exception, e:
print("Error %s" % e)
def validate_the_plan(connection=None, vpn_name=None, queues=None):
"""
:param connection: the connection instance
:param vpn_name: string name of vpn
:param queues: list of queues to manipulate
:return: commands
"""
# commandQueue is used to stack and validate solace commands
commands = SolaceCommandQueue(version=connection.version)
try:
for queue in queues:
# Delete Messages
'''
<rpc xmlns="http://www.solacesystems.com/semp/topic_routing/6_0">
<admin>
<message-spool>
<vpn-name>dev_domainevent</vpn-name>
<delete-messages>
<queue-name>testqueue</queue-name>
</delete-messages>
</message-spool>
</admin>
</rpc>
'''
cmd = delete_msgs_request(connection=connection, queue=queue, vpn_name=vpn_name)
commands.enqueue(cmd)
except Exception, e:
print("Error %s" % e)
raise
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,
testmode=True,
shutdown_on_apply=False,
options=None,
version=None,
**kwargs):
""" Init user object
:type testmode: boolean
:type shutdown_on_apply: boolean
:type options: OptionParser
:type version: string
"""
logger.debug("options: %s" % options)
self.cq = SolaceCommandQueue(version=version)
self.primaryCluster = SolaceAPI(options.primary,
testmode=testmode,
version=version)
self.drCluster = SolaceAPI(options.backup,
testmode=testmode,
version=version)
self.vpns = []
for vpn in options.vpns:
try:
self.vpns.append(vpn % options.environment)
except Exception, e:
self.vpns.append(vpn)
def generateXMLForManagingRejectMsgToSenderOnDiscard(
vpn_name=None, queues=None, reject_msg_to_sender_on_discard=False):
"""
:param vpn_name: string name of vpn
:param queues: list of queues to manipulate
:return: commands
"""
# commandQueue is used to stack and validate solace commands
commands = SolaceCommandQueue()
try:
for queue in queues:
# Disable reject-msg-to-sender-on-discard
'''
<rpc xmlns="http://www.solacesystems.com/semp/topic_routing/6_0">
<message-spool>
<vpn-name>dev_domainevent</vpn-name>
<queue>
<name>unibet.TestStatusChangedEvents.customertest</name>
<no>
<reject-msg-to-sender-on-discard/>
</no>
</queue>
</message-spool>
</rpc>
'''
if reject_msg_to_sender_on_discard:
prefix = "Enabling"
else:
prefix = "Disabling"
cmd = SolaceXMLBuilder(
"%s reject-msg-to-sender-on-discard for queue: %s" %
(prefix, queue))
cmd.message_spool.vpn_name = vpn_name
cmd.message_spool.queue.name = queue
if reject_msg_to_sender_on_discard:
cmd.message_spool.queue.reject_msg_to_sender_on_discard
else:
cmd.message_spool.queue.no.reject_msg_to_sender_on_discard
commands.enqueue(cmd)
except Exception, e:
print("Error %s" % e)
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 __init__(self, *args, **kwargs):
"""Initialize in Query or Batch mode
Example:
>>> from libsolace.SolaceAPI import SolaceAPI
>>> client = SolaceAPI("dev")
>>> client.manage("SolaceACLProfile", name="myprofile", vpn_name="testvpn").commands.commands
[XML, XML, XML]
:type api: SolaceAPI
:param api: the api (passed in automatically if instantiated via SolaceAPI.manage
Optional (Batch/Provision) Mode
:type name: str
:param name: the name of the ACL Profile
:type vpn_name: str
:param vpn_name: the vpn name
:rtype: SolaceACLProfile
:returns: instance with batch requests on SolaceACLProfile.commands.commands
"""
self.api = get_key_from_kwargs("api", kwargs) #: SolaceAPI instance
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
return
self.name = get_key_from_kwargs('name', kwargs)
self.vpn_name = get_key_from_kwargs('vpn_name', kwargs)
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")
# queue up the commands
self.new_acl(**kwargs)
self.allow_publish(**kwargs)
self.allow_subscribe(**kwargs)
self.allow_connect(**kwargs)
def generateXMLForManagingRejectMsgToSenderOnDiscard(vpn_name=None, queues=None, reject_msg_to_sender_on_discard=False):
"""
:param vpn_name: string name of vpn
:param queues: list of queues to manipulate
:return: commands
"""
# commandQueue is used to stack and validate solace commands
commands = SolaceCommandQueue()
try:
for queue in queues:
# Disable reject-msg-to-sender-on-discard
'''
<rpc xmlns="http://www.solacesystems.com/semp/topic_routing/6_0">
<message-spool>
<vpn-name>dev_domainevent</vpn-name>
<queue>
<name>unibet.TestStatusChangedEvents.customertest</name>
<no>
<reject-msg-to-sender-on-discard/>
</no>
</queue>
</message-spool>
</rpc>
'''
if reject_msg_to_sender_on_discard:
prefix = "Enabling"
else:
prefix = "Disabling"
cmd = SolaceXMLBuilder("%s reject-msg-to-sender-on-discard for queue: %s" % (prefix,queue))
cmd.message_spool.vpn_name = vpn_name
cmd.message_spool.queue.name = queue
if reject_msg_to_sender_on_discard:
cmd.message_spool.queue.reject_msg_to_sender_on_discard
else:
cmd.message_spool.queue.no.reject_msg_to_sender_on_discard
commands.enqueue(cmd)
except Exception, e:
print("Error %s" % e)
def __init__(self, **kwargs):
"""
General tools plugin, invoke as any other plugin. May have dependencies to other plugins.
:param api: the SolaceAPI instance, settings object will be used from SolaceAPI.
:param kwargs:
:return:
"""
self.api = get_key_from_kwargs('api', kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
self.settings = self.api.settings
self.SOLACE_QUEUE_PLUGIN = self.settings["SOLACE_QUEUE_PLUGIN"]
self.SOLACE_USER_PLUGIN = self.settings["SOLACE_USER_PLUGIN"]
def validate_the_plan(connection=None, vpn_name=None, queues=None):
"""
:param connection: the connection instance
:param vpn_name: string name of vpn
:param queues: list of queues to manipulate
:return: commands
"""
# commandQueue is used to stack and validate solace commands
commands = SolaceCommandQueue(version=connection.version)
try:
for queue in queues:
# Delete Messages
'''
<rpc xmlns="http://www.solacesystems.com/semp/topic_routing/6_0">
<admin>
<message-spool>
<vpn-name>dev_domainevent</vpn-name>
<delete-messages>
<queue-name>testqueue</queue-name>
</delete-messages>
</message-spool>
</admin>
</rpc>
'''
cmd = delete_msgs_request(connection=connection,
queue=queue,
vpn_name=vpn_name)
commands.enqueue(cmd)
except Exception, e:
print("Error %s" % e)
raise
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:
logging.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
logging.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():
logging.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:
logging.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:
logging.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_logging_tag(**kwargs)
self.enable_vpn(**kwargs)
def __init__(self, *args, **kwargs):
"""Initialize in Query or Batch mode
Example:
>>> from libsolace.SolaceAPI import SolaceAPI
>>> client = SolaceAPI("dev")
>>> client.manage("SolaceACLProfile", name="myprofile", vpn_name="testvpn").commands.commands
[XML, XML, XML]
:type api: SolaceAPI
:param api: the api (passed in automatically if instantiated via SolaceAPI.manage
Optional (Batch/Provision) Mode
:type name: str
:param name: the name of the ACL Profile
:type vpn_name: str
:param vpn_name: the vpn name
:rtype: SolaceACLProfile
:returns: instance with batch requests on SolaceACLProfile.commands.commands
"""
self.api = get_key_from_kwargs("api", kwargs) #: SolaceAPI instance
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
return
self.name = get_key_from_kwargs('name', kwargs)
self.vpn_name = get_key_from_kwargs('vpn_name', kwargs)
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")
# queue up the commands
self.new_acl(**kwargs)
self.allow_publish(**kwargs)
self.allow_subscribe(**kwargs)
self.allow_connect(**kwargs)
class SolaceClientProfile(Plugin):
"""Create / Manage client profiles
This plugin manages Client Profiles within Solace. Typically you should invoke this plugin via :class:`libsolace.SolaceAPI.SolaceAPI`
Please see :class:`libsolace.plugin.Plugin` for how plugins are instantiated and used.
Example of direct instantiation and passing in a instance SolaceAPI
>>> from libsolace.settingsloader import settings
>>> import libsolace
>>> from libsolace.SolaceAPI import SolaceAPI
>>> clazz = libsolace.plugin_registry("SolaceClientProfile", settings=settings)
>>> api = SolaceAPI("dev")
>>> scp = clazz(settings=settings, api=api)
>>> client_dict = scp.get(api=api, name="default", vpn_name="default")
Example of Instantiation via the SolaceAPI manage method
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> scp = api.manage("SolaceClientProfile")
>>> client_dict = scp.get(api=api, name="default", vpn_name="default")
>>> list_xml = api.manage("SolaceClientProfile", name="myprofile", vpn_name="dev_testvpn").commands.commands
"""
plugin_name = "SolaceClientProfile"
defaults = {"max_clients": 1000}
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 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))
# @only_if_not_exists('get', 'rpc-reply.rpc.show.message-vpn.vpn')
def new_client_profile(self, **kwargs):
"""Create a new client profile
Enqueues the request in self.commands and returns the SEMP request via PluginResponse.
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> plugin_response = api.manage("SolaceClientProfile").new_client_profile(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: dictionary representation of client profile
:rtype: plugin.PluginResponse
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Create Client Profile",
version=self.api.version)
self.api.x.create.client_profile.name = name
if version_equal_or_greater_than('soltr/6_2', self.api.version):
self.api.x.create.client_profile.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 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_consume(self, **kwargs):
"""Allow consume permission
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> plugin_response = api.manage("SolaceClientProfile").allow_consume(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("Allow profile consume",
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_guaranteed_message_receive
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def allow_send(self, **kwargs):
"""Allow send permission
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> plugin_response = api.manage("SolaceClientProfile").allow_send(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("Allow profile send",
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_guaranteed_message_send
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def allow_endpoint_create(self, **kwargs):
"""Allow endpoint creation permission
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceClientProfile").allow_endpoint_create(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 endpoint create",
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_guaranteed_endpoint_create
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 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)
class SolaceAPI:
"""
Connects to a Solace cluster's *primary* and *backup* appliance(s)
a SolaceAPI instance contains a SolaceXMLBuilder and a SolaceCommandQueue
in order to facilitate the generation of SEMP XML requests, enqueuing the XML
requests, and sending them to the appliance(s) through the rpc(str) method.
SolaceAPI connects to **both** appliances in a redundant pair setup and gets
the the *primary* and *backup* node states. Typically you issue the same SEMP
command to both appliances. Commands can also be issued to either the primary
or the backup appliance utilizing the `primaryOnly` and `backupOnly` kwargs.
see: :func:`~libsolace.SolaceAPI.SolaceAPI.rpc`
The version of the SolOS-TR OS is detected on automatically, and this behaviour
can be overridden with the `version` kwarg. If using the VMR you will want to
pass in both detect_status=False and version="soltr/7_1_1".
:keyword environment: the environemnt
:type environment: str
:keyword detect_status: detection of node primary/backup status, pass True
here for the VMR or single appliances.
:type detect_status: bool
:keyword version: override appliance version detection. Some versions of SolOS-TR
require you to set the language level a bit higher like the VMR for example.
:type version: str
:keyword testmode: Tells the api to connect using the READ_ONLY_USER as defined
in the libsolace.yaml file.
:type testmode: bool
:keyword setting_overrides: dictionary containing overrides for the settings in
`libsolace.yaml`. Any key configured in this parameter will take precedence
over keys specified in `libsolace.yaml`.
:type setting_overrides: dict
:rtype: SolaceAPI.SolaceAPI
:returns: instance
Examples:
>>> from libsolace.SolaceXMLBuilder import SolaceXMLBuilder
>>> api = SolaceAPI("dev")
>>> api.x = SolaceXMLBuilder("LOG: Showing the Message Spool in %s" % api.environment, version=api.version)
>>> api.x.show.message_spool.detail
OrderedDict()
>>> response = api.rpc(api.x)
Setting the API version if detection fails
>>> from libsolace.SolaceXMLBuilder import SolaceXMLBuilder
>>> api = SolaceAPI("dev", version="soltr/7_1_1")
>>> api.x = SolaceXMLBuilder("My description of what im doing", version=api.version)
>>> api.x.show.message_spool
OrderedDict()
>>> response = api.rpc(api.x, primaryOnly=True)
>>> response[0]['rpc-reply']['rpc']['show']['message-spool']['message-spool-info']['config-status']
u'Enabled (Primary)'
Query the backup appliance only
>>> from libsolace.SolaceXMLBuilder import SolaceXMLBuilder
>>> api = SolaceAPI("dev", detect_status=False)
>>> api.x = SolaceXMLBuilder("My Something something", version=api.version)
>>> api.x.show.version
OrderedDict()
>>> r = api.rpc(api.x, backupOnly=True)
>>> # check the response was the "configured" backup
>>> r[0]['HOST'] == settings["SOLACE_CONF"]["dev"]['MGMT'][1]
True
Get a instance of some plugin from the plugin manager
>>> api = SolaceAPI("dev")
>>> type(api.manage("NullPlugin"))
<class 'libsolace.items.NullPlugin.NullPlugin'>
"""
def __init__(self,
environment,
version=None,
detect_status=True,
testmode=False,
setting_overrides=None,
**kwargs):
try:
logger.info("Solace Client SEMP version: %s", version)
self.version = version
self.settings = settings
setting_overrides = [] if setting_overrides is None else setting_overrides
self.settings.update(setting_overrides)
self.config = self.settings["SOLACE_CONF"][environment]
self.environment = environment
logger.info("Connecting to appliances %s in %s",
self.config['MGMT'], environment)
logger.debug("Loaded Config: %s", self.config)
# testmode sets the user to the RO user
self.testmode = testmode
if self.testmode:
self.config['USER'] = self.settings["READ_ONLY_USER"]
self.config['PASS'] = self.settings["READ_ONLY_PASS"]
logger.info('READONLY mode')
# for SSL / TLS
if 'VERIFY_SSL' not in self.config:
self.config['VERIFY_SSL'] = True
# detect primary / backup node instance states or assume
# 1st node is primary and second is backup
self.detect_status = detect_status
if self.detect_status:
logger.info("Detecting primary and backup node states")
self.status = self.get_message_spool(**kwargs)
self.primaryRouter = None
self.backupRouter = None
for node in self.status:
result = self.__detect_state(node)
if result == 'Primary':
self.primaryRouter = node['HOST']
elif result == 'Backup':
self.backupRouter = node['HOST']
if self.primaryRouter is None:
raise Exception("Failed to detect primary router")
if self.backupRouter is None:
raise Exception("Failed to detect backup router")
if self.primaryRouter == self.backupRouter:
# impossible to test, but possible to happen...
raise Exception(
"Error, detected router %s to be both primary and backup",
self.primaryRouter)
logger.info("Detected primary Router: %s", self.primaryRouter)
logger.info("Detected backup Router: %s", self.backupRouter)
else:
logger.info("Not detecting statuses, using config")
try:
self.primaryRouter = self.config['MGMT'][0]
except Exception, e:
logger.error("No routers")
raise
try:
self.backupRouter = self.config['MGMT'][1]
except IndexError, e:
logger.warn("No second router in config")
kwargs["primaryOnly"] = True
kwargs["backupOnly"] = False
pass
# if the version is NOT specified, query appliance versions
# assumes that backup and primary are SAME firmware version.s
if version == None:
logger.debug("Detecting Version")
self.xmlbuilder = SolaceXMLBuilder(
"Detecting SolOS-TR Version", version="soltr/5_0")
self.xmlbuilder.show.version
result = self.rpc(str(self.xmlbuilder), **kwargs)
self.version = result[0]['rpc-reply']['@semp-version']
else:
logger.info("Override SolOS-TR Version: %s", version)
self.version = version
logger.info("SolOS-TR Version: %s", self.version)
# backwards compatibility
# self.xmlbuilder = SolaceXMLBuilder(version=self.version)
# shortcut / new methods
self.x = SolaceXMLBuilder("XML Buider", version=self.version)
self.cq = SolaceCommandQueue(version=self.version)
class SolaceACLProfile(Plugin):
""" Plugin to manage AclProfiles
Description
===========
This plugin manages ACL Profiles within Solace. Typically you should invoke this plugin via :class:`libsolace.SolaceAPI.SolaceAPI`
Please see :class:`libsolace.plugin.Plugin` for how plugins are instantiated and used.
"""
plugin_name = "SolaceACLProfile"
def __init__(self, *args, **kwargs):
"""Initialize in Query or Batch mode
Example:
>>> from libsolace.SolaceAPI import SolaceAPI
>>> client = SolaceAPI("dev")
>>> client.manage("SolaceACLProfile", name="myprofile", vpn_name="testvpn").commands.commands
[XML, XML, XML]
:type api: SolaceAPI
:param api: the api (passed in automatically if instantiated via SolaceAPI.manage
Optional (Batch/Provision) Mode
:type name: str
:param name: the name of the ACL Profile
:type vpn_name: str
:param vpn_name: the vpn name
:rtype: SolaceACLProfile
:returns: instance with batch requests on SolaceACLProfile.commands.commands
"""
self.api = get_key_from_kwargs("api", kwargs) #: SolaceAPI instance
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
return
self.name = get_key_from_kwargs('name', kwargs)
self.vpn_name = get_key_from_kwargs('vpn_name', kwargs)
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")
# queue up the commands
self.new_acl(**kwargs)
self.allow_publish(**kwargs)
self.allow_subscribe(**kwargs)
self.allow_connect(**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 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 allow_publish(self, **kwargs):
"""Allow publish
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceACLProfile").allow_publish(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("Allow Publish %s" % 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.publish_topic.default_action.allow
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 allow_connect(self, **kwargs):
""" Allow Connect
: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")
>>> # response = 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 connect 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.client_connect.default_action.allow
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
class SolaceVPN(Plugin):
"""Manage a Solace VPN
If `vpn_name` is passed as a kwarg, this plugin enters provision/batch mode, if it is omitted, the plugin will go into
single query mode.
In provision/batch mode, this plugin generates all the neccesary SEMP requests to create a VPN. You also need to pass a
`owner_name` and a existing `acl_profile` name. If these are omitted, the vpn_name property is used.
In single query mode, this plugin creates single SEMP requests, you need only pass a SolaceAPI into `api`, or invoke
via SolaceAPI("dev").manage("SolaceVPN")
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
:param vpn_name: name of the VPN to scope the ACL to
:type api: SolaceAPI
:type vpn_name: str
:rtype: SolaceVPN
Query/Single Mode Example Direct Access:
>>> import libsolace.settingsloader as settings
>>> import libsolace
>>> from libsolace.SolaceAPI import SolaceAPI
>>> clazz = libsolace.plugin_registry("SolaceVPN", settings=settings)
>>> api = SolaceAPI("dev")
>>> solaceVpnPlugin = clazz(settings=settings, api=api)
>>> list_of_dicts = solaceVpnPlugin.get(vpn_name="default")
Provision/Batch Mode Example via SolaceAPI
>>> api = SolaceAPI("dev")
>>> vpn = api.manage("SolaceVPN", vpn_name="my_vpn", owner_name="someuser", acl_profile="default", max_spool_usage=1024)
>>> #for req in vpn.commands.commands:
>>> # api.rpc(str(req[0]), **req[1])
"""
plugin_name = "SolaceVPN"
api = "None"
default_settings = {'max_spool_usage': 4096,
'large_message_threshold': 4096}
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:
logging.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
logging.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():
logging.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:
logging.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:
logging.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_logging_tag(**kwargs)
self.enable_vpn(**kwargs)
@only_if_not_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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 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))
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", '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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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))
# logging.info(response)
return [vpn['name'] for vpn in response[0]['rpc-reply']['rpc']['show']['message-vpn']['vpn']]
def __getitem__(self, k):
return self.__dict__[k]
class SolaceClientProfile(Plugin):
"""Create / Manage client profiles
This plugin manages Client Profiles within Solace. Typically you should invoke this plugin via :class:`libsolace.SolaceAPI.SolaceAPI`
Please see :class:`libsolace.plugin.Plugin` for how plugins are instantiated and used.
Example of direct instantiation and passing in a instance SolaceAPI
>>> import libsolace.settingsloader as settings
>>> import libsolace
>>> from libsolace.SolaceAPI import SolaceAPI
>>> clazz = libsolace.plugin_registry("SolaceClientProfile", settings=settings)
>>> api = SolaceAPI("dev")
>>> scp = clazz(settings=settings, api=api)
>>> client_dict = scp.get(api=api, name="default", vpn_name="default")
Example of Instantiation via the SolaceAPI manage method
>>> import libsolace.settingsloader as settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> scp = api.manage("SolaceClientProfile")
>>> client_dict = scp.get(api=api, name="default", vpn_name="default")
>>> list_xml = api.manage("SolaceClientProfile", name="myprofile", vpn_name="dev_testvpn").commands.commands
"""
plugin_name = "SolaceClientProfile"
defaults = {"max_clients": 1000}
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 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))
# @only_if_not_exists('get', 'rpc-reply.rpc.show.message-vpn.vpn')
def new_client_profile(self, **kwargs):
"""Create a new client profile
Enqueues the request in self.commands and returns the SEMP request via PluginResponse.
Example:
>>> import libsolace.settingsloader as settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> plugin_response = api.manage("SolaceClientProfile").new_client_profile(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: dictionary representation of client profile
:rtype: plugin.PluginResponse
"""
name = get_key_from_kwargs("name", kwargs)
vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.api.x = SolaceXMLBuilder("Create Client Profile", version=self.api.version)
self.api.x.create.client_profile.name = name
if version_equal_or_greater_than("soltr/6_2", self.api.version):
self.api.x.create.client_profile.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 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 allow_consume(self, **kwargs):
"""Allow consume permission
Example:
>>> import libsolace.settingsloader as settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> plugin_response = api.manage("SolaceClientProfile").allow_consume(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("Allow profile consume", 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_guaranteed_message_receive
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def allow_send(self, **kwargs):
"""Allow send permission
Example:
>>> import libsolace.settingsloader as settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> plugin_response = api.manage("SolaceClientProfile").allow_send(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("Allow profile send", 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_guaranteed_message_send
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def allow_endpoint_create(self, **kwargs):
"""Allow endpoint creation permission
Example:
>>> import libsolace.settingsloader as settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceClientProfile").allow_endpoint_create(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 endpoint create", 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_guaranteed_endpoint_create
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 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 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 __init__(self, *args, **kwargs):
"""
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
:param queue_name: the queue name in Query mode
:param queues: list of queue dictionaries with keys: name, queue_config
:param vpn_name: name of the VPN to scope the ACL to
:param defaults: dictionary of queue properties, see `defaults` in SolaceQueue class
:type api: SolaceAPI
:type queue_name: str
:type vpn_name: str
:type defaults: dict
:returns: instance with batch requests on SolaceACLProfile.commands.commands
:rtype: SolaceClientProfile
Example:
>>> api = SolaceAPI("dev")
>>> sq = api.manage("SolaceQueue")
>>> dict_queue = sq.get(vpn_name="dev_testvpn", queue_name="testqueue1")
>>> api.rpc(sq.max_bind_count(vpn_name="dev_testvpn", queue_name="testqueue1", max_bind_count=10))
"""
self.api = get_key_from_kwargs("api", kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
logger.info("Query Mode")
return
logger.info("Provision mode: %s" % kwargs)
self.vpn_name = get_key_from_kwargs("vpn_name",
kwargs,
default="default")
self.testmode = get_key_from_kwargs("testmode", kwargs, default=False)
self.queues = get_key_from_kwargs("queues", kwargs, default={})
self.shutdown_on_apply = get_key_from_kwargs("shutdown_on_apply",
kwargs,
default=False)
self.defaults = get_key_from_kwargs('defaults',
kwargs,
default=self.defaults)
self.options = None
logger.info("Queues: %s" % self.queues)
# 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"
)
for queue in self.queues:
queueName = queue['name']
queue_config = self.get_queue_config(queue, **kwargs)
self.create_queue(queue_name=queueName, **kwargs)
self.shutdown_egress(queue_name=queueName, **kwargs)
if queue_config['exclusive'].lower() == "true":
self.exclusive(queue_name=queueName,
exclusive=True,
**kwargs)
else:
self.exclusive(queue_name=queueName,
exclusive=False,
**kwargs)
self.owner(queue_name=queueName,
owner_username=queue_config['owner'],
**kwargs)
self.max_bind_count(
queue_name=queueName,
max_bind_count=queue_config['max_bind_count'],
**kwargs)
self.consume(queue_name=queueName,
consume=queue_config['consume'],
**kwargs)
self.spool_size(queue_name=queueName,
queue_size=queue_config['queue_size'],
**kwargs)
self.retries(queue_name=queueName,
retries=queue_config['retries'],
**kwargs)
self.reject_on_discard(queue_name=queueName, **kwargs)
self.enable(queue_name=queueName, **kwargs)
def __init__(self, *args, **kwargs):
""" Init user object
:type users: dict
:type vpn_name: str
:type client_profile: str
:type acl_profile: str
:type shutdown_on_apply: bool / char b / char u
:type options: Options
:type version: str
:type api: SolaceAPI
Example:
>>> connection = SolaceAPI("dev")
>>> self.users = [connection.manage("SolaceUsers",
users = users_dict,
vpn_name = "dev_testvpn",
client_profile = "glassfish",
acl_profile = "dev_testvpn",
testmode = True,
shutdown_on_apply = False
version = self.version)]
"""
self.api = get_key_from_kwargs("api", kwargs)
kwargs.pop("api")
logger.info("SolaceUsers: kwargs: %s " % kwargs)
if kwargs == {}:
logger.info("No kwargs, factory mode")
return
else:
logger.info("kwargs: %s" % kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
self.options = None # not implemented
self.users = get_key_from_kwargs("users", kwargs)
self.vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.acl_profile = get_key_from_kwargs("acl_profile", kwargs)
self.client_profile = get_key_from_kwargs("client_profile", kwargs)
self.testmode = get_key_from_kwargs("testmode", kwargs)
self.shutdown_on_apply = get_key_from_kwargs("shutdown_on_apply", kwargs)
logger.info("""UsersCommands: %s, Environment: %s, Users: %s, vpn_name: %s,
acl_profile: %s, client_profile: %s, testmode: %s, shutdown_on_apply: %s""" % (self.commands,
self.api.environment,
self.users,
self.vpn_name,
self.acl_profile,
self.client_profile,
self.testmode,
self.shutdown_on_apply))
if self.testmode:
logger.info('TESTMODE ACTIVE')
try:
self._tests(**kwargs)
except Exception, e:
logger.error("Tests Failed %s" % e)
raise BaseException("Tests Failed")
# backwards compatibility for None options passed to still execute "add" code
if self.options == None:
logger.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance")
for user in self.users:
user_kwargs = dict(kwargs)
user_kwargs['username'] = user['username']
user_kwargs['password'] = user['password']
try:
# Check if user already exists, if not then shutdown immediately after creating the user
self.get(**user_kwargs).reply.show.client_username.client_usernames.client_username
except (AttributeError, KeyError, MissingClientUser):
logger.info(
"User %s doesn't exist, using shutdown_on_apply to True for user" % user_kwargs['username'])
user_kwargs['shutdown_on_apply'] = True
self.create_user(**user_kwargs)
self.disable_user(**user_kwargs)
self.set_client_profile(**user_kwargs)
self.set_acl_profile(**user_kwargs)
self.no_guarenteed_endpoint(**user_kwargs)
self.no_subscription_manager(**user_kwargs)
self.set_password(**user_kwargs)
self.no_shutdown_user(**user_kwargs)
def generateXML(connection, options, vpn_name=None, queues=None):
"""
:param vpn_name: string name of vpn
:param queues: list of queues to manipulate
:return: commands
"""
# commandQueue is used to stack and validate solace commands
commands = SolaceCommandQueue()
if options.settings is None:
settings_file = 'default'
else:
settings_file = options.settings
print """============ Task details ============
Queues: %s
VPN: %s
Environment: %s
Settings file: %s
Force remove: %s
Shutdown only: %s
======================================""" % (
",".join(queues), vpn_name, options.env, settings_file,
str(options.force), str(options.shutdownonly))
def shutdown_queue(queue):
cmd = SolaceXMLBuilder("Full shutdown on queue: %s" % queue.strip())
cmd.message_spool.vpn_name = vpn_name
cmd.message_spool.queue.name = queue.strip()
cmd.message_spool.queue.shutdown.full
commands.enqueue(cmd)
def delete_queue(queue):
cmd = SolaceXMLBuilder("Deleting queue: %s" % queue.strip())
cmd.message_spool.vpn_name = vpn_name
cmd.message_spool.no.queue.name = queue.strip()
commands.enqueue(cmd)
def check_queue_in_use(queue):
q = connection.get_queue(queue, vpn_name, detail=True)
try:
resp = q[0]['rpc-reply']['rpc']['show']['queue']['queues'][
'queue']['info']
bind_count = int(resp['bind-count'])
topic_subscription_count = int(resp['topic-subscription-count'])
current_spool_usage_in_mb = float(
resp['current-spool-usage-in-mb'])
if bind_count > 0:
print "WARNING: Queue %s is being used. Bind count: %s" % (
queue, str(bind_count))
return True
if topic_subscription_count > 0:
print "WARNING: Queue %s is being used. Topic subscription count: %s" % (
queue, str(topic_subscription_count))
return True
if current_spool_usage_in_mb > 0:
print "WARNING: Queue %s has messages in spool. Current spool usage: %sMB" % (
queue, str(current_spool_usage_in_mb))
return True
return False
except Exception, e:
print "ERROR: Exception thrown: %s" % e
print "ERROR: Queue '%s' does not exist, quitting...." % queue
sys.exit(1)
class SolaceQueue(Plugin):
"""Manage a Solace Queue
Description
===========
This plugin manages Queues within Solace. Typically you should invoke this plugin via L{SolaceAPI.SolaceAPI}.
Please see L{plugin.Plugin} for how plugins are instantiated and used.
"""
plugin_name = "SolaceQueue"
# defaults should be provided from the settingsloader key
defaults = {
"retries": 0,
"exclusive": "true",
"queue_size": 1024,
"consume": "all",
"max_bind_count": 1000,
"owner": "default"
}
def __init__(self, *args, **kwargs):
"""
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
:param queue_name: the queue name in Query mode
:param queues: list of queue dictionaries with keys: name, queue_config
:param vpn_name: name of the VPN to scope the ACL to
:param defaults: dictionary of queue properties, see `defaults` in SolaceQueue class
:type api: SolaceAPI
:type queue_name: str
:type vpn_name: str
:type defaults: dict
:returns: instance with batch requests on SolaceACLProfile.commands.commands
:rtype: SolaceClientProfile
Example:
>>> api = SolaceAPI("dev")
>>> sq = api.manage("SolaceQueue")
>>> dict_queue = sq.get(vpn_name="dev_testvpn", queue_name="testqueue1")
>>> api.rpc(sq.max_bind_count(vpn_name="dev_testvpn", queue_name="testqueue1", max_bind_count=10))
"""
self.api = get_key_from_kwargs("api", kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
logger.info("Query Mode")
return
logger.info("Provision mode: %s" % kwargs)
self.vpn_name = get_key_from_kwargs("vpn_name",
kwargs,
default="default")
self.testmode = get_key_from_kwargs("testmode", kwargs, default=False)
self.queues = get_key_from_kwargs("queues", kwargs, default={})
self.shutdown_on_apply = get_key_from_kwargs("shutdown_on_apply",
kwargs,
default=False)
self.defaults = get_key_from_kwargs('defaults',
kwargs,
default=self.defaults)
self.options = None
logger.info("Queues: %s" % self.queues)
# 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"
)
for queue in self.queues:
queueName = queue['name']
queue_config = self.get_queue_config(queue, **kwargs)
self.create_queue(queue_name=queueName, **kwargs)
self.shutdown_egress(queue_name=queueName, **kwargs)
if queue_config['exclusive'].lower() == "true":
self.exclusive(queue_name=queueName,
exclusive=True,
**kwargs)
else:
self.exclusive(queue_name=queueName,
exclusive=False,
**kwargs)
self.owner(queue_name=queueName,
owner_username=queue_config['owner'],
**kwargs)
self.max_bind_count(
queue_name=queueName,
max_bind_count=queue_config['max_bind_count'],
**kwargs)
self.consume(queue_name=queueName,
consume=queue_config['consume'],
**kwargs)
self.spool_size(queue_name=queueName,
queue_size=queue_config['queue_size'],
**kwargs)
self.retries(queue_name=queueName,
retries=queue_config['retries'],
**kwargs)
self.reject_on_discard(queue_name=queueName, **kwargs)
self.enable(queue_name=queueName, **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_queue_config(self, queue, **kwargs):
""" Returns a queue config for the queue and overrides where neccessary
:param queue: single queue dictionary e.g.
{
"name": "foo",
"env": [
"qa1": {
"queue_config": {
"retries": 0,
"exclusive": "false",
"queue_size": 1024,
"consume": "all",
"max_bind_count": 1000,
"owner": "dev_testuser"
}
}
]
}
"""
# get the queue name from the queue dictionary as passed to this method
queue_name = get_key_from_kwargs("name", queue)
try:
logger.debug("Checking env overrides for queue %s" % queue['env'])
for e in queue['env']:
if e['name'] == self.api.environment:
logger.info(
'setting queue_config to environment %s values' %
e['name'])
return self.__apply_default_config__(
e['queue_config'], self.defaults)
except:
logger.warn("No environment overrides for queue %s" % queue_name)
pass
try:
return self.__apply_default_config__(queue['queue_config'],
self.defaults)
except:
logger.warning(
"No queue_config for queue: %s found, please check site-config"
% queue_name)
raise
def __apply_default_config__(self, config, default):
""" copys keys from default dict to config dict when not present """
logger.info("Applying default config after config")
final_config = {}
for k, v in default.items():
if k in config:
logger.info("Using environment config key: %s to %s" %
(k, config[k]))
final_config[k] = config[k]
else:
logger.info("Using default config key: %s to %s" % (k, v))
final_config[k] = v
return final_config
# perform the if_exists on the primary only
@only_if_not_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
@primary()
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)
# perform the if_exists on the primary only
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
# @only_on_shutdown('queue')
@primary()
def shutdown_egress(self, **kwargs):
"""Shutdown egress for 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: One Shot
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").shutdown_egress(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_egress(shutdown_on_apply=True, vpn_name="dev_testvpn", queue_name="testqueue1")
>>> # response = 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.egress
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)
# perform the if_exists on the primary only
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
# @only_on_shutdown('queue')
@primary()
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)
# perform the if_exists on the primary only
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
# @only_on_shutdown('queue')
@primary()
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
# @only_on_shutdown('queue')
@primary()
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
@primary()
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True,
backupOnly=False)
# @only_on_shutdown('queue')
@primary()
@deprecation_warning(
"Please implement the use of the 'permission' method instead of relying on this"
)
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True,
backupOnly=False)
# @only_on_shutdown('queue')
@primary()
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
@primary()
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
@primary()
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
@primary()
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)
@only_if_exists('get',
'rpc-reply.rpc.show.queue.queues.queue.info',
primaryOnly=True)
@primary()
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)
class SolaceACLProfile(Plugin):
""" Plugin to manage AclProfiles
Description
===========
This plugin manages ACL Profiles within Solace. Typically you should invoke this plugin via :class:`libsolace.SolaceAPI.SolaceAPI`
Please see :class:`libsolace.plugin.Plugin` for how plugins are instantiated and used.
"""
plugin_name = "SolaceACLProfile"
def __init__(self, *args, **kwargs):
"""Initialize in Query or Batch mode
Example:
>>> from libsolace.SolaceAPI import SolaceAPI
>>> client = SolaceAPI("dev")
>>> client.manage("SolaceACLProfile", name="myprofile", vpn_name="testvpn").commands.commands
[XML, XML, XML]
:type api: SolaceAPI
:param api: the api (passed in automatically if instantiated via SolaceAPI.manage
Optional (Batch/Provision) Mode
:type name: str
:param name: the name of the ACL Profile
:type vpn_name: str
:param vpn_name: the vpn name
:rtype: SolaceACLProfile
:returns: instance with batch requests on SolaceACLProfile.commands.commands
"""
self.api = get_key_from_kwargs("api", kwargs) #: SolaceAPI instance
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
return
self.name = get_key_from_kwargs('name', kwargs)
self.vpn_name = get_key_from_kwargs('vpn_name', kwargs)
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")
# queue up the commands
self.new_acl(**kwargs)
self.allow_publish(**kwargs)
self.allow_subscribe(**kwargs)
self.allow_connect(**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 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 allow_publish(self, **kwargs):
"""Allow publish
Example:
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceACLProfile").allow_publish(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("Allow Publish %s" % 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.publish_topic.default_action.allow
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 allow_connect(self, **kwargs):
""" Allow Connect
: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")
>>> # response = 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 connect 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.client_connect.default_action.allow
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
def __init__(self, *args, **kwargs):
"""
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
:param queue_name: the queue name in Query mode
:param queues: list of queue dictionaries with keys: name, queue_config
:param vpn_name: name of the VPN to scope the ACL to
:param defaults: dictionary of queue properties, see `defaults` in SolaceQueue class
:type api: SolaceAPI
:type queue_name: str
:type vpn_name: str
:type defaults: dict
:returns: instance with batch requests on SolaceACLProfile.commands.commands
:rtype: SolaceClientProfile
Example:
>>> api = SolaceAPI("dev")
>>> sq = api.manage("SolaceQueue")
>>> dict_queue = sq.get(vpn_name="dev_testvpn", queue_name="testqueue1")
>>> api.rpc(sq.max_bind_count(vpn_name="dev_testvpn", queue_name="testqueue1", max_bind_count=10))
"""
self.api = get_key_from_kwargs("api", kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
logging.info("Query Mode")
return
logging.info("Provision mode: %s" % kwargs)
self.vpn_name = get_key_from_kwargs("vpn_name", kwargs, default="default")
self.testmode = get_key_from_kwargs("testmode", kwargs, default=False)
self.queues = get_key_from_kwargs("queues", kwargs, default={})
self.shutdown_on_apply = get_key_from_kwargs("shutdown_on_apply", kwargs, default=False)
self.defaults = get_key_from_kwargs('defaults', kwargs, default=self.defaults)
self.options = None
logging.info("Queues: %s" % self.queues)
# backwards compatibility for None options passed to still execute "add" code
if self.options is None:
logging.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance")
for queue in self.queues:
queueName = queue['name']
queue_config = self.get_queue_config(queue, **kwargs)
self.create_queue(queue_name=queueName, **kwargs)
self.shutdown_egress(queue_name=queueName, **kwargs)
if queue_config['exclusive'].lower() == "true":
self.exclusive(queue_name=queueName, exclusive=True, **kwargs)
else:
self.exclusive(queue_name=queueName, exclusive=False, **kwargs)
self.owner(queue_name=queueName, owner_username=queue_config['owner'], **kwargs)
self.max_bind_count(queue_name=queueName, max_bind_count=queue_config['max_bind_count'], **kwargs)
self.consume(queue_name=queueName, consume=queue_config['consume'], **kwargs)
self.spool_size(queue_name=queueName, queue_size=queue_config['queue_size'], **kwargs)
self.retries(queue_name=queueName, retries=queue_config['retries'], **kwargs)
self.reject_on_discard(queue_name=queueName, **kwargs)
self.enable(queue_name=queueName, **kwargs)
class SolaceQueue(Plugin):
"""Manage a Solace Queue
Description
===========
This plugin manages Queues within Solace. Typically you should invoke this plugin via L{SolaceAPI.SolaceAPI}.
Please see L{plugin.Plugin} for how plugins are instantiated and used.
"""
plugin_name = "SolaceQueue"
# defaults should be provided from the settingsloader key
defaults = {
"retries": 0,
"exclusive": "true",
"queue_size": 1024,
"consume": "all",
"max_bind_count": 1000,
"owner": "default"
}
def __init__(self, *args, **kwargs):
"""
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
:param queue_name: the queue name in Query mode
:param queues: list of queue dictionaries with keys: name, queue_config
:param vpn_name: name of the VPN to scope the ACL to
:param defaults: dictionary of queue properties, see `defaults` in SolaceQueue class
:type api: SolaceAPI
:type queue_name: str
:type vpn_name: str
:type defaults: dict
:returns: instance with batch requests on SolaceACLProfile.commands.commands
:rtype: SolaceClientProfile
Example:
>>> api = SolaceAPI("dev")
>>> sq = api.manage("SolaceQueue")
>>> dict_queue = sq.get(vpn_name="dev_testvpn", queue_name="testqueue1")
>>> api.rpc(sq.max_bind_count(vpn_name="dev_testvpn", queue_name="testqueue1", max_bind_count=10))
"""
self.api = get_key_from_kwargs("api", kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
logging.info("Query Mode")
return
logging.info("Provision mode: %s" % kwargs)
self.vpn_name = get_key_from_kwargs("vpn_name", kwargs, default="default")
self.testmode = get_key_from_kwargs("testmode", kwargs, default=False)
self.queues = get_key_from_kwargs("queues", kwargs, default={})
self.shutdown_on_apply = get_key_from_kwargs("shutdown_on_apply", kwargs, default=False)
self.defaults = get_key_from_kwargs('defaults', kwargs, default=self.defaults)
self.options = None
logging.info("Queues: %s" % self.queues)
# backwards compatibility for None options passed to still execute "add" code
if self.options is None:
logging.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance")
for queue in self.queues:
queueName = queue['name']
queue_config = self.get_queue_config(queue, **kwargs)
self.create_queue(queue_name=queueName, **kwargs)
self.shutdown_egress(queue_name=queueName, **kwargs)
if queue_config['exclusive'].lower() == "true":
self.exclusive(queue_name=queueName, exclusive=True, **kwargs)
else:
self.exclusive(queue_name=queueName, exclusive=False, **kwargs)
self.owner(queue_name=queueName, owner_username=queue_config['owner'], **kwargs)
self.max_bind_count(queue_name=queueName, max_bind_count=queue_config['max_bind_count'], **kwargs)
self.consume(queue_name=queueName, consume=queue_config['consume'], **kwargs)
self.spool_size(queue_name=queueName, queue_size=queue_config['queue_size'], **kwargs)
self.retries(queue_name=queueName, retries=queue_config['retries'], **kwargs)
self.reject_on_discard(queue_name=queueName, **kwargs)
self.enable(queue_name=queueName, **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_queue_config(self, queue, **kwargs):
""" Returns a queue config for the queue and overrides where neccessary
:param queue: single queue dictionary e.g.
{
"name": "foo",
"env": [
"qa1": {
"queue_config": {
"retries": 0,
"exclusive": "false",
"queue_size": 1024,
"consume": "all",
"max_bind_count": 1000,
"owner": "dev_testuser"
}
}
]
}
"""
# get the queue name from the queue dictionary as passed to this method
queue_name = get_key_from_kwargs("name", queue)
try:
logging.debug("Checking env overrides for queue %s" % queue['env'])
for e in queue['env']:
if e['name'] == self.api.environment:
logging.info('setting queue_config to environment %s values' % e['name'])
return self.__apply_default_config__(e['queue_config'], self.defaults)
except:
logging.warn("No environment overides for queue %s" % queue_name)
pass
try:
return self.__apply_default_config__(queue['queue_config'], self.defaults)
except:
logging.warning("No queue_config for queue: %s found, please check site-config" % queue_name)
raise
def __apply_default_config__(self, config, default):
""" copys keys from default dict to config dict when not present """
logging.info("Applying default config after config")
final_config = {}
for k, v in default.items():
if k in config:
logging.info("Config key: %s to %s" % (k, v))
final_config[k] = config[k]
else:
logging.info("Default config key: %s to %s" % (k, v))
final_config[k] = v
return final_config
# perform the if_exists on the primary only
@only_if_not_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@primary()
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)
# perform the if_exists on the primary only
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@only_on_shutdown('queue')
@primary()
def shutdown_egress(self, **kwargs):
"""Shutdown egress for 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: One Shot
>>> api = SolaceAPI("dev")
>>> request = api.manage("SolaceQueue").shutdown_egress(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_egress(shutdown_on_apply=True, vpn_name="dev_testvpn", queue_name="testqueue1")
>>> # response = 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.egress
self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs))
return PluginResponse(str(self.api.x), **kwargs)
else:
logging.warning("Not disabling Queue, commands could fail since shutdown_on_apply = %s" % shutdown_on_apply)
# perform the if_exists on the primary only
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@only_on_shutdown('queue')
@primary()
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:
logging.warning("Not disabling Queue, commands could fail since shutdown_on_apply = %s" % shutdown_on_apply)
# perform the if_exists on the primary only
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@only_on_shutdown('queue')
@primary()
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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@only_on_shutdown('queue')
@primary()
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
logging.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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@primary()
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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True, backupOnly=False)
@only_on_shutdown('queue')
@primary()
@deprecation_warning("Please implement the use of the 'permission' method instead of relying on this")
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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True, backupOnly=False)
@only_on_shutdown('queue')
@primary()
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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@primary()
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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@primary()
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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@primary()
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)
@only_if_exists('get', 'rpc-reply.rpc.show.queue.queues.queue.info', primaryOnly=True)
@primary()
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)
from libsolace.SolaceProvision import SolaceProvision
from libsolace.plugin import Plugin
import re
from libsolace.SolaceXMLBuilder import SolaceXMLBuilder
pattern = "(__[a-zA-Z0-9_]*(__)?)"
public_methods = re.compile(pattern)
classes_list = libsolace.plugin_registry.plugins_dict
classes_list['SolaceXMLBuilder'] = SolaceXMLBuilder().__class__
classes_list['Decorators'] = Decorators
classes_list['Plugin'] = Plugin().__class__
classes_list['Naming'] = Naming
classes_list['SolaceCommandQueue'] = SolaceCommandQueue().__class__
classes_list['SolaceProvision'] = SolaceProvision().__class__
ignore_list = [
"Decorators.MissingClientUser", "Decorators.MissingException",
"Decorators.get_calling_module", "Decorators.wraps"
]
logging.info(classes_list)
def get_callable_methods(clazz):
"""
Returns methods that can be called and are not private
:param clazz:
class SolaceVPN(Plugin):
"""Manage a Solace VPN
If `vpn_name` is passed as a kwarg, this plugin enters provision/batch mode, if it is omitted, the plugin will go into
single query mode.
In provision/batch mode, this plugin generates all the neccesary SEMP requests to create a VPN. You also need to pass a
`owner_name` and a existing `acl_profile` name. If these are omitted, the vpn_name property is used.
In single query mode, this plugin creates single SEMP requests, you need only pass a SolaceAPI into `api`, or invoke
via SolaceAPI("dev").manage("SolaceVPN")
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
:param vpn_name: name of the VPN to scope the ACL to
:type api: SolaceAPI
:type vpn_name: str
:rtype: SolaceVPN
Query/Single Mode Example Direct Access:
>>> from libsolace.settingsloader import settings
>>> import libsolace
>>> from libsolace.SolaceAPI import SolaceAPI
>>> clazz = libsolace.plugin_registry("SolaceVPN", settings=settings)
>>> api = SolaceAPI("dev")
>>> solaceVpnPlugin = clazz(settings=settings, api=api)
>>> list_of_dicts = solaceVpnPlugin.get(vpn_name="default")
Provision/Batch Mode Example via SolaceAPI
>>> api = SolaceAPI("dev")
>>> vpn = api.manage("SolaceVPN", vpn_name="my_vpn", owner_name="someuser", acl_profile="default", max_spool_usage=1024)
>>> #for req in vpn.commands.commands:
>>> # api.rpc(str(req[0]), **req[1])
"""
plugin_name = "SolaceVPN"
api = "None"
default_settings = {
'max_spool_usage': 4096,
'large_message_threshold': 4096
}
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)
@only_if_not_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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 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))
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", '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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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)
@only_if_exists("get", 'rpc-reply.rpc.show.message-vpn.vpn')
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 __getitem__(self, k):
return self.__dict__[k]
