def test_004(self):
"""
set default flavor
:return:
"""
HEADING()
name = "myflavor"
Default.set_flavor(name, "mycloud")
assert Default.get_flavor("mycloud") == name
self._check(name)
def test_004(self):
"""
set default flavor
:return:
"""
HEADING()
name = "myflavor"
Default.set_flavor(name, "mycloud")
assert Default.get_flavor("mycloud") == name
self._check(name)
def do_info(self, args, arguments):
"""
::
Usage:
info [--cloud=CLOUD] [--format=FORMAT]
Options:
--format=FORMAT the output format [default: table]
--cloud=CLOUD the cloud name
Examples:
cm info
"""
arg = dotdict(arguments)
arg.cloud = arguments["--cloud"] or Default.cloud
arg.FORMAT = arguments["--format"] or "table"
d = {
"cloud": arg.cloud,
"key": Default.key,
"user": Default.user,
"vm": Default.vm,
"group": Default.group,
"secgroup": Default.secgroup,
"counter": Default.get_counter(name="name"),
"image": Default.get_image(category=arg.cloud),
"flavor": Default.get_flavor(category=arg.cloud),
"refresh": str(Default.refresh),
"debug": str(Default.debug),
"interactive": str(Default.interactive),
"purge": str(Default.purge),
}
order = [
"cloud", "key", "user", "vm", "group", "secgroup", "counter",
"image", "flavor", "refresh", "debug", "interactive", "purge"
]
print(
Printer.attribute(d,
order=order,
output=arg.FORMAT,
sort_keys=False))
if d["key"] in ["TBD", ""] or d["user"] in ["TBD", ""]:
msg = "Please replace the TBD values"
msg = msg + "\nSee Also: \n\n" \
+ " cm register profile \n" \
+ " cm default user=YOURUSERNAME\n"
Console.error(msg, traceflag=False)
return ""
def do_info(self, args, arguments):
"""
::
Usage:
info [--cloud=CLOUD] [--format=FORMAT]
Options:
--format=FORMAT the output format [default: table]
--cloud=CLOUD the cloud name
Examples:
cm info
"""
arg = dotdict(arguments)
arg.cloud = arguments["--cloud"] or Default.cloud
arg.FORMAT = arguments["--format"] or "table"
d = {
"cloud": arg.cloud,
"key": Default.key,
"user": Default.user,
"vm": Default.vm,
"group": Default.group,
"secgroup": Default.secgroup,
"counter": Default.get_counter(name="name"),
"image": Default.get_image(category=arg.cloud),
"flavor": Default.get_flavor(category=arg.cloud),
"refresh": str(Default.refresh),
"debug": str(Default.debug),
"interactive": str(Default.interactive),
"purge": str(Default.purge),
}
order = ["cloud", "key", "user", "vm", "group", "secgroup",
"counter", "image", "flavor", "refresh", "debug", "interactive", "purge"]
print(Printer.attribute(d, order=order, output=arg.FORMAT, sort_keys=False))
if d["key"] in ["TBD", ""] or d["user"] in ["TBD", ""]:
msg = "Please replace the TBD values"
msg = msg + "\nSee Also: \n\n" \
+ " cm register profile \n" \
+ " cm default user=YOURUSERNAME\n"
Console.error(msg, traceflag=False)
return ""
def do_info(self, args, arguments):
"""
::
Usage:
info [--cloud=CLOUD] [--format=FORMAT]
Options:
--format=FORMAT the output format [default: table]
--cloud=CLOUD the cloud name
Examples:
cm info
"""
arg = dotdict(arguments)
arg.cloud = arguments["--cloud"] or Default.cloud
arg.FORMAT = arguments["--format"] or "table"
d = {
"cloud": arg.cloud,
"key": Default.key,
"user": Default.user,
"vm": Default.vm,
"group": Default.group,
"secgroup": Default.secgroup,
"counter": Default.get_counter(name="name"),
"image": Default.get_image(category=arg.cloud),
"flavor": Default.get_flavor(category=arg.cloud),
"refresh": str(Default.refresh),
"debug": str(Default.debug),
"interactive": str(Default.interactive),
"purge": str(Default.purge),
}
order = ["cloud", "key", "user", "vm", "group", "secgroup",
"counter", "image", "flavor", "refresh", "debug", "interactive", "purge"]
print(Printer.attribute(d, order=order, output=arg.FORMAT, sort_keys=False))
return ""
class Test_register:
"""
# tests
# for india only
"""
data = dotdict({
# "cloud": Default.cloud,
# only retrieving for india kilo
"cloud": "kilo",
"group": "test",
"vm": "testvm",
"flavor": "TBD",
"image": "TBD",
"wrong_cloud": "no_cloud",
"cert": "~/.cloudmesh/clouds/india/{cloud}/cacert.pem",
"yaml": "cloudmesh1.yaml"
})
data.image = Default.get_image()
data.flavor = Default.get_flavor()
def run(self, command):
command = command.format(**self.data)
banner(command, c="-")
print(command)
parameter = command.split(" ")
shell_command = parameter[0]
args = parameter[1:]
result = Shell.execute(shell_command, args)
print(result)
return str(result)
def setup(self):
pass
def tearDown(self):
pass
def test_001(self):
HEADING("cm register remote {cloud}".format(**self.data))
# os.sytem("yes | cm register india")
result = self.run("cm register remote {cloud}")
print(result)
#result = Shell.cm("register", "india", "--force")
assert "{cloud}".format(**self.data) in result
assert "OS_AUTH_URL" in result
assert "https://kilo.futuresystems.org:5000/v3" in result
def test_002(self):
HEADING("testing cm register random1")
result = self.run("cm register remote doesnotexist")
assert "ERROR: executing" in result
def test_003(self):
HEADING("testing cm register list")
result = self.run("cm register list")
assert "{cloud}".format(**self.data) in result
def test_004(self):
HEADING("testing cm register info")
result = self.run("cm register info")
assert "exists" in result
def test_005(self):
HEADING("testing cm register cat")
result = self.run("cm register cat")
assert "version:" in result
def test_006(self):
HEADING("testing cm register cat --yaml={yaml}".format(**self.data))
result = self.run("cm register cat --yaml={yaml}")
assert "ERROR: executing command" in result
def test_007(self):
HEADING("testing cm register edit --yaml=cloudmesh_doesnotexist.yaml")
result = self.run("cm register edit --yaml=cloudmesh_doesnotexit.yaml")
assert "ERROR: executing command" in result
def test_008(self):
HEADING("testing cm register list ssh")
result = self.run("cm register list ssh")
assert "| host" in result
def test_009(self):
HEADING("testing cm register remote")
result = self.run("cm register remote")
assert "Reading rc file from" in result
def test_010(self):
HEADING("cm register json {cloud}".format(**self.data))
result = self.run("cm register json {cloud}")
assert "openstack" in result
def test_011(self):
HEADING("testing cm register json hadoop")
result = self.run("cm register json hadoop")
assert "Cloud hadoop is not described in cloudmesh.yaml" in result
class Test_vm:
data = dotdict({
"wrong_cloud": "no_cloud",
"cloud": Default.cloud,
"group": "test",
"image": Default.get_image(category=Default.cloud),
"flavor": Default.get_flavor(category=Default.cloud),
"vm": "{}_testvm".format(Default.user),
"vm_rename": "{}_renamed_testvm".format(Default.user),
})
data.image = Default.get_image()
data.flavor = Default.get_flavor()
def run(self, command):
command = command.format(**self.data)
banner(command, c="-")
print(command)
parameter = command.split(" ")
shell_command = parameter[0]
args = parameter[1:]
result = Shell.execute(shell_command, args)
print(result)
return str(result)
def setup(self):
pass
# noinspection PyPep8Naming
def tearDown(self):
pass
def load_key(self):
try:
self.run("cm key load")
result = self.run("cm key upload")
except Exception as e:
print(e)
def test_000(self):
HEADING("key upload")
command= "cm key add --ssh"
result = self.run(command)
def test_001(self):
HEADING("cm vm boot --name={vm} --cloud={cloud} --image={image} --flavor=2 --group={group}".format(**self.data))
self.load_key()
command = "cm vm boot --name={vm} --cloud={cloud} --image={image}" + \
" --flavor={flavor} --group={group}"
result = self.run(command)
assert "OK." in result
def test_002(self):
HEADING("cm vm refresh --cloud={cloud}".format(**self.data))
result = self.run("cm vm refresh --cloud={cloud}")
assert "OK." in result
def test_003(self):
HEADING("cm vm list --cloud={cloud}".format(**self.data))
result = self.run("cm vm list --cloud={cloud}")
assert "Listing VMs on Cloud: {cloud}".format(**self.data) in result
def test_004(self):
HEADING("cm vm list {vm} --cloud={cloud}".format(**self.data))
result = self.run("cm vm list {vm} --cloud={cloud}")
assert "Listing VMs on Cloud: {cloud}".format(**self.data) in result
def test_005(self):
HEADING("cm vm status --cloud={cloud}".format(**self.data))
result = self.run("cm vm status --cloud={cloud}")
assert "OK." in result
def test_006(self):
from pprint import pprint; pprint(self.data)
HEADING("cm vm ip show {vm} --cloud={cloud}".format(**self.data))
result = self.run("cm vm list --refresh --cloud={cloud}")
result = self.run("cm vm ip show {vm} --cloud={cloud}")
assert "name" in result
assert "{vm}".format(**self.data) in result
def test_007(self):
HEADING("cm vm rename {vm} {vm_rename}".format(**self.data))
result = self.run("cm vm rename {vm} {vm_rename}")
assert "OK." in result
def test_008(self):
HEADING("cm vm delete {vm_rename} --cloud={cloud} ".format(**self.data))
result = self.run("cm vm delete {vm_rename} --cloud={cloud}")
assert "OK." in result
def test_009(self):
HEADING("testing purgeing a vm")
result = self.run("cm key add --ssh")
result = self.run("cm info")
result = self.run("cm vm boot")
result = self.run("cm vm list")
result = self.run("cm vm delete last")
result = self.run("cm vm list")
'''
class Test_secgroup:
data = dotdict({
"dgroup": "{}-default".format(Default.user),
"cloud": Default.cloud,
"group": "cm-{}-test".format(Default.user),
"wrong_cloud": "no_cloud",
"rules": {
"rule_http": "80 80 tcp 0.0.0.0/0",
"rule_https": "443 443 tcp 0.0.0.0/0",
"rule_ssh": "22 22 tcp 0.0.0.0/0",
},
"image": Default.get_image(category=Default.cloud),
"flavor": Default.get_flavor(category=Default.cloud),
"vm": "{}_testsecgroup".format(Default.user),
})
for rule in data.rules:
data[rule] = data.rules[rule]
data.tenant = ConfigDict("cloudmesh.yaml")["cloudmesh.clouds"][
data.cloud]["credentials"]["OS_TENANT_NAME"]
def run(self, command):
command = command.format(**self.data)
banner(command, c="-")
print(command)
parameter = command.split(" ")
shell_command = parameter[0]
args = parameter[1:]
result = Shell.execute(shell_command, args)
print(result)
return str(result)
def setup(self):
pass
# noinspection PyPep8Naming
def tearDown(self):
pass
def test_001(self):
HEADING("cm secgroup add ...")
for rule in self.data.rules:
command = "cm secgroup add {} {} {}".format(
self.data.group, rule, self.data["rules"][rule])
result = self.run(command)
command = "cm secgroup list"
result = self.run(command)
for rule in self.data.rules:
assert rule in result
def test_002(self):
HEADING("cm secgroup delete ...")
command = "cm secgroup delete {group}".format(**self.data)
result = self.run(command)
result = self.run("cm secgroup list")
assert self.data.group not in result
def test_003(self):
HEADING("secgroup api")
data = dotdict({'cloud': "cm", 'groupname': 'gvonlasz-default'})
provider = CloudProvider(data.cloud).provider
groups = None
rules = provider.list_secgroup(data.cloud)
"""
# passed
def add_group(cloud, groupname):
provider = CloudProvider(cloud).provider
return provider.create_secgroup(groupname)
# passed
def delete_group(cloud, groupname):
provider = CloudProvider(data.cloud).provider
return provider.delete_secgroup(groupname)
# passed
def add_rule(cloud, groupname, rulename):
ret = None
provider = CloudProvider(data.cloud).provider
# fetch rule from db
cm = CloudmeshDatabase()
db_rule = cm.find(kind="secgrouprule", category="general", name=rulename, scope='first', output='dict')
kwargs = {}
kwargs["protocol"] = db_rule["protocol"]
kwargs["cidr"] = db_rule["cidr"]
kwargs["from_port"] = db_rule["fromPort"]
kwargs["to_port"] = db_rule["toPort"]
group = get_group(cloud, groupname)
if group:
groupid = group["id"]
kwargs["uuid"] = groupid
print (kwargs)
ret = provider.add_secgroup_rule(**kwargs)
return ret
# passed
def delete_rule(cloud, groupname, rulename):
ret = None
provider = CloudProvider(data.cloud).provider
ruleid = get_rule(cloud, groupname, rulename)
if ruleid:
ret = provider.delete_secgroup_rule(ruleid)
else:
Console.error("Rule does not exist - Rule:{}, Group:{}".format(rulename, groupname))
return ret
# passed
def list_groups(cloud):
provider = CloudProvider(cloud).provider
groups = provider.list_secgroup(cloud)
return groups
# passed
def get_group(cloud, groupname):
provider = CloudProvider(cloud).provider
groups = provider.list_secgroup(cloud)
ret = None
for groupkey in groups:
group = groups[groupkey]
if group["name"] == groupname:
ret = group
break
return ret
# passed
def list_rules(cloud, groupname):
provider = CloudProvider(cloud).provider
groups = provider.list_secgroup(cloud)
for id in groups:
group = groups[id]
if groupname == group["name"]:
return group["rules"]
return None
# passed
def get_rule(cloud, groupname, rulename):
rules = list_rules(cloud, groupname)
# find properties for db rule
cm = CloudmeshDatabase()
db_rule = cm.find(kind="secgrouprule", category="general", name=rulename, scope='first', output='dict')
#db_rule = {u'from_port': 80,
# u'ip_protocol': u'tcp',
# u'ip_range': {u'cidr': u'0.0.0.0/0'},
# u'to_port': 80},
ruleid = None
for rule in rules:
if 'cidr' in rule['ip_range']:
if (db_rule["fromPort"] == str(rule['from_port']) and
db_rule["toPort"] == str(rule['to_port']) and
db_rule["protocol"] == rule['ip_protocol'] and
db_rule["cidr"] == rule['ip_range']['cidr']
):
ruleid = rule['id'] #uuid for the rule
return ruleid
"""
# testing each individual method defined in this test
#
# list/get of groups/rules
# all passed
# pprint (list_groups(data.cloud))
# print("dgroup", self.data.dgroup)
# dgroup = self.data.dgroup
# pprint (get_group(data.cloud, "default"))
# pprint (list_rules(data.cloud, "default"))
# pprint (get_rule(data.cloud, "default", "ssh"))
# print ("...should be None")
# pprint(get_group(data.cloud, dgroup))
'''
# testing adding and deleting groups
# all passed
print ("...should be None")
pprint(get_group(data.cloud, "fwtest"))
print ("...should return the newly created object")
pprint(add_group(data.cloud, "fwtest"))
print ("...should be NOT None")
pprint(get_group(data.cloud, "fwtest"))
print ("...deleting")
pprint(delete_group(data.cloud, "fwtest"))
print ("...should be None")
pprint(get_group(data.cloud, "fwtest"))
'''
'''
# testing adding and deleting rules
# all passed
print ("...should return the newly created object")
pprint(add_group(data.cloud, "fwtest"))
print ("...adding ssh rule")
pprint(add_rule(data.cloud, "fwtest", "ssh"))
print ("...listing the group. Should have the ssh rule int it")
pprint(get_group(data.cloud, "fwtest"))
print ("...deleting ssh rule")
pprint(delete_rule(data.cloud, "fwtest", "ssh"))
print ("...listing the group. ssh rule should be gone")
pprint(get_group(data.cloud, "fwtest"))
print ("...deleting the testing group")
pprint(delete_group(data.cloud, "fwtest"))
'''
def test_004(self):
'''
A through test of deleting/updating secgroups.
It creates in the db a testing group with 3 rules;
Uploading the secgroup to cloud;
booting a vm with this newly created group;
deleting the secgroup (should fail as being used);
updating rules for the secgroup
(should succeed - updating rules, but not creating duplicated group);
cleaning up...
delete the testing vm
deleting the testing secgroup
'''
HEADING("creating testing group in db and populate with rules")
for rule in self.data.rules:
command = "cm secgroup add {} {} {}".format(
self.data.group, rule, self.data["rules"][rule])
result = self.run(command)
HEADING("uploading the newly created secgroup to default cloud")
command = "cm secgroup upload {} --cloud={}".format(
self.data.group, self.data.cloud)
result = self.run(command)
HEADING("listing secgroup in default cloud")
command = "cm secgroup list --cloud={}".format(self.data.cloud)
result = self.run(command)
assert "80" in result and self.data.group in result
HEADING("booting a vm with the test secgroup")
command = "cm vm boot --name={vm} --cloud={cloud} --image={image}" + \
" --flavor={flavor} --secgroup={group}"
result = self.run(command)
assert "OK." in result
HEADING(
"cm secgroup delete ... Deleting a secgroup that is being used")
command = "cm secgroup delete {} --cloud={}".format(
self.data.group, self.data.cloud)
result = self.run(command)
assert "ERROR" in result and "in use" in result
HEADING("adding new rule to the test secgroup (change in db)")
command = "cm secgroup add {} ssh 8765 8765 tcp 0.0.0.0/0".format(
self.data.group)
result = self.run(command)
HEADING(
"updating the teseting secgroup in the default cloud (upload to cloud)"
)
command = "cm secgroup upload {} --cloud={}".format(
self.data.group, self.data.cloud)
result = self.run(command)
HEADING("cm secgroup list --cloud={}".format(self.data.cloud))
command = "cm secgroup list --cloud={}".format(self.data.cloud)
result = self.run(command)
assert "8765" in result
HEADING("Cleaning up......")
HEADING("deleting the test vm and the test secgroup")
command = "cm vm delete {}".format(self.data.vm)
result = self.run(command)
command = "cm secgroup delete {} --cloud={}".format(
self.data.group, self.data.cloud)
result = self.run(command)
command = "cm secgroup list --cloud={}".format(self.data.cloud)
result = self.run(command)
assert self.data.group not in result
def test_004(self):
HEADING("set default flavor")
name = "myflavor"
Default.set_flavor(name, self.data.cloud)
assert Default.get_flavor(self.data.cloud) == name
def test_004(self):
HEADING("set default flavor")
name = "myflavor"
Default.set_flavor(name, self.data.cloud)
assert Default.get_flavor(self.data.cloud) == name
