def authenticate(self):
libcloud.security.VERIFY_SSL_CERT = False
provider = get_driver(Provider.OPENSTACK)
credentials = dotdict(self.info["credentials"])
# print (credentials)
# print ("U", credentials.OS_USERNAME)
self.credentials = credentials
"""
#chameleon
self.driver = provider(
credentials.OS_USERNAME,
credentials.OS_PASSWORD,
ex_force_auth_url=credentials.OS_AUTH_URL,
ex_force_auth_version="3.x_password",
#ex_force_auth_version="3.x_password",
ex_tenant_name=credentials.OS_TENANT_NAME,
# ex_domain_name=credentials.OS_PROJECT_DOMAIN_ID,
ex_force_service_type='compute',
ex_force_service_region=credentials.OS_REGION_NAME)
"""
try:
self.driver = provider(credentials.username, credentials.password,
**credentials)
except Exception as e:
Error.traceback(error=e, debug=True, trace=True)
def main():
"""evegenie.
Usage:
evegenie --help
evegenie FILENAME
Arguments:
FILENAME The filename containing the schema
Options:
-h --help
Description:
Creates a schema from objects defined in a jason file
"""
arguments = docopt(main.__doc__, sys.argv[1:])
# print(arguments)
if arguments["--help"]:
print(main.__doc__)
sys.exit()
try:
filename = arguments["FILENAME"]
if os.path.isfile(filename):
run(filename)
except Exception as e:
print("ERROR: generating schema")
Error.traceback(error=e, debug=True, trace=True)
def read_yaml_config(filename, check=True, osreplace=True, exit=True):
"""
reads in a yaml file from the specified filename. If check is set to true
the code will fail if the file does not exist. However if it is set to
false and the file does not exist, None is returned.
:param exit: if true is exist with sys exit
:param osreplace: if true replaces environment variables from the OS
:param filename: the file name
:param check: if True fails if the file does not exist,
if False and the file does not exist return will be None
"""
location = filename
if location is not None:
location = path_expand(location)
if not os.path.exists(location) and not check:
return None
if check and os.path.exists(location):
# test for tab in yaml file
if check_file_for_tabs(location):
log.error("The file {0} contains tabs. yaml "
"Files are not allowed to contain tabs".format(location))
sys.exit()
result = None
try:
if osreplace:
result = open(location, 'r').read()
t = Template(result)
result = t.substitute(os.environ)
# data = yaml.safe_load(result)
data = ordered_load(result, yaml.SafeLoader)
else:
f = open(location, "r")
# data = yaml.safe_load(f)
data = ordered_load(result, yaml.SafeLoader)
f.close()
return data
except Exception as e:
log.error(
"The file {0} fails with a yaml read error".format(filename))
Error.traceback(e)
sys.exit()
else:
log.error("The file {0} does not exist.".format(filename))
if exit:
sys.exit()
return None
def postcmd(self, stop, line):
StopWatch.stop("command")
try:
variable = Variables()
if "timer" not in variable:
variable["timer"] = "off"
if variable["timer"].lower() in ['on', 'true']:
print("Timer: {:.4f}s ({})".format(StopWatch.get("command"),
line.strip()))
variable.close()
except Exception as e:
Error.traceback(error=e)
return stop
def postcmd(self, stop, line):
StopWatch.stop("command")
try:
variable = Variables()
if "timer" not in variable:
variable["timer"] = "False"
if str(variable["timer"].lower()) in ['on', 'true']:
command_time = StopWatch.get("command")
load_time = StopWatch.get("load")
line_strip = line.strip()
print(f"# Timer: {command_time:.4f}s "
f"Load: {load_time:.4f}s "
f"{line_strip}")
variable.close()
except Exception as e:
Error.traceback(error=e)
return stop
def do_openstack(self, args, arguments):
"""
::
Usage:
openstack info
openstack yaml
openstack yaml list [CLOUD]
openstack image list [CLOUD] [--format=FORMAT]
openstack flavor list [CLOUD] [--format=FORMAT]
openstack vm list [CLOUD] [--user=USER] [--format=FORMAT] [--ip=public|private]
This command does some useful things.
Arguments:
FILE a file name
Options:
-f specify the file
"""
# print(arguments)
default = Default()
cloud = arguments.CLOUD or default["global"]["cloud"]
default.close()
arguments.format = arguments["--format"] or 'table'
arguments.user = arguments["--user"]
fd = None
if arguments.info:
if arguments.CLOUD is None:
arguments.CLOUD = cloud
provider = OpenStack(arguments.CLOUD)
provider.information()
elif arguments.yaml and arguments.list:
filename = path_expand("~/.cloudmesh/cloudmesh.yaml")
content = readfile(filename)
d = yaml.load(content, Loader=yaml.RoundTripLoader)
if arguments.CLOUD is None:
default_cloud = default["global"]["cloud"]
# print (yaml.dump(d, indent=4, Dumper=yaml.RoundTripDumper))
info = OrderedDict()
clouds = d["cloudmesh"]["clouds"]
for cloud in clouds:
info[cloud] = {
"default": "",
"name": cloud,
"type": clouds[cloud]["cm_type"],
"label": clouds[cloud]["cm_label"],
"flavor": clouds[cloud]["default"]["flavor"],
"image": clouds[cloud]["default"]["image"]
}
if default_cloud == cloud:
info[cloud]["default"] = "*"
print(Printer.dict(info,
order=["default", "name", "type", "label", "flavor", "image"]))
else:
cloud = arguments.CLOUD
clouds = d["cloudmesh"]["clouds"]
print(yaml.dump(clouds[cloud], indent=4, Dumper=yaml.RoundTripDumper))
elif arguments.yaml:
filename = path_expand("~/.cloudmesh/cloudmesh.yaml")
content = readfile(filename)
d = yaml.load(content, Loader=yaml.RoundTripLoader)
print(yaml.dump(d, indent=4, Dumper=yaml.RoundTripDumper))
elif arguments.image and arguments.list:
if arguments.CLOUD is None:
arguments.CLOUD = cloud
# print (arguments.CLOUD)
provider = OpenStack(arguments.CLOUD)
images = provider.images()
try:
fd = flatme(images)
except Exception as e:
Error.traceback(error=e, debug=True, trace=True)
order = ["name", "extra__metadata__user_id", "extra__metadata__image_state", "extra__updated"]
header = ["name", "user", "state", "updated"]
if arguments.format == "table":
print(arguments.CLOUD)
print(Printer.dict(fd,
sort_keys="name",
order=order,
header=header,
output=arguments.format))
# elif arguments.format == "dict":
# print(yaml.dump(images, indent=4, Dumper=yaml.RoundTripDumper))
else:
print(Printer.dict(images, output=arguments.format))
elif arguments.flavor and arguments.list:
if arguments.CLOUD is None:
arguments.CLOUD = cloud
# print (arguments.CLOUD)
provider = OpenStack(arguments.CLOUD)
d = provider.flavors()
print(arguments.CLOUD)
print(Printer.dict(d,
sort_keys="id",
output=arguments.format,
order=['id', 'name', 'ram', 'vcpus', 'disk']))
elif arguments.vm and arguments.list:
if arguments.CLOUD is None:
arguments.CLOUD = cloud
# print (arguments.CLOUD)
provider = OpenStack(arguments.CLOUD)
elements = provider.vms()
if arguments.user is not None:
found = {}
for element in elements:
if elements[element]['extra']['userId'] == arguments.user:
found[element] = elements[element]
elements = found
try:
fd = flatme(elements)
except Exception as e:
Error.traceback(error=e, debug=True, trace=True)
order = ["name", 'extra__vm_state', 'extra__metadata__image', 'extra__metadata__flavor', "extra__key_name",
'extra__metadata__group', "extra__userId", "extra__created", 'private_ips', 'public_ips']
header = ["name", "state", "image", "flavor", "key", "group", "user", "created", "private", "public"]
if arguments.format == "table" or arguments.format == "inventory":
for element in fd:
fd[element]['private_ips'] = ','.join(fd[element]['private_ips'])
fd[element]['public_ips'] = ','.join(fd[element]['public_ips'])
# fd[element]["extra__created"] = humanize.timedelta(fd[element]["extra__created"])
t = humanize.naturaltime(timestring.Date(fd[element]["extra__created"]).date)
fd[element]["extra__created"] = t
if arguments["--ip"]:
kind = arguments["--ip"]
ips = {}
for element in fd:
ips[element] = {
'name': fd[element]['name'],
kind: fd[element][kind + '_ips']
}
if arguments.format == 'inventory':
# print ("[hosts]")
for host in ips:
print(ips[host][kind])
else:
print(Printer.dict(ips,
# sort_keys=True,
order=["name", kind],
output=arguments.format))
else:
print(arguments.CLOUD)
print(Printer.dict(fd,
# sort_keys=True,
order=order,
header=header,
output=arguments.format))
# elif arguments.format == "dict":
# print(yaml.dump(images, indent=4, Dumper=yaml.RoundTripDumper))
elif arguments.format == 'flatten':
pprint(fd)
else:
print(Printer.dict(elements, output=arguments.format))
return ""
def do_vm(self, args, arguments):
"""
::
Usage:
vm ping [NAMES] [--cloud=CLOUDS] [--count=N]
vm check [NAMES] [--cloud=CLOUDS] [--username=USERNAME]
vm status [NAMES] [--cloud=CLOUDS] [--output=OUTPUT]
vm console [NAME] [--force]
vm log [NAME] [--force]
vm stop [NAMES] [--dryrun]
vm start [NAMES] [--dryrun]
vm terminate [NAMES] [--cloud=CLOUD] [--dryrun]
vm delete [NAMES] [--cloud=CLOUD] [--dryrun]
vm refresh [--cloud=CLOUDS]
vm list [NAMES]
[--cloud=CLOUDS]
[--output=OUTPUT]
[--refresh]
vm boot [--n=COUNT]
[--name=VMNAMES]
[--cloud=CLOUD]
[--username=USERNAME]
[--image=IMAGE]
[--flavor=FLAVOR]
[--network=NETWORK]
[--public]
[--secgroup=SECGROUPs]
[--group=GROUPs]
[--key=KEY]
[--dryrun]
[-v]
vm meta list [NAME]
vm meta set [NAME] KEY=VALUE...
vm meta delete [NAME] KEY...
vm script [--name=NAMES]
[--username=USERNAME]
[--key=KEY]
[--dryrun]
[--dir=DESTINATION]
SCRIPT
vm ip assign [NAMES]
[--cloud=CLOUD]
vm ip show [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--output=OUTPUT]
[--refresh]
vm ip inventory [NAMES]
vm ssh [NAMES]
[--username=USER]
[--quiet]
[--ip=IP]
[--key=KEY]
[--command=COMMAND]
vm put SOURCE DESTINATION [NAMES]
vm get SOURCE DESTINATION [NAMES]
vm rename [OLDNAMES] [NEWNAMES] [--force] [--dryrun]
vm wait [--cloud=CLOUD] [--interval=INTERVAL] [--timeout=TIMEOUT]
vm info [--cloud=CLOUD]
[--output=OUTPUT]
vm username USERNAME [NAMES] [--cloud=CLOUD]
vm resize [NAMES] [--size=SIZE]
Arguments:
OUTPUT the output format
COMMAND positional arguments, the commands you want to
execute on the server(e.g. ls -a) separated by ';',
you will get a return of executing result instead of login to
the server, note that type in -- is suggested before
you input the commands
NAME server name. By default it is set to the name of last vm from database.
NAMES server name. By default it is set to the name of last vm from database.
KEYPAIR_NAME Name of the vm keypair to be used to create VM. Note this is
not a path to key.
NEWNAMES New names of the VM while renaming.
OLDNAMES Old names of the VM while renaming.
Options:
-v verbose, prints the dict at the end
--output=OUTPUT the output format
-H --modify-knownhosts Do not modify ~/.ssh/known_hosts file
when ssh'ing into a machine
--username=USERNAME the username to login into the vm. If not
specified it will be guessed
from the image name and the cloud
--ip=IP give the public ip of the server
--cloud=CLOUD give a cloud to work on, if not given, selected
or default cloud will be used
--count=COUNT give the number of servers to start
--detail for table, a brief version
is used as default, use this flag to print
detailed table
--flavor=FLAVOR give the name or id of the flavor
--group=GROUP give the group name of server
--secgroup=SECGROUP security group name for the server
--image=IMAGE give the name or id of the image
--key=KEY specify a key to use, input a string which
is the full path to the private key file
--keypair_name=KEYPAIR_NAME Name of the vm keypair to
be used to create VM.
Note this is not a path to key.
--user=USER give the user name of the server that you want
to use to login
--name=NAME give the name of the virtual machine
--force rename/ delete vms without user's confirmation
--command=COMMAND
specify the commands to be executed
Description:
commands used to boot, start or delete servers of a cloud
vm default [options...]
Displays default parameters that are set for vm boot either
on the default cloud or the specified cloud.
vm boot [options...]
Boots servers on a cloud, user may specify flavor, image
.etc, otherwise default values will be used, see how to set
default values of a cloud: cloud help
vm start [options...]
Starts a suspended or stopped vm instance.
vm stop [options...]
Stops a vm instance .
vm delete [options...]
Delete servers of a cloud, user may delete a server by its
name or id, delete servers of a group or servers of a cloud,
give prefix and/or range to find servers by their names.
Or user may specify more options to narrow the search
vm floating_ip_assign [options...]
assign a public ip to a VM of a cloud
vm ip show [options...]
show the ips of VMs
vm ssh [options...]
login to a server or execute commands on it
vm list [options...]
same as command "list vm", please refer to it
vm status [options...]
Retrieves status of last VM booted on cloud and displays it.
vm refresh [--cloud=CLOUDS]
this command refreshes the data for virtual machines,
images and flavors for the specified clouds.
vm ping [NAMES] [--cloud=CLOUDS] [--count=N] [--processors=PROCESSORS]
pings the specified virtual machines, while using at most N pings.
The ping is executed in parallel.
If names are specifies the ping is restricted to the given names in
parameter format. If clouds are specified, names that are not in
these clouds are ignored. If the name is set in the variables
this name is used.
cms vm ssh --command=\"uname -a\"
executes the uname command on the last booted vm
vm script [--name=NAMES]
[--username=USERNAME]
[--key=KEY]
[--dryrun]
[--dir=DESTINATION]
[--shell=SHELL]
SCRIPT
The script command copies a shell script to the specified vms
into the DESTINATION directory and than execute it. With
SHELL you can set the shell for executing the command,
this coudl even be a python interpreter. Examples for
SHELL are /bin/sh, /usr/bin/env python
vm put SOURCE DESTINATION [NAMES]
puts the file defined by SOURCE into the DESINATION folder
on the specified machines. If the file exists it is
overwritten, so be careful.
vm get SOURCE DESTINATION [NAMES]
gets the file defined by SOURCE into the DESINATION folder
on the specified machines. The SOURCE is on the remote
machine. If one machine is specified, the SOURCE is the same
name as on the remote machine. If multiple machines are
specified, the name of the machine will be a prefix to the
filename. If the filenames exists, they will be overwritten,
so be careful.
Tip:
give the VM name, but in a hostlist style, which is very
convenient when you need a range of VMs e.g. sample[1-3]
=> ['sample1', 'sample2', 'sample3']
sample[1-3,18] => ['sample1', 'sample2', 'sample3', 'sample18']
Quoting commands:
cm vm login gregor-004 --command=\"uname -a\"
Limitations:
Azure: rename is not supported
"""
map_parameters(arguments, 'active', 'cloud', 'command', 'dryrun',
'flavor', 'force', 'group'
'output', 'group', 'image', 'interval', 'timeout', 'ip',
'key', 'modify-knownhosts', 'n', 'name', 'public',
'quiet', 'secgroup', 'size', 'username', 'output',
'count', 'network', 'refresh')
variables = Variables()
database = CmDatabase()
arguments.output = Parameter.find("output", arguments, variables,
"table")
arguments.refresh = Parameter.find_bool("refresh", arguments,
variables)
if (arguments.meta and arguments.list):
name = arguments.NAME
if arguments.NAME is None:
name = variables['vm']
if name is None:
Console.error("No vm specified")
cloud = "chameleon"
# cloud = Parameter.find(arguments, variables)
print(f"vm metadata for {name} on {cloud}")
provider = Provider(name=cloud)
r = provider.get_server_metadata(name)
print(r)
elif arguments.meta and arguments.set:
metadata = {}
pairs = arguments['KEY=VALUE']
for pair in pairs:
key, value = pair.split("=", 1)
metadata[key] = value
name = arguments.NAME
if arguments.NAME is None:
name = variables['vm']
if name is None:
Console.error("No vm specified")
cloud = "chameleon"
# cloud = Parameter.find(arguments, variables)
print(f"cloud {cloud} {name}")
provider = Provider(name=cloud)
provider.set_server_metadata(name, **metadata)
r = provider.get_server_metadata(name)
pprint(r)
elif arguments.meta and arguments.delete:
metadata = {}
keys = arguments['KEY']
name = arguments.NAME
if arguments.NAME is None:
name = variables['vm']
if name is None:
Console.error("No vm specified")
cloud = "chameleon"
# cloud = Parameter.find(arguments, variables)
print(f"cloud {cloud} {name}")
provider = Provider(name=cloud)
for key in keys:
provider.delete_server_metadata(name, key)
r = provider.get_server_metadata(name)
pprint(r)
elif arguments.list and arguments.refresh:
names = []
clouds, names = Arguments.get_cloud_and_names(
"list", arguments, variables)
for cloud in clouds:
print(f"cloud {cloud}")
provider = Provider(name=cloud)
vms = provider.list()
provider.Print(vms, output=arguments.output, kind="vm")
return ""
elif arguments.list:
names = []
clouds, names = Arguments.get_cloud_and_names(
"list", arguments, variables)
try:
for cloud in clouds:
print(f"List {cloud}")
p = Provider(cloud)
kind = p.kind
collection = "{cloud}-vm".format(cloud=cloud, kind=p.kind)
db = CmDatabase()
vms = db.find(collection=collection)
p.Print(vms, output=arguments.output, kind="vm")
except Exception as e:
Console.error("Error in listing ", traceflag=True)
VERBOSE(e)
return ""
elif arguments.ping:
"""
vm ping [NAMES] [--cloud=CLOUDS] [--count=N]
"""
if arguments.NAMES:
variables['vm'] = arguments.NAMES
if arguments['--cloud']:
variables['cloud'] = arguments['--cloud']
clouds, names = Arguments.get_cloud_and_names(
"status", arguments, variables)
count = arguments.count
if arguments.count:
count = int(count)
else:
count = 1
def get_ips():
ips = []
for cloud in clouds:
params = {}
# gets public ips from database
cursor = database.db[f'{cloud}-vm']
for name in names:
for node in cursor.find({'name': name}):
ips.append(node['ip_public'])
ips = list(set(ips))
pprint(ips)
return ips
ips = get_ips()
if len(ips) == 0:
Console.warning("no public ip found.")
for cloud in clouds:
print(f"refresh for cloud {cloud}")
provider = Provider(name=cloud)
vms = provider.list()
ips = get_ips()
if len(ips) == 0:
Console.error("No vms with public IPS found.")
Console.error(" Make sure to use cms vm list --refresh")
for ip in ips:
result = Shell.ping(host=ip, count=count)
banner(ip)
print(result)
print()
elif arguments.check:
raise NotImplementedError
"""
vm check [NAMES] [--cloud=CLOUDS] [--username=USERNAME]
"""
"""
THIS IS ALL WRONG AS PROVIDER DEPENDENT !!!
if arguments.NAMES:
variables['vm'] = arguments.NAMES
if arguments['--cloud']:
variables['cloud'] = arguments['--cloud']
clouds, names = Arguments.get_cloud_and_names("status", arguments, variables)
for cloud in clouds:
provider = Provider(cloud)
params = {}
params['key'] = \
provider.p.spec["credentials"]['EC2_PRIVATE_KEY_FILE_PATH'] + \
provider.p.spec["credentials"]['EC2_PRIVATE_KEY_FILE_NAME']
params['username'] = arguments['--username'] # or get from db
processors = arguments['--processors']
if processors:
params['processors'] = int(processors[0])
# gets public ips from database
public_ips = []
cursor = database.db['{cloud}-vm']
for name in names:
for node in cursor.find({'name': name}):
public_ips.append(node['public_ips'])
public_ips = [y for x in public_ips for y in x]
Host.check(hosts=public_ips, **params)
"""
elif arguments.status:
if arguments.NAMES:
variables['vm'] = arguments.NAMES
if arguments['--cloud']:
variables['cloud'] = arguments['--cloud']
clouds, names = Arguments.get_cloud_and_names(
"status", arguments, variables)
# gets status from database
for cloud in clouds:
provider = Provider(cloud)
status = []
cursor = database.db[f'{cloud}-vm']
print(cloud)
for name in names:
for node in cursor.find({'name': name}):
status.append(node)
provider.Print(status, output=arguments.output, kind="status")
return ""
elif arguments.start:
# TODO: not tested
if arguments.NAMES:
names = variables['vm'] = arguments.NAMES
if arguments['--cloud']:
variables['cloud'] = arguments['--cloud']
clouds, names = Arguments.get_cloud_and_names(
"stop", arguments, variables)
cloud = clouds[0]
print(cloud)
print(names)
for name in names:
provider = Provider(cloud)
if arguments['--dryrun']:
print(f"start node {name}")
else:
vms = provider.start(name=name, cloud=cloud)
provider.Print(vms, output=arguments.output, kind="vm")
return ""
elif arguments.stop:
# TODO: not tested
if arguments.NAMES:
variables['vm'] = arguments.NAMES
if arguments['--cloud']:
variables['cloud'] = arguments['--cloud']
clouds, names = Arguments.get_cloud_and_names(
"stop", arguments, variables)
for cloud in clouds:
params = {}
provider = Provider(cloud)
if arguments['--dryrun']:
Console.ok(f"Dryrun stop: "
f" {cloud}\n"
f" {names}"
f" {provider}")
else:
for name in names:
vms = provider.stop(name)
provider.Print(vms, output=arguments.output, kind="vm")
elif arguments.terminate:
# TODO: not tested
if arguments.NAMES:
variables['vm'] = arguments.NAMES
if arguments['--cloud']:
variables['cloud'] = arguments['--cloud']
clouds, names = Arguments.get_cloud_and_names(
"stop", arguments, variables)
for cloud in clouds:
params = {}
provider = Provider(cloud)
if arguments['--dryrun']:
Console.ok(f"Dryrun terminate: "
f" {cloud}\n"
f" {names}"
f" {provider}")
else:
for name in names:
vms = provider.destroy(name)
provider.Print(vms, output=arguments.output, kind="vm")
elif arguments.delete:
if arguments.NAMES:
variables['vm'] = arguments.NAMES
if arguments['--cloud']:
variables['cloud'] = arguments['--cloud']
clouds, names = Arguments.get_cloud_and_names(
"stop", arguments, variables)
if names is not None:
pass
elif clouds is not None:
for cloud in clouds:
provider = Provider(cloud)
vms = provider.list()
for vm in vms:
r = provider.destroy(name=vm)
return ""
else:
return ""
for cloud in clouds:
provider = Provider(cloud)
vms = provider.list()
for vm in vms:
name = vm["cm"]["name"]
if name in names:
r = provider.destroy(name=name)
# TODO: username, secgroup
elif arguments.boot:
# not everything works
"""
vm boot
[--name=VMNAMES]
[--cloud=CLOUD]
[--username=USERNAME]
[--image=IMAGE]
[--flavor=FLAVOR]
[--network=NETWORK]
[--public]
[--secgroup=SECGROUP]
[--key=KEY]
[--group=GROUP]
[--dryrun]
"""
# for name in names:
# node = p.create(name=name, size=flavor, image=image)
# VERBOSE(arguments)
parameters = dotdict()
names = Parameter.expand(arguments.name)
cloud = Parameter.find("cloud", arguments, variables.dict())
defaults = Config()[f"cloudmesh.cloud.{cloud}.default"]
groups = Parameter.find("group", arguments, variables.dict(),
{"group": "default"})
parameters = dotdict()
# parameters.names = arguments.name
parameters.group = groups
for attribute in [
"image", "username", "flavor", "key", "network", "secgroup"
]:
parameters[attribute] = Parameter.find(attribute, arguments,
variables.dict(),
defaults)
if arguments.username is None:
parameters.user = Image.guess_username(parameters.image)
provider = Provider(name=cloud)
parameters.secgroup = arguments.secgroup or "default"
#
# determine names
#
if names and arguments.n and len(names) > 1:
Console.error(
f"When using --n={arguments.n}, you can only specify one name"
)
return ""
# cases
#
# only name --name = "a[1,2]"
# name and count # --name="a" --n=3, names must be of length 1
# only count --n=2 names are read form var
# nothing, just use one vm
# determin names
_names = []
if not names:
if not arguments.n:
count = 1
else:
count = int(arguments.n)
for i in range(0, count):
if names is None:
n = Name()
n.incr()
name = str(n)
else:
n = names[i]
name = str(n)
_names.append(name)
names = _names
elif len(names) == 1 and arguments.n:
name = names[0]
for i in range(0, int(arguments.n)):
_names.append(f"{name}-{i}")
names = _names
# pprint(parameters)
for name in names:
parameters.name = name
if arguments['--dryrun']:
banner("boot")
pprint(parameters)
Console.ok(f"Dryrun boot {name}: \n"
f" cloud={cloud}\n"
f" names={names}\n"
f" provider={provider}")
print()
for attribute in parameters:
value = parameters[attribute]
Console.ok(f" {attribute}={value}")
else:
# parameters.progress = len(parameters.names) < 2
try:
vms = provider.create(**parameters)
except TimeoutError:
Console.error(
f"Timeout during vm creation. There may be a problem with the cloud {cloud}"
)
except Exception as e:
Console.error("create problem", traceflag=True)
print(e)
return ""
variables['vm'] = str(n)
if arguments["-v"]:
banner("Details")
pprint(vms)
# provider.Print(arguments.output, "vm", vms)
elif arguments.info:
"""
vm info [--cloud=CLOUD] [--output=OUTPUT]
"""
print("info for the vm")
cloud, names = Arguments.get_cloud_and_names(
"info", arguments, variables)
raise NotImplementedError
elif arguments.rename:
raise NotImplementedError
# Not tested
print("rename the vm")
v = Variables()
cloud = v["cloud"]
p = Provider(cloud)
try:
oldnames = Parameter.expand(arguments["OLDNAMES"])
newnames = Parameter.expand(arguments["NEWNAMES"])
force = arguments["--force"]
if oldnames is None or newnames is None:
Console.error("Wrong VMs specified for rename",
traceflag=False)
elif len(oldnames) != len(newnames):
Console.error("The number of VMs to be renamed is wrong",
traceflag=False)
else:
print(oldnames)
print(newnames)
for i in range(0, len(oldnames)):
oldname = oldnames[i]
newname = newnames[i]
if arguments["--dryrun"]:
Console.ok("Rename {} to {}".format(
oldname, newname))
else:
print(f"rename {oldname} -> {newname}")
p.rename(source=oldname, destination=newname)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
Error.traceback(e)
Console.error("Problem renaming instances", traceflag=True)
elif arguments["ip"] and arguments["show"]:
raise NotImplementedError
print("show the ips")
"""
vm ip show [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--output=OUTPUT]
[--refresh]
"""
elif arguments["ip"] and arguments["assign"]:
raise NotImplementedError
"""
vm ip assign [NAMES] [--cloud=CLOUD]
"""
print("assign the public ip")
elif arguments["ip"] and arguments["inventory"]:
raise NotImplementedError
"""
vm ip inventory [NAMES]
"""
print("list ips that could be assigned")
elif arguments.default:
raise NotImplementedError
print("sets defaults for the vm")
elif arguments.script:
raise NotImplementedError
clouds, names = Arguments.get_cloud_and_names(
"run", arguments, variables)
username = arguments['--username']
script = arguments.SCRIPT
for cloud in clouds:
provider = Provider(cloud)
name_ips = {}
cursor = database.db['{}-node'.format(cloud)]
for name in names:
for node in cursor.find({'name': name}):
name_ips[name] = node['public_ips']
if arguments['--dryrun']:
print("run script {} on vms: {}".format(script, names))
else:
provider.ssh(name_ips, username=username, script=script)
elif arguments.username:
raise NotImplementedError
"""
vm username USERNAME [NAMES] [--cloud=CLOUD]
"""
print("sets the username for the vm")
elif arguments.resize:
raise NotImplementedError
"""
vm resize [NAMES] [--size=SIZE]
"""
pass
elif arguments.ssh:
"""
vm ssh [NAMES] [--username=USER]
[--quiet]
[--ip=IP]
[--key=KEY]
[--command=COMMAND]
"""
# VERBOSE(arguments)
clouds, names, command = Arguments.get_commands(
"ssh", arguments, variables)
# print (clouds)
# print(names)
# print (command)
if arguments.command is None and len(names) > 1:
Console.error("Interactive shell can only be done on one vm")
return ""
elif arguments.command is None and len(names) == 1:
name = names[0]
cloud = clouds[0]
cm = CmDatabase()
try:
vm = cm.find_name(name, "vm")[0]
except IndexError:
Console.error(f"could not find vm {name}")
return ""
# VERBOSE(vm)
cloud = vm["cm"]["cloud"]
provider = Provider(name=cloud)
try:
provider.ssh(vm=vm)
except KeyError:
vms = provider.list()
provider.Print(vms, output=arguments.output, kind="vm")
provider.ssh(vm=vm)
return ""
else:
# command on all vms
if clouds is None or names is None or command is None:
return ""
else:
for cloud in clouds:
p = Provider(cloud)
for name in names:
cm = CmDatabase()
try:
vm = cm.find_name(name, "vm")[0]
except IndexError:
Console.error(f"could not find vm {name}")
continue
r = p.ssh(vm=vm, command=command)
print(r)
return ""
elif arguments.console:
# why is this not vm
clouds, names, command = Arguments.get_commands(
"ssh", arguments, variables)
print(clouds)
print(names)
print(command)
for cloud in clouds:
p = Provider(cloud)
for name in names:
cm = CmDatabase()
try:
vm = cm.find_name(name, "vm")[0]
except IndexError:
Console.error(f"could not find vm {name}")
continue
r = p.console(vm=vm)
print(r)
return ""
elif arguments.log:
# why is this not vm
clouds, names, command = Arguments.get_commands(
"ssh", arguments, variables)
print(clouds)
print(names)
print(command)
for cloud in clouds:
p = Provider(cloud)
for name in names:
cm = CmDatabase()
try:
vm = cm.find_name(name, "vm")[0]
except IndexError:
Console.error(f"could not find vm {name}")
continue
r = p.log(vm=vm)
print(r)
return ""
elif arguments.wait:
"""
vm wait [--cloud=CLOUD] [--interval=INTERVAL] [--timeout=TIMEOUT]
"""
# why is this not vm
clouds, names, command = Arguments.get_commands(
"ssh", arguments, variables)
# print (clouds)
# print (names)
# print (command)
for cloud in clouds:
p = Provider(cloud)
for name in names:
cm = CmDatabase()
try:
vm = cm.find_name(name, "vm")[0]
except IndexError:
Console.error(f"could not find vm {name}")
continue
r = p.wait(vm=vm,
interval=arguments.interval,
timeout=arguments.timeout)
if r:
Console.ok("Instance available for SSH")
else:
Console.error(
f"Instance unavailable after timeout of {arguments.timeout}"
)
# print(r)
return ""
elif arguments.put:
"""
vm put SOURCE DESTINATION
"""
clouds, names, command = Arguments.get_commands(
"ssh", arguments, variables)
key = variables['key']
source = arguments['SOURCE']
destination = arguments['DESTINATION']
for cloud in clouds:
p = Provider(name=cloud)
cm = CmDatabase()
for name in names:
try:
vms = cm.find_name(name, "vm")
except IndexError:
Console.error(f"could not find vm {name}")
return ""
# VERBOSE(vm)
for vm in vms:
try:
ip = vm['public_ips']
except:
try:
ip = p.get_public_ip(name=name)
except:
Console.error(
f"could not find a public ip for vm {name}",
traceflag=True)
return
Console.error(
f"could not find a public ip for vm {name}",
traceflag=True)
return
# get the username
try:
# username not in vm...guessing
imagename = list(
cm.collection(cloud + '-image').find(
{'ImageId': vm['ImageId']}))[0]['name']
print(imagename)
user = Image.guess_username(image=imagename,
cloud=cloud)
except:
try:
user = vm['os_profile']['admin_username']
except:
Console.error(
f"could not find a valid username for "
f"{name}, try refreshing the image list",
traceflag=True)
return
Console.error(
f"could not find a valid username for {name}, try refreshing the image list"
)
return
cmd = f'scp -i {key} {source} {user}@{ip}:{destination}'
print(cmd)
os.system(cmd)
return ""
def do_vm(self, args, arguments):
"""
::
Usage:
vm ping [NAMES] [--cloud=CLOUDS] [--count=N] [--processors=PROCESSORS]
vm check [NAMES] [--cloud=CLOUDS] [--processors=PROCESSORS]
vm status [NAMES] [--cloud=CLOUDS]
vm console [NAME] [--force]
vm start [NAMES] [--cloud=CLOUD] [--dryrun]
vm stop [NAMES] [--cloud=CLOUD] [--dryrun]
vm terminate [NAMES] [--cloud=CLOUD] [--dryrun]
vm delete [NAMES] [--cloud=CLOUD] [--dryrun]
vm refresh [--cloud=CLOUDS]
vm list [NAMES]
[--cloud=CLOUDS]
[--output=OUTPUT]
[--refresh]
vm boot [--name=VMNAMES]
[--cloud=CLOUD]
[--username=USERNAME]
[--image=IMAGE]
[--flavor=FLAVOR]
[--public]
[--secgroup=SECGROUPs]
[--key=KEY]
[--dryrun]
vm boot [--n=COUNT]
[--cloud=CLOUD]
[--username=USERNAME]
[--image=IMAGE]
[--flavor=FLAVOR]
[--public]
[--secgroup=SECGROUPS]
[--key=KEY]
[--dryrun]
vm run [--name=VMNAMES] [--username=USERNAME] [--dryrun] COMMAND
vm script [--name=NAMES] [--username=USERNAME] [--dryrun] SCRIPT
vm ip assign [NAMES]
[--cloud=CLOUD]
vm ip show [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--output=OUTPUT]
[--refresh]
vm ip inventory [NAMES]
vm ssh [NAMES] [--username=USER]
[--quiet]
[--ip=IP]
[--key=KEY]
[--command=COMMAND]
[--modify-knownhosts]
vm rename [OLDNAMES] [NEWNAMES] [--force] [--dryrun]
vm wait [--cloud=CLOUD] [--interval=SECONDS]
vm info [--cloud=CLOUD]
[--output=OUTPUT]
vm username USERNAME [NAMES] [--cloud=CLOUD]
vm resize [NAMES] [--size=SIZE]
Arguments:
OUTPUT the output format
COMMAND positional arguments, the commands you want to
execute on the server(e.g. ls -a) separated by ';',
you will get a return of executing result instead of login to
the server, note that type in -- is suggested before
you input the commands
NAME server name. By default it is set to the name of last vm from database.
NAMES server name. By default it is set to the name of last vm from database.
KEYPAIR_NAME Name of the vm keypair to be used to create VM. Note this is
not a path to key.
NEWNAMES New names of the VM while renaming.
OLDNAMES Old names of the VM while renaming.
Options:
--output=OUTPUT the output format [default: table]
-H --modify-knownhosts Do not modify ~/.ssh/known_hosts file
when ssh'ing into a machine
--username=USERNAME the username to login into the vm. If not
specified it will be guessed
from the image name and the cloud
--ip=IP give the public ip of the server
--cloud=CLOUD give a cloud to work on, if not given, selected
or default cloud will be used
--count=COUNT give the number of servers to start
--detail for table, a brief version
is used as default, use this flag to print
detailed table
--flavor=FLAVOR give the name or id of the flavor
--group=GROUP give the group name of server
--secgroup=SECGROUP security group name for the server
--image=IMAGE give the name or id of the image
--key=KEY specify a key to use, input a string which
is the full path to the private key file
--keypair_name=KEYPAIR_NAME Name of the vm keypair to
be used to create VM.
Note this is not a path to key.
--user=USER give the user name of the server that you want
to use to login
--name=NAME give the name of the virtual machine
--force rename/ delete vms without user's confirmation
--command=COMMAND
specify the commands to be executed
Description:
commands used to boot, start or delete servers of a cloud
vm default [options...]
Displays default parameters that are set for vm boot either
on the default cloud or the specified cloud.
vm boot [options...]
Boots servers on a cloud, user may specify flavor, image
.etc, otherwise default values will be used, see how to set
default values of a cloud: cloud help
vm start [options...]
Starts a suspended or stopped vm instance.
vm stop [options...]
Stops a vm instance .
vm delete [options...]
Delete servers of a cloud, user may delete a server by its
name or id, delete servers of a group or servers of a cloud,
give prefix and/or range to find servers by their names.
Or user may specify more options to narrow the search
vm floating_ip_assign [options...]
assign a public ip to a VM of a cloud
vm ip show [options...]
show the ips of VMs
vm ssh [options...]
login to a server or execute commands on it
vm list [options...]
same as command "list vm", please refer to it
vm status [options...]
Retrieves status of last VM booted on cloud and displays it.
vm refresh [--cloud=CLOUDS]
this command refreshes the data for virtual machines,
images and flavors for the specified clouds.
vm ping [NAMES] [--cloud=CLOUDS] [--count=N] [--processors=PROCESSORS]
pings the specified virtual machines, while using at most N pings.
The ping is executed in parallel.
If names are specifies the ping is restricted to the given names in
parameter format. If clouds are specified, names that are not in
these clouds are ignored. If the name is set in the variables
this name is used.
Tip:
give the VM name, but in a hostlist style, which is very
convenient when you need a range of VMs e.g. sample[1-3]
=> ['sample1', 'sample2', 'sample3']
sample[1-3,18] => ['sample1', 'sample2', 'sample3', 'sample18']
Quoting commands:
cm vm login gvonlasz-004 --command=\"uname -a\"
Limitations:
Azure: rename is not supported
"""
map_parameters(arguments, 'active', 'cloud', 'command', 'dryrun',
'flavor', 'force', 'output', 'group', 'image',
'interval', 'ip', 'key', 'modify-knownhosts', 'n',
'name', 'public', 'quiet', 'secgroup', 'size',
'username')
VERBOSE(arguments)
variables = Variables()
if arguments.refresh:
names = []
clouds, names = Arguments.get_cloud_and_names(
"refresh", arguments, variables)
return ""
elif arguments.ping:
# TODO: IMPLEMENT
names = []
pings = int(arguments.N or 3)
names = []
clouds, names = Arguments.get_cloud_and_names(
"ping", arguments, variables)
for name in names:
ping = Shell.live("ping -c {N} {name}".format(name=name,
N=arguments.N))
print(ping)
else:
return True
return ""
elif arguments.check:
names = []
clouds, names = Arguments.get_cloud_and_names(
"check", arguments, variables)
return ""
elif arguments.status:
names = []
clouds, names = Arguments.get_cloud_and_names(
"status", arguments, variables)
return ""
elif arguments.start:
names = []
clouds, names = Arguments.get_cloud_and_names(
"start", arguments, variables)
return ""
elif arguments.stop:
names = []
clouds, names = Arguments.get_cloud_and_names(
"stop", arguments, variables)
return ""
elif arguments.terminate:
names = []
clouds, names = Arguments.get_cloud_and_names(
"terminate", arguments, variables)
return ""
elif arguments.delete:
clouds, names = Arguments.get_cloud_and_names(
"delete", arguments, variables)
return ""
elif arguments.boot:
print("boot the vm")
elif arguments.list:
# vm list [NAMES]
# [--cloud=CLOUDS]
# [--output=OUPTUT]
# [--refresh]
# if no clouds find the clouds of all specified vms by name
# find all vms of the clouds,
# print only those vms specified by name, if no name is given print all for the cloud
# print("list the vms")
clouds, names = Arguments.get_cloud_and_names(
"list", arguments, variables)
# print("Clouds:", clouds)
if arguments.NAMES is not None:
names = Parameter.expand(arguments.NAMES)
Console.error("NAMES, not yet implemented" + str(names))
try:
if arguments["--refresh"]:
pass
# find all clouds in db
# iterate over the clouds
# for each name in name queue, find it and add it to the cloud vm list
# for each cloud print the vms
else:
pass
# find all clouds in db
# iterate over all clouds
# find the vm with the name
# add it to the cloud list
# for each cloud print the vms
except Exception as e:
VERBOSE(e)
return ""
else:
try:
if arguments["--refresh"]:
for cloud in clouds:
Console.ok("refresh " + cloud)
p = Provider(cloud)
vms = p.list()
order = p.p.output['vm']['order'] # not pretty
header = p.p.output['vm']['header'] # not pretty
print(
Printer.flatwrite(vms,
sort_keys=["cm.name"],
order=order,
header=header,
output=arguments.output))
else:
for cloud in clouds:
p = Provider(cloud)
kind = p.kind
# pprint(p.__dict__)
# pprint(p.p.__dict__) # not pretty
collection = "{cloud}-node".format(cloud=cloud,
kind=p.kind)
db = CmDatabase()
vms = db.find(collection=collection)
# pprint(vms)
# print(arguments.output)
# print(p.p.output['vm'])
order = p.p.output['vm']['order'] # not pretty
header = p.p.output['vm']['header'] # not pretty
print(
Printer.flatwrite(vms,
sort_keys=["cm.name"],
order=order,
header=header,
output=arguments.output))
except Exception as e:
VERBOSE(e)
return ""
elif arguments.info:
"""
vm info [--cloud=CLOUD] [--output=OUTPUT]
"""
print("info for the vm")
cloud, names = Arguments.get_cloud_and_names(
"info", arguments, variables)
elif arguments.rename:
print("rename the vm")
v = Variables()
cloud = v["cloud"]
p = Provider(cloud)
try:
oldnames = Parameter.expand(arguments["OLDNAMES"])
newnames = Parameter.expand(arguments["NEWNAMES"])
force = arguments["--force"]
if oldnames is None or newnames is None:
Console.error("Wrong VMs specified for rename",
traceflag=False)
elif len(oldnames) != len(newnames):
Console.error("The number of VMs to be renamed is wrong",
traceflag=False)
else:
print(oldnames)
print(newnames)
for i in range(0, len(oldnames)):
oldname = oldnames[i]
newname = newnames[i]
if arguments["--dryrun"]:
Console.ok("Rename {} to {}".format(
oldname, newname))
else:
print(f"rename {oldname} -> {newname}")
p.rename(source=oldname, destination=newname)
msg = "info. OK."
Console.ok(msg)
except Exception as e:
Error.traceback(e)
Console.error("Problem renameing instances", traceflag=True)
elif arguments["ip"] and arguments["show"]:
print("show the ips")
"""
vm ip show [NAMES]
[--group=GROUP]
[--cloud=CLOUD]
[--output=OUTPUT]
[--refresh]
"""
elif arguments["ip"] and arguments["assign"]:
"""
vm ip assign [NAMES] [--cloud=CLOUD]
"""
print("assign the public ip")
elif arguments["ip"] and arguments["inventory"]:
"""
vm ip inventory [NAMES]
"""
print("list ips that could be assigned")
elif arguments.username:
"""
vm username USERNAME [NAMES] [--cloud=CLOUD]
"""
print("sets the username for the vm")
elif arguments.default:
print("sets defaults for the vm")
elif arguments.run:
"""
vm run [--name=NAMES] [--username=USERNAME] [--dryrun] COMMAND
"""
pass
elif arguments.script:
"""
vm script [--name=NAMES] [--username=USERNAME] [--dryrun] SCRIPT
"""
pass
elif arguments.resize:
"""
vm resize [NAMES] [--size=SIZE]
"""
pass
elif arguments.ssh:
"""
vm ssh [NAMES] [--username=USER]
[--quiet]
[--ip=IP]
[--key=KEY]
[--command=COMMAND]
[--modify-knownhosts]
"""
print("ssh the vm")
elif arguments.console:
# vm console [NAME] [--force]
names = Arguments.get_names(arguments, variables)
for name in names:
# r = vm.console(name,force=argument.force)
Console.msg("{label} {name}".format(label="console",
name=name))
return
elif arguments.wait:
"""
vm wait [--cloud=CLOUD] [--interval=SECONDS]
"""
print("waits for the vm till its ready and one can login")
def main():
"""cms.
Usage:
cms --help
cms [--echo] [--debug] [--nosplash] [-i] [COMMAND ...]
Arguments:
COMMAND A command to be executed
Options:
--file=SCRIPT -f SCRIPT Executes the script
-i After start keep the shell interactive,
otherwise quit [default: False]
--nosplash do not show the banner [default: False]
"""
def manual():
print(main.__doc__)
args = sys.argv[1:]
arguments = {
'--echo': '--echo' in args,
'--help': '--help' in args,
'--debug': '--debug' in args,
'--nosplash': '--nosplash' in args,
'-i': '-i' in args
}
echo = arguments["--echo"]
if arguments['--help']:
manual()
sys.exit()
for a in args:
if a in arguments:
args.remove(a)
arguments['COMMAND'] = [' '.join(args)]
commands = arguments["COMMAND"]
# commands = list(arguments["COMMAND"])
if len(commands) > 0:
if ".cm" in commands[0]:
arguments["SCRIPT"] = commands[0]
commands = commands[1:]
else:
arguments["SCRIPT"] = None
arguments["COMMAND"] = ' '.join(commands)
if arguments["COMMAND"] == '':
arguments["COMMAND"] = None
# noinspection PySimplifyBooleanCheck
if arguments['COMMAND'] == []:
arguments['COMMAND'] = None
splash = not arguments['--nosplash']
debug = arguments['--debug']
interactive = arguments['-i']
script = arguments["SCRIPT"]
command = arguments["COMMAND"]
# context = CloudmeshContext(
# interactive=interactive,
# debug=debug,
# echo=echo,
# splash=splash)
cmd = CMShell()
# if script is not None:
# cmd.do_exec(script)
try:
if echo:
print(cmd.prompt, command)
if command is not None:
cmd.precmd(command)
stop = cmd.onecmd(command)
cmd.postcmd(stop, command)
except Exception as e:
print("ERROR: executing command '{0}'".format(command))
print(70 * "=")
print(e)
d = Default()
trace = d["global", "trace"] == "True"
trace = True
Error.traceback(error=e, debug=True, trace=trace)
d.close()
print(70 * "=")
if interactive or (command is None and script is None):
cmd.cmdloop()
def onecmd(self, line):
"""Interpret the argument as though it had been typed in response
to the prompt.
This may be overridden, but should not normally need to be;
see the precmd() and postcmd() methods for useful execution hooks.
The return value is a flag indicating whether interpretation of
commands by the interpreter should stop.
"""
oldline, line = self.replace_vars(line)
# -----------------------------
# print comment lines, but do not execute them
# -----------------------------
if line.startswith('#') \
or line.startswith('//') \
or line.startswith('/*'):
print(line)
return ""
if line.startswith('!'):
os.system(line[1:])
return ""
# if line is None:
# return ""
# if line.startswith("!"):
# line.replace("!", "! ")
# line = self.var_replacer(line)
# if line != "hist" and line:
# self._hist += [line.strip()]
# if line.startswith("!") or line.startswith("shell"):
# self.do_shell_exec(line[1:])
# return ""
cmd, arg, line = self.parseline(line)
if line.startswith("$") or line.startswith('var.'):
line = line.replace("$", "", 1)
line = line.replace("var.", "", 1)
print("FIND>", line, "<", sep='')
variable = Variables()
print(variable[line])
variable.close()
return ""
# -----------------------------
# handle empty line
# -----------------------------
if not line:
return self.emptyline()
# -----------------------------
# handle file execution
# -----------------------------
#
# this does not yet work
#
# if os.path.isfile(line):
# print ("... execute", line)
# self.do_exec(line)
# return ""
if cmd != '':
try:
func = getattr(self, 'do_' + cmd)
return func(arg)
except AttributeError as e:
variables = Variables()
trace = "T" in variables['trace']
debug = "T" in variables['debug']
command_missing = "'CMShell' object has no attribute 'do_{cmd}'".format(
cmd=cmd)
if e.args[0] == command_missing:
Console.error(
"this command does not exist: '{cmd}'".format(cmd=cmd),
traceflag=False)
else:
Error.traceback(error=e, debug=debug, trace=trace)
# noinspection PyUnusedLocal
cmd = None
line = oldline
return ""
def do_schema(self, args, arguments):
"""
::
Usage:
schema cat DIRECTORY FILENAME
schema convert INFILE [OUTFILE]
Arguments:
FILENAME a filename
DIRECTORY the derectory where the schma
objects are defined
Options:
-h help
Description:
schema eve [json|yml] DIRECTORY FILENAME
concatenates all files with ending yml
or json in the directory and combines
them. Using evegenie on the combined
file a eve settings file is generated
and written into FILENAME
schema cat [json|yml] DIRECTORY FILENAME
Concatinates all files with the given
ending (either json, or yml) into the
file called FILENAME
"""
# pprint(arguments)
try:
if arguments.cat:
directory = arguments.DIRECTORY
filename = arguments.FILENAME
elements = Elements(directory, filename)
elif arguments.convert:
try:
filename = arguments.INFILE
outfile = arguments.OUTFILE or "settings.py"
if arguments.OUTFILE is None:
if ".py" in outfile:
pass
elif ".json" in filename:
outfile = filename.replace(".json", ".yml")
elif ".yml" in filename:
outfile = filename.replace(".yml", ".json")
ConvertSpec(filename, outfile)
except Exception as e:
print(e)
Error.traceback(error=e, debug=True, trace=True)
except Exception as e:
print(e)
Error.traceback(error=e, debug=True, trace=True)
def do_robot(self, args, arguments):
"""
::
Usage:
robot welcome
robot osx install
robot osx driver
robot image fetch
robot probe [--format=FORMAT]
robot flash erase [--dryrun]
robot flash python [--dryrun]
robot test
robot run PROGRAM
robot credentials set SSID USERNAME PASSWORD
robot put (credentials | cred)
robot list (credentials | cred)
robot login
robot set PORT NOT IMPLEMENTED
robot ls [PATH]
robot put [-o] SOURCE [DESTINATION]
robot get PATH
robot rm PATH
robot rmdir PATH
robot dance FILE IPS
robot inventory list [--cat] [--path=PATH] [ID]
robot inventory export FILENAME
robot reset
Arguments:
FILE a file name
Options:
-f specify the file
"""
# pprint(arguments)
# "wget http://micropython.org/resources/firmware/esp8266-20170108-v1.8.7.bin"
arguments.dryrun = arguments["--dryrun"]
def _run(command):
print(command)
if arguments.dryrun:
print(command)
else:
os.system(command)
def _continue(msg):
if not arguments.dryrun:
c = yn_choice(msg, default='y')
if arguments.welcome:
print(self.Banner.show())
elif arguments.login:
p = Probe()
Console.error(
"If you do not see a >>> please press the reset button.")
print(p)
data = {'tty': p.tty, 'baudrate': "115200"}
# if 'tty.SLAB_USBtoUART' in p.tty:
# data["baudrate"] = "9600"
# else:
# data["baudrate"] = "115200"
os.system(
"picocom --imap lfcrlf -b {baudrate} {tty}".format(**data))
elif arguments.flash and arguments.erase:
p = Probe()
print(p.tty)
print("Please press the right buttons")
_continue("continue?")
command = "esptool.py --port {} erase_flash".format(p.tty)
_run(command)
elif arguments.flash and arguments.python:
p = Probe()
print(p.tty)
print("Please press the right buttons")
_continue("continue?")
d = {
"baud": str(9600 * 6),
"dir": ".",
"image": "esp8266-20170108-v1.8.7.bin",
"port": p.tty
}
if 'tty.SLAB_USBtoUART' in p.tty:
d["baud"] = str(460800)
command = "esptool.py --port {port} --baud {baud} write_flash --flash_size=detect -fm dio 0x00000 {image}".format(
**d)
_run(command)
# "esptool.py --port /dev/tty.wchusbserial1410 --baud 9600 write_flash --flash_size=detect -fm dio 0x00000 esp8266-20170108-v1.8.7.bin"
elif arguments.osx and arguments.install:
o = sys.platform
print(o)
if sys.platform == 'darwin':
if Shell.command_exists("brew"):
pass
else:
os.system(
'/usr/bin/ruby -e "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/master/install)"'
)
os.system("pip install pyserial")
#
# INSTALLING COMMANDS WITH BREW
#
for package in ["lua", "picocom", "wget"]:
try:
print("installing command", package)
r = Shell.which(package)
if r is None:
r = Brew.install(package)
else:
print(" [OK]", package, "already installed")
except Exception as e:
print("Error", e, type(e))
#
# INSTALLING LIBRARIES WITH BREW
#
# libusb-compat
for package in ["libusb", "mosquitto"]:
try:
print("installing", package)
r = Brew.install(package)
if r is None:
r = Brew.install(package)
else:
Console.error(
package +
" package already installed. skipping.")
except Exception as e:
print("Error", e, type(e))
#
# INSTALLING CASK LIBRARIES AND COMMANDS WITH BREW
#
# libusb-compat
for package in ["adafruit-arduino",
"pycharm-ce"]: # "aquamacs"
try:
print("installing", package)
os.system("brew cask install {}".format(package))
except Exception as e:
print("Error", e, type(e))
if sys.platform == 'linux':
Console.error(
"Linux not yet supported. Install lua and picocom.")
return ""
elif arguments.osx and arguments.driver:
os.system(
"brew tap mengbo/ch340g-ch34g-ch34x-mac-os-x-driver https://github.com/mengbo/ch340g-ch34g-ch34x-mac-os-x-driver"
)
os.system("brew cask install wch-ch34x-usb-serial-driver")
elif arguments.probe:
output_format = arguments["--format"] or "table"
try:
p = Probe()
d = p.probe()
print(Printer.attribute(d, output=output_format))
except Exception as e:
Error.traceback(error=e, debug=True, trace=True)
return ""
elif arguments.image and arguments.fetch:
try:
if os.path.isfile("esp8266-20170108-v1.8.7.bin"):
print("... image already downloaded")
else:
os.system(
"wget http://micropython.org/resources/firmware/esp8266-20170108-v1.8.7.bin"
)
# g = Git()
# r = g.fetch()
except Exception as e:
Error.traceback(error=e, debug=True, trace=True)
return ""
elif arguments.run:
p = Probe()
d = {"port": p.tty, "program": arguments.PROGRAM}
os.system("ampy --port {port} run {program}".format(**d))
elif arguments.test:
p = Probe()
d = {"port": p.tty}
test = textwrap.dedent("""
n=3
print('Count to', n)
for i in range(1, n+1):
print(i)
""")
with open("test.py", "w") as f:
f.write(test)
os.system("ampy --port {port} run test.py".format(**d))
elif arguments.reset:
p = Probe()
d = {"port": p.tty}
test = textwrap.dedent("""
import machine
machine.reset()
""")
with open("tmp-reset.py", "w") as f:
f.write(test)
os.system("ampy --port {port} run tmp-reset.py".format(**d))
os.remove("tmp-reset.py")
elif arguments.credentials and arguments.set:
try:
net = Network(ssid=arguments.SSID,
username=arguments.USERNAME,
password=arguments.PASSWORD)
except Exception as e:
Error.traceback(e)
elif (arguments.credentials or arguments.cred) and arguments.put:
try:
filename = path_expand("~/.cloudmesh/robot/credentials.txt")
p = Probe()
# print (p.tty)
ampy = Ampy(p.tty)
ampy.put(filename, "credentials.txt", False)
except Exception as e:
Error.traceback(e)
sys.exit(1)
elif arguments.put:
try:
t = StopWatch()
t.start("put")
size = os.path.getsize(arguments.SOURCE)
optimize = arguments["-o"]
p = Probe()
ampy = Ampy(p.tty)
ampy.put(arguments.SOURCE,
dest=arguments.DESTINATION,
optimize=optimize)
t.stop("put")
t.print("Time:", "put")
print("Rate:", "{0:.2f}".format(size / t.get("put") / 1024),
"KB/s")
except Exception as e:
Error.traceback(e)
elif arguments.credentials and arguments.list:
try:
p = Probe()
ampy = Ampy(p.tty)
filename = path_expand(
"~/.cloudmesh/robot/credentials.txt.robot")
ampy.get("credentials.txt", filename)
r = Shell.cat(filename)
print(r)
os.remove(filename)
except Exception as e:
Error.traceback(e)
elif arguments.ls:
try:
p = Probe()
ampy = Ampy(p.tty)
r = ampy.ls()
print(r)
except Exception as e:
Error.traceback(e)
elif arguments.rm:
try:
p = Probe()
ampy = Ampy(p.tty)
ampy.rm(arguments.PATH)
except Exception as e:
Error.traceback(e)
elif arguments.rmdir:
try:
p = Probe()
ampy = Ampy(p.tty)
ampy.rmdir(arguments.PATH)
except Exception as e:
Error.traceback(e)
elif arguments.mkdir:
try:
p = Probe()
ampy = Ampy(p.tty)
ampy.mkdir(arguments.PATH)
except Exception as e:
Error.traceback(e)
elif arguments.dance:
pprint(arguments)
from cloudmesh.robot.turtles import Car, Cars
import turtle
iplist = Parameter.expand(arguments.IPS)
print(iplist)
ips = []
i = 1
for ip in iplist:
spec = [i, ip]
ips.append(spec)
i = i + 1
print("IPS", ips)
try:
colors = [
'blue', 'red', 'green', 'oragne', 'gray', 'brown', 'cyan',
'pink', 'purple', 'tomato'
]
cars = Cars(ips)
print(cars)
cars.read_dance(arguments.FILE)
wn = turtle.Screen() # creates a graphics window
# def a():
for i in range(0, len(ips)):
car = Car(i + 1, "robi" + str(i + 1), ips[i], colors[i])
cars.add(car)
cars.run()
wn.exitonclick()
except Exception as e:
Error.traceback(e)
elif arguments.inventory and arguments.export:
filename = arguments.FILENAME
inventory = NetworkInventory(
path_expand('~/.cloudmesh/robot/inventory.txt'))
inventory.export(filename)
elif arguments.inventory:
def load_inventory(path):
with open(path) as stream:
try:
d = yaml.safe_load(stream)
except Exception as e:
print("problem loading file", e)
for id in d:
d[id]['id'] = str(id)
return d
path = path_expand(arguments["--path"]
or "~/.cloudmesh/robot/inventory.txt")
print(path)
if not os.path.isfile(path):
print("ERROR: file does not exist")
sys.exit(1)
if arguments.ID:
d = load_inventory(path)
if arguments["--cat"]:
result = d[int(arguments.ID)]
else:
result = Printer.attribute(d[int(arguments.ID)])
print(result)
elif arguments["--cat"]:
with open(path) as stream:
try:
content = stream.read()
print(content)
except Exception as e:
print("problem loading file", e)
else:
d = load_inventory(path)
table = Printer.dict(
d, order=['id', 'name', 'ip', 'mac', 'chipid'])
print(table)
'''