def allow_bridging(self, **kwargs): """Allow bridging Example: >>> from libsolace.settingsloader import settings >>> from libsolace.SolaceAPI import SolaceAPI >>> plugin = SolaceAPI("dev", version="soltr/7_1_1").manage("SolaceClientProfile") >>> request = plugin.allow_bridging(name="default", vpn_name="default") >>> request.xml '<rpc semp-version="soltr/7_1_1"><client-profile><name>default</name><vpn-name>default</vpn-name><allow-bridge-connections/></client-profile></rpc>' >>> # api.rpc(request) :param name: name of the profile :param vpn_name: the name of the vpn to scope the request to :type name: str :type vpn_name: str :returns: SEMP request :rtype: plugin.PluginResponse """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) self.api.x = SolaceXMLBuilder("Setting Bridging", version=self.api.version) self.api.x.client_profile.name = name if version_equal_or_greater_than('soltr/6_2', self.api.version): self.api.x.client_profile.vpn_name = vpn_name self.api.x.client_profile.allow_bridge_connections self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def set_max_clients(self, **kwargs): """Set max clients for profile Example: >>> from libsolace.settingsloader import settings >>> from libsolace.SolaceAPI import SolaceAPI >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceClientProfile").set_max_clients(name="default", vpn_name="default", max_clients=500) >>> # response = api.rpc(request) :param name: name of the profile :param vpn_name: the name of the vpn to scope the request to :param max_clients: max number of clients :type name: str :type vpn_name: str :type max_clients: int :returns: SEMP request :rtype: plugin.PluginResponse """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) max_clients = get_key_from_kwargs("max_clients", kwargs) self.api.x = SolaceXMLBuilder("Setting Max Clients", version=self.api.version) self.api.x.client_profile.name = name if version_equal_or_greater_than('soltr/6_2', self.api.version): self.api.x.client_profile.vpn_name = vpn_name self.api.x.client_profile.max_connections_per_client_username.value = max_clients self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def allow_transacted_sessions(self, **kwargs): """Allow transaction sessions permission Example: >>> from libsolace.settingsloader import settings >>> from libsolace.SolaceAPI import SolaceAPI >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceClientProfile").allow_transacted_sessions(name="default", vpn_name="default") >>> # response = api.rpc(request) :param name: name of the profile :param vpn_name: the name of the vpn to scope the request to :type name: str :type vpn_name: str :returns: SEMP request :rtype: plugin.PluginResponse """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) self.api.x = SolaceXMLBuilder("Allow profile transacted sessions", version=self.api.version) self.api.x.client_profile.name = name if version_equal_or_greater_than('soltr/6_2', self.api.version): self.api.x.client_profile.vpn_name = vpn_name self.api.x.client_profile.message_spool.allow_transacted_sessions self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def delete(self, **kwargs): """Delete a client profile Example: >>> from libsolace.settingsloader import settings >>> from libsolace.SolaceAPI import SolaceAPI >>> api = SolaceAPI("dev") >>> plugin_response = api.manage("SolaceClientProfile").delete(name="default", vpn_name="default") :param name: name of the profile :param vpn_name: the name of the vpn to scope the request to :type name: str :type vpn_name: str :returns: SEMP request :rtype: plugin.PluginResponse """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) self.api.x = SolaceXMLBuilder("Delete Client Profile", version=self.api.version) self.api.x.no.client_profile.name = name if version_equal_or_greater_than('soltr/6_2', self.api.version): self.api.x.no.client_profile.vpn_name = vpn_name self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def allow_subscribe(self, **kwargs): """ Allow subscribe :param name: name of the profile :param vpn_name: vpn name :rtype: PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceACLProfile").allow_subscribe(name="myprofile", vpn_name="dev_testvpn") >>> # api.rpc(request) """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) self.api.x = SolaceXMLBuilder("VPN %s Allowing ACL Profile to subscribe to VPN" % name, version=self.api.version) self.api.x.acl_profile.name = name self.api.x.acl_profile.vpn_name = vpn_name self.api.x.acl_profile.subscribe_topic.default_action.allow self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def max_bind_count(self, **kwargs): """Limit the max bind count :param vpn_name: the name of the vpn :param queue_name: the queue name :param max_bind_count: max bind count :type vpn_name: str :type queue_name: str :type max_bind_count: int :rtype: plugin.PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> requests = api.manage("SolaceQueue").max_bind_count(vpn_name="dev_testvpn", queue_name="testqueue1", max_bind_count=50) >>> # response = api.rpc(requests) """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) max_bind_count = get_key_from_kwargs("max_bind_count", kwargs) self.api.x = SolaceXMLBuilder( "Settings Queue %s max bind count to %s" % (queue_name, str(max_bind_count)), version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.max_bind_count.value = max_bind_count self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def list_vpns(self, **kwargs): """Returns a list of vpns from first / primary node only :param vpn_name: the vpn_name or search pattern :type vpn_name: str :return: Example: >>> api = SolaceAPI("dev") >>> list_dict = api.manage("SolaceVPN").list_vpns(vpn_name="*") """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) self.api.x = SolaceXMLBuilder("Getting list of VPNS", version=self.api.version) self.api.x.show.message_vpn.vpn_name = vpn_name self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) response = self.api.rpc(PluginResponse(str(self.api.x), **kwargs)) # response = SolaceReplyHandler(self.api.rpc(str(self.api.x), primaryOnly=True)) # logger.info(response) return [ vpn['name'] for vpn in response[0]['rpc-reply']['rpc']['show'] ['message-vpn']['vpn'] ]
def create_queue(self, **kwargs): """Create a queue / endpoint only if it doesnt exist. :param queue_name: the queue name :param vpn_name: the vpn name :type queue_name: str :type vpn_name: str :type: plugin.PluginResponse :returns: single SEMP request Example 1: Create Request, then Execute >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").create_queue(vpn_name="dev_testvpn", queue_name="my_test_queue") >>> # response = api.rpc(request) """ queue_name = get_key_from_kwargs("queue_name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) # Create a queue self.api.x = SolaceXMLBuilder("Creating Queue %s in vpn: %s" % (queue_name, vpn_name), version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.create.queue.name = queue_name self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) self.exists = True return PluginResponse(str(self.api.x), **kwargs)
def get(self, **kwargs): """Fetch a queue from the appliance :type queue_name: str :type vpn_name: str :param queue_name: Queue name or filter :param vpn_name: name of the VPN :rtype: plugin.PluginResponse :returns: the queue(s) Examples: >>> api = SolaceAPI("dev") >>> list_queues = api.manage("SolaceQueue").get(queue_name='*', vpn_name='dev_testvpn') """ queue_name = get_key_from_kwargs("queue_name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) detail = get_key_from_kwargs("detail", kwargs, default=False) # if this request is not specifically targeted at the backup, default to primary if get_key_from_kwargs("backupOnly", kwargs, default=False) is False: kwargs["primaryOnly"] = True self.api.x = SolaceXMLBuilder("Querying Queue %s" % queue_name, version=self.api.version) self.api.x.show.queue.name = queue_name self.api.x.show.queue.vpn_name = vpn_name if detail: self.api.x.show.queue.detail self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return self.api.rpc(PluginResponse(str(self.api.x), **kwargs))
def spool_size(self, **kwargs): """Set the spool size :param vpn_name: the name of the vpn :param queue_name: the queue name :param queue_size: size of the spool in mb :type vpn_name: str :type queue_name: str :type queue_size: int :rtype: plugin.PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").spool_size(vpn_name="dev_testvpn", queue_name="testqueue1", queue_size=64) >>> # response = api.rpc(request) """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) queue_size = get_key_from_kwargs("queue_size", kwargs) # Configure Queue Spool Usage self.api.x = SolaceXMLBuilder("Set Queue %s spool size: %s" % (queue_name, queue_size), version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.max_spool_usage.size = queue_size self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def retries(self, **kwargs): """Delivery retries before failing the message :param vpn_name: the name of the vpn :param queue_name: the queue name :param retries: number of retries :type vpn_name: str :type queue_name: str :type retries: int :rtype: plugin.PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").retries(vpn_name="dev_testvpn", queue_name="testqueue1", retries=5) >>> # response = api.rpc(request) """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) retries = get_key_from_kwargs("retries", kwargs, default=0) self.api.x = SolaceXMLBuilder( "Tuning max-redelivery retries for %s to %s" % (queue_name, retries), version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.max_redelivery.value = retries self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def set_acl_profile(self, **kwargs): """ set acl profile :param username: the username :type username: str :param vpn_name: the vpn name :type vpn_name: str :param acl_profile: name of the profile :type acl_profile: str :rtype: plugin.PluginResponse :return: SEMP request """ username = get_key_from_kwargs('username', kwargs) vpn_name = get_key_from_kwargs('vpn_name', kwargs) acl_profile = get_key_from_kwargs('acl_profile', kwargs) # Set client user profile self.api.x = SolaceXMLBuilder("Set User %s ACL Profile to %s" % (username, vpn_name), version=self.api.version) self.api.x.client_username.username = username self.api.x.client_username.vpn_name = vpn_name self.api.x.client_username.acl_profile.name = acl_profile self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def disable_user(self, **kwargs): """ Disable the user ( suspending pub/sub ) :param username: the username :type username: str :param vpn_name: the vpn name :type vpn_name: str :param shutdown_on_apply: see :func:`Kwargs.shutdown_on_apply` :type shutdown_on_apply: bool / char :rtype: plugin.PluginResponse :return: SEMP request """ username = get_key_from_kwargs('username', kwargs) vpn_name = get_key_from_kwargs('vpn_name', kwargs) shutdown_on_apply = get_key_from_kwargs('shutdown_on_apply', kwargs) if (shutdown_on_apply == 'b') or (shutdown_on_apply == 'u') or (shutdown_on_apply == True): # Disable / Shutdown User ( else we cant change profiles ) self.api.x = SolaceXMLBuilder("Disabling User %s" % username, version=self.api.version) self.api.x.client_username.username = username self.api.x.client_username.vpn_name = vpn_name self.api.x.client_username.shutdown self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs) else: logger.warning( "Not disabling User, commands could fail since shutdown_on_apply = %s" % self.shutdown_on_apply) return None
def set_client_profile(self, **kwargs): """ set client profile :param username: the username :type username: str :param vpn_name: the vpn name :type vpn_name: str :param client_profile: name of the profile :type client_profile: str :rtype: plugin.PluginResponse :return: SEMP request """ username = get_key_from_kwargs('username', kwargs) vpn_name = get_key_from_kwargs('vpn_name', kwargs) client_profile = get_key_from_kwargs('client_profile', kwargs) # Client Profile self.api.x = SolaceXMLBuilder("Setting User %s client profile to %s" % (username, client_profile), version=self.api.version) self.api.x.client_username.username = username self.api.x.client_username.vpn_name = vpn_name self.api.x.client_username.client_profile.name = client_profile self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def reject_on_discard(self, **kwargs): """ Reject to sender on discard :param vpn_name: the name of the vpn :param queue_name: the queue name :type vpn_name: str :type queue_name: str :rtype: plugin.PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").reject_on_discard(vpn_name="dev_testvpn", queue_name="testqueue1") >>> # response = api.rpc(request) """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) self.api.x = SolaceXMLBuilder("Setting Queue to Reject Drops", version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.reject_msg_to_sender_on_discard self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def get(self, **kwargs): """Returns a ClientProfile immediately from both appliances Example: >>> from libsolace.settingsloader import settings >>> from libsolace.SolaceAPI import SolaceAPI >>> api = SolaceAPI("dev") >>> response = api.manage("SolaceClientProfile").get(name="default", vpn_name="default") :param name: name of the profile :param vpn_name: the name of the vpn to scope the request to :param details: get more details boolean :type name: str :type vpn_name: str :type details: bool :rtype: libsolace.SolaceReplyHandler :returns: dictionary representation of client profile """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) details = get_key_from_kwargs("details", kwargs, default=False) self.api.x = SolaceXMLBuilder("Get Client Profile", version=self.api.version) self.api.x.show.client_profile.name = name if version_equal_or_greater_than('soltr/6_2', self.api.version): self.api.x.show.client_profile.vpn_name = vpn_name if details: self.api.x.show.client_profile.details # enqueue to validate self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return self.api.rpc(PluginResponse(str(self.api.x), **kwargs))
def enable(self, **kwargs): """Enable a the queue :param vpn_name: the name of the vpn :param queue_name: the queue name :type vpn_name: str :type queue_name: str :rtype: plugin.PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").enable(queue_name="testqueue1", vpn_name="dev_testvpn") >>> # response = api.rpc(request) """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) # Enable the Queue self.api.x = SolaceXMLBuilder("Enabling Queue %s" % queue_name, version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.no.shutdown.full self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def set_password(self, **kwargs): """ Set the user password :param username: the username :type username: str :param vpn_name: the vpn name :type vpn_name: str :param password: the password :type password: str :rtype: plugin.PluginResponse :return: SEMP request """ username = get_key_from_kwargs('username', kwargs) vpn_name = get_key_from_kwargs('vpn_name', kwargs) password = get_key_from_kwargs('password', kwargs) # Set User Password self.api.x = SolaceXMLBuilder("Set User %s password" % username, version=self.api.version) self.api.x.client_username.username = username self.api.x.client_username.vpn_name = vpn_name self.api.x.client_username.password.password = password self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def shutdown_ingress(self, **kwargs): """Shutdown the ingress of a queue :param shutdown_on_apply: is shutdown permitted boolean or char :param vpn_name: name of the vpn :param queue_name: name of the queue :type shutdown_on_apply: char or bool :type queue_name: str :type vpn_name: str :rtype: plugin.PluginResponse :returns: single SEMP request Example 1: Instant Execution: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").shutdown_ingress(shutdown_on_apply=True, vpn_name="dev_testvpn", queue_name="testqueue1") >>> # response = api.rpc(request) Example 2: Create Request, then Execute >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").shutdown_ingress(shutdown_on_apply=True, vpn_name="dev_testvpn", queue_name="testqueue1") >>> # api.rpc(request) """ shutdown_on_apply = get_key_from_kwargs("shutdown_on_apply", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) if (shutdown_on_apply == 'b') or (shutdown_on_apply == 'q') or (shutdown_on_apply is True): # Lets only shutdown the egress of the queue self.api.x = SolaceXMLBuilder("Shutting down egress for queue:%s" % queue_name, version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.shutdown.ingress self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs) else: logger.warning( "Not disabling Queue, commands could fail since shutdown_on_apply = %s" % shutdown_on_apply)
def exclusive(self, **kwargs): """Set queue exclusivity :param vpn_name: the name of the vpn :param queue_name: the queue name :param exclusive: state :type vpn_name: str :type queue_name: str :type exclusive: bool :rtype: plugin.PluginResponse :returns: single SEMP request Example: Shutdown, Set Exclusive, Start >>> api = SolaceAPI("dev") >>> requests = [] >>> requests.append(api.manage("SolaceQueue").shutdown_ingress(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True)) >>> requests.append(api.manage("SolaceQueue").exclusive(queue_name="testqueue1", vpn_name="dev_testvpn", exclusive=False, shutdown_on_apply=True)) >>> requests.append(api.manage("SolaceQueue").enable(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True)) >>> # [api.rpc(x) for x in requests] """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) exclusive = get_key_from_kwargs("exclusive", kwargs) # Default to NON Exclusive queue if not exclusive: self.api.x = SolaceXMLBuilder("Set Queue %s to Non Exclusive " % queue_name, version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.access_type.non_exclusive else: # Non Exclusive queue self.api.x = SolaceXMLBuilder("Set Queue %s to Exclusive " % queue_name, version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.access_type.exclusive self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def permission(self, **kwargs): """Sets permission on a queue :param vpn_name: the name of the vpn :param queue_name: the queue name :param permission: which permission to grant non-owner users. e.g. "consume", "delete", "modify-topic", "read-only" :type vpn_name: str :type queue_name: str :type permission: str :rtype: plugin.PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").permission(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True, permission="consume") >>> # api.rpc(request) """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) permission = get_key_from_kwargs("permission", kwargs) # Open Access self.api.x = SolaceXMLBuilder("Settings Queue %s Permission to %s" % (queue_name, permission), version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.permission.all if permission == "consume": self.api.x.message_spool.queue.permission.consume elif permission == "delete": self.api.x.message_spool.queue.permission.delete elif permission == "modify-topic": self.api.x.message_spool.queue.permission.modify_topic elif permission == "read-only": self.api.x.message_spool.queue.permission.read_only self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def create_user(self, **kwargs): """ Create the user :param username: the username :type username: str :param vpn_name: the vpn name :type vpn_name: str :rtype: plugin.PluginResponse :return: SEMP request """ username = get_key_from_kwargs('username', kwargs) vpn_name = get_key_from_kwargs('vpn_name', kwargs) self.api.x = SolaceXMLBuilder("Creating User %s" % username, version=self.api.version) self.api.x.create.client_username.username = username self.api.x.create.client_username.vpn_name = vpn_name self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def owner(self, **kwargs): """ Set the owner :param vpn_name: the name of the vpn :param queue_name: the queue name :param owner: the owner client-username :type vpn_name: str :type queue_name: str :type owner: str :rtype: plugin.PluginResponse :returns: single SEMP request Example: >>> api = SolaceAPI("dev") >>> requests = [] >>> requests.append(api.manage("SolaceQueue").shutdown_ingress(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True)) >>> requests.append(api.manage("SolaceQueue").shutdown_egress(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True)) >>> requests.append(api.manage("SolaceQueue").owner(vpn_name="dev_testvpn", queue_name="testqueue1", owner_username="******")) >>> requests.append(api.manage("SolaceQueue").enable(queue_name="testqueue1", vpn_name="dev_testvpn")) >>> # [api.rpc(x) for x in requests] """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) owner = get_key_from_kwargs("owner_username", kwargs) if owner == "%lsVPN": owner = vpn_name logger.info("Owner being set to VPN itself: %s" % owner) # Queue Owner self.api.x = SolaceXMLBuilder("Set Queue %s owner to %s" % (queue_name, vpn_name), version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name self.api.x.message_spool.queue.owner.owner = owner self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def no_subscription_manager(self, **kwargs): """ no subscription manager :param username: the username :type username: str :param vpn_name: the vpn name :type vpn_name: str :rtype: plugin.PluginResponse :return: SEMP request """ username = get_key_from_kwargs('username', kwargs) vpn_name = get_key_from_kwargs('vpn_name', kwargs) # No Subscription Managemer self.api.x = SolaceXMLBuilder("Default User %s subscription manager" % username, version=self.api.version) self.api.x.client_username.username = username self.api.x.client_username.vpn_name = vpn_name self.api.x.client_username.no.subscription_manager self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def consume(self, **kwargs): """Sets consume permission. add `consume` kwarg to allow non-owner users to consume. :param vpn_name: the name of the vpn :param queue_name: the queue name :param consume: set to "all" to allow ALL appliance client-users to "consume" :type vpn_name: str :type queue_name: str :type consume: str :rtype: plugin.PluginResponse :returns: single SEMP request .. deprecated:: 2.0 Use :func:`permission` instead. Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceQueue").consume(queue_name="testqueue1", vpn_name="dev_testvpn", shutdown_on_apply=True, consume="all") >>> # response = api.rpc(request) "" """ vpn_name = get_key_from_kwargs("vpn_name", kwargs) queue_name = get_key_from_kwargs("queue_name", kwargs) consume = get_key_from_kwargs("consume", kwargs) # Open Access self.api.x = SolaceXMLBuilder( "Settings Queue %s Permission to Consume" % queue_name, version=self.api.version) self.api.x.message_spool.vpn_name = vpn_name self.api.x.message_spool.queue.name = queue_name if consume == "all": self.api.x.message_spool.queue.permission.all self.api.x.message_spool.queue.permission.consume self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def no_guarenteed_endpoint(self, **kwargs): """ no guaranteed endpoint :param username: the username :type username: str :param vpn_name: the vpn name :type vpn_name: str :rtype: plugin.PluginResponse :return: SEMP request """ username = get_key_from_kwargs('username', kwargs) vpn_name = get_key_from_kwargs('vpn_name', kwargs) # No Guarenteed Endpoint self.api.x = SolaceXMLBuilder("Default User %s guaranteed endpoint override" % username, version=self.api.version) self.api.x.client_username.username = username self.api.x.client_username.vpn_name = vpn_name self.api.x.client_username.no.guaranteed_endpoint_permission_override self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def new_acl(self, **kwargs): """Returns a SEMP request for new ACL profile. Example: >>> api = SolaceAPI("dev") >>> request = api.manage("SolaceACLProfile").new_acl(name="myprofile", vpn_name="dev_testvpn") >>> # response = api.rpc(request) :param name: name of the profile :param vpn_name: vpn name :rtype: PluginResponse :returns: single SEMP request """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) self.api.x = SolaceXMLBuilder("Profile %s" % name, version=self.api.version) self.api.x.create.acl_profile.name = name self.api.x.create.acl_profile.vpn_name = vpn_name self.commands.enqueue(PluginResponse(str(self.api.x), **kwargs)) return PluginResponse(str(self.api.x), **kwargs)
def get(self, **kwargs): """Returns the ACL immediately as a dictionary :param name: name of the profile :param vpn_name: vpn name :returns: tuple SEMP request and kwargs :rtype: dict :returns: the acl profile """ name = get_key_from_kwargs("name", kwargs) vpn_name = get_key_from_kwargs("vpn_name", kwargs) self.api.x = SolaceXMLBuilder("Profile %s" % name, version=self.api.version) self.api.x.show.acl_profile.name = name self.api.x.show.acl_profile.vpn_name = vpn_name self.commands.enqueue(self.api.x) return self.api.rpc(PluginResponse(str(self.api.x), **kwargs))
def test_plugin_response_rpc(self): p = PluginResponse( '<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>', primaryOnly=True) x = self.solace.rpc(p) self.assertIsInstance(x, list)