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]