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