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 __init__(self, **kwargs):
"""Initialize in Query or Batch mode
Example:
>>> from libsolace.settingsloader import settings
>>> from libsolace.SolaceAPI import SolaceAPI
>>> client = SolaceAPI("dev")
>>> client.manage("SolaceClientProfile", name="myprofile", vpn_name="testvpn").commands.commands
[XML, XML, XML]
:param api: The instance of SolaceAPI if not called from SolaceAPI.manage
Optional (Batch/Provision) Mode
:param name: the name of the profile
:param vpn_name: name of the VPN to scope the ACL to
:param defaults: dictionary of defaults
:param max_clients: max clients sharing a username connection limit
:type api: SolaceAPI
:type name: str
:type vpn_name: str
:type defaults: dict
:type max_clients: int
:returns: instance with batch requests on SolaceACLProfile.commands.commands
:rtype: SolaceClientProfile
"""
self.api = get_key_from_kwargs("api", kwargs)
self.commands = SolaceCommandQueue(version=self.api.version)
kwargs.pop("api")
if kwargs == {}:
return
if not "name" in kwargs:
logger.info("No name kwarg, assuming query mode")
return
self.name = get_key_from_kwargs('name', kwargs)
self.vpn_name = get_key_from_kwargs('vpn_name', kwargs)
self.defaults = get_key_from_kwargs('defaults',
kwargs,
default=self.defaults)
self.max_clients = get_key_from_kwargs(
'max_clients', kwargs, default=self.defaults.get("max_clients"))
if kwargs.get('options', None) is None:
logger.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance"
)
self.new_client_profile(**kwargs)
self.allow_consume(**kwargs)
self.allow_send(**kwargs)
self.allow_endpoint_create(**kwargs)
self.allow_transacted_sessions(**kwargs)
def __init__(self, **kwargs):
if kwargs == {}:
return
# decorator, for caching decorator creates and set this property, Missing exception is used also, so leave
# completely unassigned. this line is just here for reference.
# self.exists = None
# get the connection SolaceAPI instance
self.api = get_key_from_kwargs("api", kwargs)
# create a commandqueue instance for queuing up XML and validating
self.commands = SolaceCommandQueue(version=self.api.version)
if not "vpn_name" in kwargs:
logger.info("No vpn_name kwarg, assuming query mode")
else:
self.vpn_name = get_key_from_kwargs("vpn_name", kwargs)
self.owner_username = get_key_from_kwargs("owner_username",
kwargs,
default=self.vpn_name)
self.acl_profile = get_key_from_kwargs("acl_profile",
kwargs,
default=self.vpn_name)
self.options = None
logger.debug("Creating vpn in env: %s vpn: %s, kwargs: %s" %
(self.api.environment, self.vpn_name, kwargs))
# set defaults
for k, v in self.default_settings.items():
logger.info("Setting Key: %s to %s" % (k, v))
setattr(self, k, v)
# use kwargs to tune defaults
for k, v in self.default_settings.items():
if k in kwargs:
logger.info("Overriding Key: %s to %s" % (k, kwargs[k]))
setattr(self, k, kwargs[k])
# backwards compatibility for None options passed to still execute "add" code
if self.options is None:
logger.warning(
"No options passed, assuming you meant 'add', please update usage of this class to pass a OptionParser instance"
)
# stack the commands
self.create_vpn(**kwargs)
self.clear_radius(**kwargs)
self.set_internal_auth(**kwargs)
self.set_spool_size(**kwargs)
self.set_large_message_threshold(**kwargs)
self.set_logger_tag(**kwargs)
self.enable_vpn(**kwargs)
def __init__(self, **kwargs):
"""
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 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, *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 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
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)
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 __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)
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:
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)
