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 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)
# 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 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 solace_delete_client_username(options):
""" Deletes users / profiles / acl's where neccesary.
Has a shutdown only mode which only shutdowns the user
Has a force remove now mode which kills everything!
Shutdown User
Delete User
"""
for environment in options.environment:
solace = SolaceAPI(environment, testmode=options.testmode)
try:
vpnname = name(options.vpnname, environment)
except Exception, e:
vpnname = options.vpnname
# Users
usernames = []
for username in options.username:
try:
usernames.append(username % environment)
except Exception, e:
usernames.append(username)
def solace_manage_profile(run_options):
"""
Deletes profile, solace 6.2+ needs to be scoped to VPN, prior versions
are global.
:param run_options: the Options Parser instance
:return:
"""
logging.info("Options: %s" % run_options)
for environment in run_options.environment:
solace = SolaceAPI(environment, testmode=run_options.testmode)
# try substitute environment into vpn_name if it is formated '%s_somename'
try:
vpnname = name(run_options.vpnname, environment)
except Exception, e:
vpnname = run_options.vpnname
# profiles
profiles = []
for profile in run_options.profile:
try:
profiles.append(profile % environment)
except Exception, e:
profiles.append(profile)
def setUp(self):
self.api = SolaceAPI("dev")
self.plugin = get_plugin_from_api(self.api, __plugin_name__)
self.queue_config = {
"retries": 0,
"consume": "all",
"exclusive": "true",
"max_bind_count": 10,
"queue_size": 1024,
"owner": "default"
}
def solace_profile(options=None, vpn=None):
""" Create / Update Profile """
logging.info("Profile Options: %s" % options)
for environment in options.environment:
solace = SolaceAPI(environment, testmode=options.testmode)
# try substitite environment into vpn_name if it is formated '%s_somename'
try:
vpnname = vpn % environment
except Exception, e:
vpnname = vpn
logging.info("VPN Name: %s" % vpnname)
# Users
profiles = []
for profile in options.profile:
try:
profiles.append(profile % environment)
except Exception, e:
profiles.append(profile)
class TestSolaceAPI(unittest.TestCase):
def setUp(self):
self.solace = SolaceAPI('dev')
def test_connect(self):
self.assertIsInstance(self.solace, SolaceAPI)
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=True)
self.assertTrue(self.solace.testmode)
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=False)
self.assertFalse(self.solace.testmode)
def test_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad")
def test_single_node_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad", detect_status=False)
def test_single_appliance(self):
self.solace = SolaceAPI("single", detect_status=False)
self.assertEqual(self.solace.primaryRouter, "http://solace1.swe1.unibet.com/SEMP")
def test_failed_detection(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("backup_only")
def test_failed_detection2(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("primary_only")
def test_bad_config_no_mgmt(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad_no_mgmt", detect_status=False)
def test_backup_only_rpc(self):
self.solace = SolaceAPI("dev")
self.solace.rpc('<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>', backupOnly=True)
def test_get_redundancy(self):
response = SolaceAPI("dev").get_redundancy()
self.assertIsInstance(response, list)
def test_get_redundancy_error(self):
with self.assertRaises(Exception):
response = SolaceAPI("dev", version="foo").get_redundancy()
def test_get_memory(self):
memory = SolaceAPI("dev").get_memory()
self.assertIsInstance(memory, list)
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)
def test_plugin_rpc_tuple(self, **kwargs):
res = ('<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>', kwargs)
x = self.solace.rpc(res)
self.assertIsInstance(x, list)
def test_plugin_rpc_bad_request_object(self):
res = []
with self.assertRaises(Exception):
x = self.solace.rpc(res)
def test_manage(self):
x = self.solace.manage("SolaceUser")
self.assertEqual(str(x.__class__), "<class 'libsolace.items.SolaceUser.SolaceUser'>")
def test_bad_config_no_mgmt(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad_no_mgmt", detect_status=False)
"--debug",
action="store_true",
dest="debug",
default=False,
help="toggles solace debug mode")
(options, args) = parser.parse_args()
if not options.env:
parser.print_help()
sys.exit()
if options.debug:
logging.getLogger().setLevel(logging.DEBUG)
# forces read-only
options.testmode = True
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" %
(settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
connection.manage("SolaceClientProfile")
request = SolaceXMLBuilder()
request.show.message_vpn.vpn_name = '*'
response = connection.rpc(str(request), primaryOnly=True)
for vpn in response[0]['rpc-reply']['rpc']['show']['message-vpn']['vpn']:
print vpn['name']
def setUp(self):
self.solace = SolaceAPI('dev')
def test_get_memory(self):
memory = SolaceAPI("dev").get_memory()
self.assertIsInstance(memory, list)
default=False, help="set to enable reject-msg-to-sender-on-discard")
(options, args) = parser.parse_args()
if not options.env:
parser.print_help()
sys.exit()
if not options.vpn_name:
parser.print_help()
sys.exit()
if options.testmode:
logging.info("TEST MODE ACTIVE!!!")
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" % (settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
queues = connection.list_queues(options.vpn_name)
commands = generateXMLForManagingRejectMsgToSenderOnDiscard(vpn_name=options.vpn_name, queues=queues,
reject_msg_to_sender_on_discard=options.reject_msg_to_sender_on_discard)
print("The following queues will be manipulated in %s environment! " % settings.env)
pprint.pprint(queues)
s = raw_input('Do you want to continue? N/y? ')
if s.lower() == 'y':
for cmd in commands.commands:
connection.rpc(str(cmd))
else:
print("chickening out...")
(options, args) = parser.parse_args()
if not options.env:
parser.print_help()
sys.exit()
if not options.vpn_name:
parser.print_help()
sys.exit()
if options.testmode:
logging.info("TEST MODE ACTIVE!!!")
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" %
(settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
queues = connection.list_queues(options.vpn_name)
commands = generateXMLForManagingRejectMsgToSenderOnDiscard(
vpn_name=options.vpn_name,
queues=queues,
reject_msg_to_sender_on_discard=options.reject_msg_to_sender_on_discard
)
print("The following queues will be manipulated in %s environment! " %
settings.env)
pprint.pprint(queues)
s = raw_input('Do you want to continue? N/y? ')
if s.lower() == 'y':
for cmd in commands.commands:
# client.create_retention_policy("30d", "4w", 1, options.influxdb_db, True)
except Exception, e:
logging.error("Unable to connect to influxdb")
sys.exit(1)
if options.update_retention:
logging.info("Altering retention policies")
client.alter_retention_policy("default", duration="4w", replication=1, default=True)
# forces read-only
options.testmode = True
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" % (settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
"""
Gather client stats, this is quite slow if you have MANY clients!
"""
if options.clients:
connection.x = SolaceXMLBuilder("show clients stats")
connection.x.show.client.name = options.filter
connection.x.show.client.stats
# measurement point start
startTime = time.time()
# set time now immediately before we request
timeNow = get_time()
logging.info("TEST MODE ACTIVE!!!")
if options.debug:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.INFO)
# Details for VPN that we should discard, including
# * VPN
# * ACL profile
# * User
environment = options.env
vpn = options.vpn_name
vpn_name = vpn # '%s_%s' % (environment, vpn)
username = vpn # '%s_%s' % (environment, vpn)
acl_profile = vpn_name
solace = SolaceAPI(options.env, testmode=options.testmode)
# Shutdown the VPN
shutdown_vpn(solace, vpn_name)
# Verify queue usage
verify_queues(solace, vpn_name)
# Verify users
try:
verify_users(solace, vpn_name)
except AttributeError, ex:
logging.warn("Verify users threw an exception: %s" % str(ex))
# Delete queues
delete_queues(solace, vpn_name)
options.influxdb_db,
)
try:
client.create_database(options.influxdb_db)
except Exception, e:
logging.warn("Unable to create database, does it already exist?")
except Exception, e:
logging.error("Unable to connect to influxdb")
sys.exit(1)
# forces read-only
options.testmode = True
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" % (settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
if options.details:
connection.x = SolaceXMLBuilder("show clients details")
connection.x.show.client.name = options.client
connection.x.show.client.detais
elif options.stats:
connection.x = SolaceXMLBuilder("show clients stats")
connection.x.show.client.name = options.client
connection.x.show.client.stats
# get the clients
clients = connection.rpc(str(connection.x), primaryOnly=True)
count = 0
# print clients[0]
if not options.env:
parser.print_help()
sys.exit()
if not options.vpn_name:
parser.print_help()
sys.exit()
if not options.queues:
parser.print_help()
sys.exit()
if options.testmode:
logging.info("TEST MODE ACTIVE!!!")
settings.env = options.env.lower()
queues = options.queues.split(',')
logging.info("Connecting to appliance in %s, testmode:%s" % (settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
commands = generateXML(vpn_name=options.vpn_name, queues=queues, api=connection)
print("The following queues will be manipulated in %s environment! " % settings.env)
pprint.pprint(queues)
s = raw_input('Do you want to continue? N/y? ')
if s.lower() == 'y':
for cmd in commands:
connection.rpc(cmd)
else:
print("chickening out...")
def setUp(self):
self.plugin = get_plugin("SolaceVPN", SolaceAPI("dev"))
try:
client.create_database(options.influxdb_db)
except Exception, e:
logging.warn(
"Unable to create database, does it already exist?")
except Exception, e:
logging.error("Unable to connect to influxdb")
sys.exit(1)
# forces read-only
options.testmode = True
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" %
(settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
if options.details:
connection.x = SolaceXMLBuilder("show clients details")
connection.x.show.client.name = options.client
connection.x.show.client.detais
elif options.stats:
connection.x = SolaceXMLBuilder("show clients stats")
connection.x.show.client.name = options.client
connection.x.show.client.stats
# get the clients
clients = connection.rpc(str(connection.x), primaryOnly=True)
count = 0
# print clients[0]
def setUp(self):
self.api = SolaceAPI("dev")
self.plugin = get_plugin_from_api(self.api, __plugin_name__)
def setUp(self):
self.api = SolaceAPI("dev")
self.plugin = get_plugin_from_api(self.api, __plugin_name__)
class TestSolaceUser(unittest.TestCase):
def setUp(self):
self.api = SolaceAPI("dev")
self.plugin = get_plugin_from_api(self.api, __plugin_name__)
def test_zzz_get_solace_client_profile_batch_provision(self):
self.plugin = get_plugin_from_api(self.api,
__plugin_name__,
force=True,
**test_kwargs)
self.assertTrue(isinstance(self.plugin.commands.commands, list))
self.assertEqual(
self.plugin.commands.commands[0][0],
'<rpc semp-version="%s"><create><client-username><username>my_componenet</username><vpn-name>default</vpn-name></client-username></create></rpc>'
% self.api.version)
def test_requirements(self):
xml = get_plugin_from_api(self.api,
__plugin_name__).requirements(**test_kwargs)
self.assertIsNone(xml)
def test_bad_requirements(self):
self.assertRaises(
BaseException,
get_plugin_from_api(
self.api, __plugin_name__).requirements(**test_bad_kwargs))
def test_get(self):
xml = get_plugin_from_api(self.api, __plugin_name__).get(
client_username="******", vpn_name="default")
self.assertEqual(
xml[0]['rpc-reply']['rpc']['show']['client-username']
['client-usernames']['client-username']['message-vpn'], 'default')
def test_zzx_delete(self):
self.api.rpc(
get_plugin_from_api(self.api,
__plugin_name__).create_user(force=True,
**test_kwargs))
xml = get_plugin_from_api(self.api, __plugin_name__).delete(
client_username="******",
vpn_name="default",
force=True,
shutdown_on_apply=True,
skip_before=True)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><no><client-username><username>my_componenet</username><vpn-name>default</vpn-name></client-username></no></rpc>'
% self.api.version)
def test_check_client_profile_exists(self):
self.assertTrue(
get_plugin_from_api(
self.api,
__plugin_name__).check_client_profile_exists(**test_kwargs))
def test_check_client_profile_not_exists(self):
self.assertFalse(
get_plugin_from_api(self.api,
__plugin_name__).check_client_profile_exists(
**test_bad_kwargs))
def test_check_acl_profile_exists(self):
self.assertTrue(
get_plugin_from_api(
self.api,
__plugin_name__).check_acl_profile_exists(**test_kwargs))
def test_check_acl_profile_not_exists(self):
self.assertFalse(
get_plugin_from_api(
self.api,
__plugin_name__).check_acl_profile_exists(**test_bad_kwargs))
def test_aaa_create_user(self):
xml = get_plugin_from_api(self.api,
__plugin_name__).create_user(force=True,
**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><create><client-username><username>my_componenet</username><vpn-name>default</vpn-name></client-username></create></rpc>'
% self.api.version)
def test_ccc_shutdown(self):
test_kwargs['shutdown_on_apply'] = True
xml = get_plugin_from_api(self.api,
__plugin_name__).shutdown(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><shutdown/></client-username></rpc>'
% self.api.version)
def test_ccd_set_client_profile(self):
test_kwargs['shutdown_on_apply'] = True
xml = get_plugin_from_api(
self.api, __plugin_name__).set_client_profile(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><client-profile><name>default</name></client-profile></client-username></rpc>'
% self.api.version)
def test_cce_set_acl_profile(self):
test_kwargs['shutdown_on_apply'] = True
xml = get_plugin_from_api(
self.api, __plugin_name__).set_acl_profile(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><acl-profile><name>default</name></acl-profile></client-username></rpc>'
% self.api.version)
def test_no_guarenteed_endpoint(self):
xml = get_plugin_from_api(
self.api, __plugin_name__).no_guarenteed_endpoint(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><no><guaranteed-endpoint-permission-override/></no></client-username></rpc>'
% self.api.version)
def test_no_subscription_manager(self):
xml = get_plugin_from_api(
self.api, __plugin_name__).no_subscription_manager(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><no><subscription-manager/></no></client-username></rpc>'
% self.api.version)
def test_set_password(self):
xml = get_plugin_from_api(self.api,
__plugin_name__).set_password(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><password><password>passw</password></password></client-username></rpc>'
% self.api.version)
def test_zzz_no_shutdown(self):
xml = get_plugin_from_api(self.api,
__plugin_name__).no_shutdown(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(
xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><no><shutdown/></no></client-username></rpc>'
% self.api.version)
sys.exit(1)
if options.update_retention:
logging.info("Altering retention policies")
client.alter_retention_policy("default",
duration="4w",
replication=1,
default=True)
# forces read-only
options.testmode = True
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" %
(settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
"""
Gather client stats, this is quite slow if you have MANY clients!
"""
if options.clients:
connection.x = SolaceXMLBuilder("show clients stats")
connection.x.show.client.name = options.filter
connection.x.show.client.stats
# measurement point start
startTime = time.time()
# set time now immediately before we request
timeNow = get_time()
# get the clients
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=False)
self.assertFalse(self.solace.testmode)
def test_get_redundancy_error(self):
with self.assertRaises(Exception):
response = SolaceAPI("dev", version="foo").get_redundancy()
def test_single_node_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad", detect_status=False)
class TestSolaceAPI(unittest.TestCase):
def setUp(self):
self.solace = SolaceAPI('dev')
def test_connect(self):
self.assertIsInstance(self.solace, SolaceAPI)
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=True)
self.assertTrue(self.solace.testmode)
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=False)
self.assertFalse(self.solace.testmode)
def test_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad")
def test_single_node_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad", detect_status=False)
def test_single_appliance(self):
self.solace = SolaceAPI("single", detect_status=False)
self.assertEqual(self.solace.primaryRouter,
"http://solace1.swe1.unibet.com/SEMP")
def test_failed_detection(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("backup_only")
def test_failed_detection2(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("primary_only")
def test_bad_config_no_mgmt(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad_no_mgmt", detect_status=False)
def test_backup_only_rpc(self):
self.solace = SolaceAPI("dev")
self.solace.rpc(
'<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>',
backupOnly=True)
def test_get_redundancy(self):
response = SolaceAPI("dev").get_redundancy()
self.assertIsInstance(response, list)
def test_get_redundancy_error(self):
with self.assertRaises(Exception):
response = SolaceAPI("dev", version="foo").get_redundancy()
def test_get_memory(self):
memory = SolaceAPI("dev").get_memory()
self.assertIsInstance(memory, list)
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)
def test_plugin_rpc_tuple(self, **kwargs):
res = (
'<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>',
kwargs)
x = self.solace.rpc(res)
self.assertIsInstance(x, list)
def test_plugin_rpc_bad_request_object(self):
res = []
with self.assertRaises(Exception):
x = self.solace.rpc(res)
def test_manage(self):
x = self.solace.manage("SolaceUser")
self.assertEqual(str(x.__class__),
"<class 'libsolace.items.SolaceUser.SolaceUser'>")
def test_failed_detection(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("backup_only")
(options, args) = parser.parse_args()
if not options.env:
parser.print_help()
sys.exit()
if not options.vpn_name:
parser.print_help()
sys.exit()
if options.testmode:
logging.info("TEST MODE ACTIVE!!!")
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" % (settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
print("Available VPNS are: %s" % connection.manage(SOLACE_VPN_PLUGIN).list_vpns(vpn_name='*'))
if options.queue_filter:
print("You have said that the queue mentioned is a filter, searching for queues")
queues = connection.list_queues(options.vpn_name, queue_filter=options.queues)
else:
queues = options.queues.split(',')
print("The following queues will be manipulated in %s environment! " % settings.env)
pprint.pprint(queues)
# validating the plan
validate_the_plan(connection=connection, vpn_name=options.vpn_name, queues=queues)
s = raw_input('Do you want to continue? N/y? ')
else:
logging.getLogger().setLevel(logging.ERROR)
if options.settings != None:
import imp
settings = imp.load_source('settings', options.settings)
print "Using settings file: %s" % options.settings
else:
import libsolace.settingsloader as settings
settings.env = options.env.lower()
queues = options.queues.split(',')
logging.info("Connecting to appliance in %s, testmode:%s" %
(settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
commands = generateXML(connection,
options,
vpn_name=options.vpn_name,
queues=queues)
print("The following queues will be manipulated in %s environment! " %
settings.env)
pprint.pprint(queues)
s = raw_input('Do you want to continue? N/y? ')
if s.lower() == 'y':
for cmd in commands.commands:
connection.rpc(str(cmd))
else:
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=True)
self.assertTrue(self.solace.testmode)
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=True)
self.assertTrue(self.solace.testmode)
def test_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad")
def test_testmode(self):
self.solace = SolaceAPI("dev", testmode=False)
self.assertFalse(self.solace.testmode)
def test_single_appliance(self):
self.solace = SolaceAPI("single", detect_status=False)
self.assertEqual(self.solace.primaryRouter, "http://solace1.swe1.unibet.com/SEMP")
def test_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad")
def test_failed_detection2(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("primary_only")
def test_single_node_bad_config(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad", detect_status=False)
def test_backup_only_rpc(self):
self.solace = SolaceAPI("dev")
self.solace.rpc('<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>', backupOnly=True)
def test_single_appliance(self):
self.solace = SolaceAPI("single", detect_status=False)
self.assertEqual(self.solace.primaryRouter,
"http://solace1.swe1.unibet.com/SEMP")
def setUp(self):
self.solace = SolaceAPI('dev')
def test_failed_detection(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("backup_only")
class TestSolaceUser(unittest.TestCase):
def setUp(self):
self.api = SolaceAPI("dev")
self.plugin = get_plugin_from_api(self.api, __plugin_name__)
def test_zzz_get_solace_client_profile_batch_provision(self):
self.plugin = get_plugin_from_api(self.api, __plugin_name__, force=True, **test_kwargs)
self.assertTrue(isinstance(self.plugin.commands.commands, list))
self.assertEqual(self.plugin.commands.commands[0][0], '<rpc semp-version="%s"><create><client-username><username>my_componenet</username><vpn-name>default</vpn-name></client-username></create></rpc>' % self.api.version)
def test_requirements(self):
xml = get_plugin_from_api(self.api, __plugin_name__).requirements(**test_kwargs)
self.assertIsNone(xml)
def test_bad_requirements(self):
self.assertRaises(BaseException,
get_plugin_from_api(self.api, __plugin_name__).requirements(**test_bad_kwargs))
def test_get(self):
xml = get_plugin_from_api(self.api, __plugin_name__).get(client_username="******", vpn_name="default")
self.assertEqual(xml[0]['rpc-reply']['rpc']['show']['client-username']['client-usernames']['client-username'][
'message-vpn'], 'default')
def test_zzx_delete(self):
self.api.rpc(get_plugin_from_api(self.api, __plugin_name__).create_user(force=True, **test_kwargs))
xml = get_plugin_from_api(self.api, __plugin_name__).delete(client_username="******", vpn_name="default",
force=True, shutdown_on_apply=True,
skip_before=True)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml,
'<rpc semp-version="%s"><no><client-username><username>my_componenet</username><vpn-name>default</vpn-name></client-username></no></rpc>' % self.api.version)
def test_check_client_profile_exists(self):
self.assertTrue(get_plugin_from_api(self.api, __plugin_name__).check_client_profile_exists(**test_kwargs))
def test_check_client_profile_not_exists(self):
self.assertFalse(get_plugin_from_api(self.api, __plugin_name__).check_client_profile_exists(**test_bad_kwargs))
def test_check_acl_profile_exists(self):
self.assertTrue(get_plugin_from_api(self.api, __plugin_name__).check_acl_profile_exists(**test_kwargs))
def test_check_acl_profile_not_exists(self):
self.assertFalse(get_plugin_from_api(self.api, __plugin_name__).check_acl_profile_exists(**test_bad_kwargs))
def test_aaa_create_user(self):
xml = get_plugin_from_api(self.api, __plugin_name__).create_user(force=True, **test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml,
'<rpc semp-version="%s"><create><client-username><username>my_componenet</username><vpn-name>default</vpn-name></client-username></create></rpc>' % self.api.version)
def test_ccc_shutdown(self):
test_kwargs['shutdown_on_apply'] = True
xml = get_plugin_from_api(self.api, __plugin_name__).shutdown(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><shutdown/></client-username></rpc>' % self.api.version)
def test_ccd_set_client_profile(self):
test_kwargs['shutdown_on_apply'] = True
xml = get_plugin_from_api(self.api, __plugin_name__).set_client_profile(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><client-profile><name>default</name></client-profile></client-username></rpc>' % self.api.version)
def test_cce_set_acl_profile(self):
test_kwargs['shutdown_on_apply'] = True
xml = get_plugin_from_api(self.api, __plugin_name__).set_acl_profile(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml,
'<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><acl-profile><name>default</name></acl-profile></client-username></rpc>' % self.api.version)
def test_no_guarenteed_endpoint(self):
xml = get_plugin_from_api(self.api, __plugin_name__).no_guarenteed_endpoint(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml, '<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><no><guaranteed-endpoint-permission-override/></no></client-username></rpc>' % self.api.version)
def test_no_subscription_manager(self):
xml = get_plugin_from_api(self.api, __plugin_name__).no_subscription_manager(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml, '<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><no><subscription-manager/></no></client-username></rpc>' % self.api.version)
def test_set_password(self):
xml = get_plugin_from_api(self.api, __plugin_name__).set_password(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml, '<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><password><password>passw</password></password></client-username></rpc>' % self.api.version)
def test_zzz_no_shutdown(self):
xml = get_plugin_from_api(self.api, __plugin_name__).no_shutdown(**test_kwargs)
self.assertIsInstance(xml, PluginResponse)
self.assertEqual(xml.xml, '<rpc semp-version="%s"><client-username><username>my_componenet</username><vpn-name>default</vpn-name><no><shutdown/></no></client-username></rpc>' % self.api.version)
def test_failed_detection2(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("primary_only")
(options, args) = parser.parse_args()
if not options.env:
parser.print_help()
sys.exit()
if not options.vpn_name:
parser.print_help()
sys.exit()
if options.testmode:
logging.info("TEST MODE ACTIVE!!!")
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" %
(settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
print("Available VPNS are: %s" %
connection.manage(SOLACE_VPN_PLUGIN).list_vpns(vpn_name='*'))
if options.queue_filter:
print(
"You have said that the queue mentioned is a filter, searching for queues"
)
queues = connection.list_queues(options.vpn_name,
queue_filter=options.queues)
else:
queues = options.queues.split(',')
print("The following queues will be manipulated in %s environment! " %
settings.env)
pprint.pprint(queues)
def test_bad_config_no_mgmt(self):
with self.assertRaises(Exception):
self.solace = SolaceAPI("bad_no_mgmt", detect_status=False)
logging.info("TEST MODE ACTIVE!!!")
if options.debug:
logging.getLogger().setLevel(logging.DEBUG)
else:
logging.getLogger().setLevel(logging.ERROR)
if options.settings != None:
import imp
settings = imp.load_source('settings', options.settings)
print "Using settings file: %s" % options.settings
else:
import libsolace.settingsloader as settings
settings.env = options.env.lower()
queues = options.queues.split(',')
logging.info("Connecting to appliance in %s, testmode:%s" % (settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
commands = generateXML(connection, options, vpn_name=options.vpn_name, queues=queues)
print("The following queues will be manipulated in %s environment! " % settings.env)
pprint.pprint(queues)
s = raw_input('Do you want to continue? N/y? ')
if s.lower() == 'y':
for cmd in commands.commands:
connection.rpc(str(cmd))
else:
print("chickening out...")
def test_backup_only_rpc(self):
self.solace = SolaceAPI("dev")
self.solace.rpc(
'<rpc semp-version="soltr/6_0"><show><message-spool/></show></rpc>',
backupOnly=True)
usage = "list all vpns in an environment"
parser = OptionParser(usage=usage)
parser.add_option("-e", "--env", "--environment", action="store", type="string", dest="env",
help="environment to run job in eg:[ dev | ci1 | si1 | qa1 | pt1 | prod ]")
parser.add_option("-d", "--debug", action="store_true", dest="debug",
default=False, help="toggles solace debug mode")
(options, args) = parser.parse_args()
if not options.env:
parser.print_help()
sys.exit()
if options.debug:
logging.getLogger().setLevel(logging.DEBUG)
# forces read-only
options.testmode = True
settings.env = options.env.lower()
logging.info("Connecting to appliance in %s, testmode:%s" % (settings.env, options.testmode))
connection = SolaceAPI(settings.env, testmode=options.testmode)
connection.manage("SolaceClientProfile")
request = SolaceXMLBuilder()
request.show.message_vpn.vpn_name = '*'
response = connection.rpc(str(request), primaryOnly=True)
for vpn in response[0]['rpc-reply']['rpc']['show']['message-vpn']['vpn']:
print vpn['name']
def test_get_redundancy(self):
response = SolaceAPI("dev").get_redundancy()
self.assertIsInstance(response, list)
