def handle(self, *args, **options):
if args:
raise CommandError("Command doesn't accept any arguments")
name = options['name']
user_id = options['user_id']
project = options['project']
backend_id = options['backend_id']
image_id = options['image_id']
flavor_id = options['flavor_id']
password = options['password']
volumes = options['volumes']
helper_vm = options['helper_vm']
if not name:
raise CommandError("name is mandatory")
if not user_id:
raise CommandError("user is mandatory")
if not project:
project = user_id
if not password:
raise CommandError("password is mandatory")
if not flavor_id:
raise CommandError("flavor is mandatory")
if not image_id and not volumes:
raise CommandError("image is mandatory")
flavor = common.get_resource("flavor", flavor_id)
if image_id is not None:
common.get_image(image_id, user_id)
if backend_id:
backend = common.get_resource("backend", backend_id)
else:
backend = None
connection_list = parse_connections(options["connections"])
volumes_list = parse_volumes(volumes)
credentials = Credentials(user_id)
server = servers.create(credentials,
name,
password,
flavor,
image_id,
networks=connection_list,
volumes=volumes_list,
use_backend=backend,
helper=helper_vm,
project=project)
pprint.pprint_server(server, stdout=self.stdout)
wait = parse_bool(options["wait"])
common.wait_server_task(server, wait, self.stdout)
def handle(self, *args, **options):
if args:
raise CommandError("Command doesn't accept any arguments")
name = options['name']
user_id = options['user_id']
project = options['project']
backend_id = options['backend_id']
image_id = options['image_id']
flavor_id = options['flavor_id']
password = options['password']
volumes = options['volumes']
helper_vm = options['helper_vm']
if not name:
raise CommandError("name is mandatory")
if not user_id:
raise CommandError("user is mandatory")
if not project:
project = user_id
if not password:
raise CommandError("password is mandatory")
if not flavor_id:
raise CommandError("flavor is mandatory")
if not image_id and not volumes:
raise CommandError("image is mandatory")
flavor = common.get_resource("flavor", flavor_id)
if image_id is not None:
common.get_image(image_id, user_id)
if backend_id:
backend = common.get_resource("backend", backend_id)
else:
backend = None
connection_list = parse_connections(options["connections"])
volumes_list = parse_volumes(volumes)
credentials = Credentials(user_id)
server = servers.create(credentials, name, password, flavor, image_id,
networks=connection_list,
volumes=volumes_list,
use_backend=backend, helper=helper_vm,
project=project)
pprint.pprint_server(server, stdout=self.stdout)
wait = parse_bool(options["wait"])
common.wait_server_task(server, wait, self.stdout)
def handle(self, *args, **options):
if args:
raise CommandError("Command doesn't accept any arguments")
name = options['name']
user_id = options['user_id']
backend_id = options['backend_id']
image_id = options['image_id']
flavor_id = options['flavor_id']
password = options['password']
if not name:
raise CommandError("name is mandatory")
if not user_id:
raise CommandError("user-id is mandatory")
if not password:
raise CommandError("password is mandatory")
if not flavor_id:
raise CommandError("flavor-id is mandatory")
if not image_id:
raise CommandError("image-id is mandatory")
flavor = common.get_flavor(flavor_id)
image = common.get_image(image_id, user_id)
if backend_id:
backend = common.get_backend(backend_id)
else:
backend = None
do_create_server(user_id, name, password, flavor, image,
backend=backend)
def handle(self, *args, **options):
if len(args) != 1:
raise CommandError("Please provide a server ID")
server = get_vm(args[0])
flavor = '%s (%s)' % (server.flavor.id, server.flavor.name)
userid = server.userid
imageid = server.imageid
try:
image_name = get_image(imageid, userid).get('name')
except:
image_name = "None"
image = '%s (%s)' % (imageid, image_name)
usercache = UserCache(ASTAKOS_BASE_URL, ASTAKOS_TOKEN)
kv = {
'id': server.id,
'name': server.name,
'owner_uuid': userid,
'owner_name': usercache.get_name(userid),
'created': utils.format_date(server.created),
'updated': utils.format_date(server.updated),
'image': image,
'host id': server.hostid,
'flavor': flavor,
'deleted': utils.format_bool(server.deleted),
'suspended': utils.format_bool(server.suspended),
'state': format_vm_state(server),
}
utils.pprint_table(self.stdout, [kv.values()], kv.keys(),
options["output_format"], vertical=True)
def handle(self, *args, **options):
if args:
raise CommandError("Command doesn't accept any arguments")
name = options['name']
user_id = options['user_id']
backend_id = options['backend_id']
image_id = options['image_id']
flavor_id = options['flavor_id']
password = options['password']
if not name:
raise CommandError("name is mandatory")
if not user_id:
raise CommandError("user-id is mandatory")
if not password:
raise CommandError("password is mandatory")
if not flavor_id:
raise CommandError("flavor-id is mandatory")
if not image_id:
raise CommandError("image-id is mandatory")
flavor = common.get_flavor(flavor_id)
image = common.get_image(image_id, user_id)
if backend_id:
backend = common.get_backend(backend_id)
do_create_server(user_id,
name,
password,
flavor,
image,
backend=backend)
def pprint_server(server, display_mails=False, stdout=None, title=None):
if stdout is None:
stdout = sys.stdout
if title is None:
title = "State of Server %s in DB" % server.id
ucache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN)
userid = server.userid
try:
image = get_image(server.imageid, server.userid)['name']
except:
image = server.imageid
server_dict = OrderedDict([
("id", server.id),
("name", server.name),
("userid", server.userid),
("username", ucache.get_name(userid) if display_mails else None),
("project", server.project),
("shared_to_project", server.shared_to_project),
("flavor_id", server.flavor_id),
("flavor_name", server.flavor.name),
("imageid", server.imageid),
("image_name", image),
("created", server.created),
("state", server.operstate),
("backend", server.backend),
("deleted", server.deleted),
("action", server.action),
("task", server.task),
("rescue", server.rescue),
("rescue_image", server.rescue_image),
("task_job_id", server.task_job_id),
("backendjobid", server.backendjobid),
("backendopcode", server.backendopcode),
("backendjobstatus", server.backendjobstatus),
("backend_time", server.backendtime),
])
pprint_table(stdout,
server_dict.items(),
None,
separator=" | ",
title=title)
def handle(self, *args, **options):
if len(args) != 1:
raise CommandError("Please provide a server ID")
server = get_resource("server", args[0])
flavor = '%s (%s)' % (server.flavor.id, server.flavor.name)
userid = server.userid
imageid = server.imageid
try:
image_name = get_image(imageid, userid).get('name')
except:
image_name = "None"
image = '%s (%s)' % (imageid, image_name)
usercache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN)
kv = {
'id': server.id,
'name': server.name,
'owner_uuid': userid,
'owner_name': usercache.get_name(userid),
'project': server.project,
'shared_to_project': server.shared_to_project,
'created': utils.format_date(server.created),
'rescue': server.rescue,
'rescue_image': (server.rescue_image.id if server.rescue_image is
not None else None),
'updated': utils.format_date(server.updated),
'image': image,
'host id': server.hostid,
'flavor': flavor,
'deleted': utils.format_bool(server.deleted),
'suspended': utils.format_bool(server.suspended),
'state': format_vm_state(server),
'task': server.task,
'task_job_id': server.task_job_id,
}
self.pprint_table([kv.values()], kv.keys(), options["output_format"],
vertical=True)
def handle(self, *args, **options):
if args:
raise CommandError("Command doesn't accept any arguments")
name = options['name']
user_id = options['user_id']
backend_id = options['backend_id']
image_id = options['image_id']
flavor_id = options['flavor_id']
password = options['password']
if not name:
raise CommandError("name is mandatory")
if not user_id:
raise CommandError("user-id is mandatory")
if not password:
raise CommandError("password is mandatory")
if not flavor_id:
raise CommandError("flavor-id is mandatory")
if not image_id:
raise CommandError("image-id is mandatory")
flavor = common.get_flavor(flavor_id)
image = common.get_image(image_id, user_id)
if backend_id:
backend = common.get_backend(backend_id)
else:
backend = None
connection_list = parse_connections(options["connections"])
server = servers.create(user_id,
name,
password,
flavor,
image,
networks=connection_list,
use_backend=backend)
pprint.pprint_server(server, stdout=self.stdout)
wait = parse_bool(options["wait"])
common.wait_server_task(server, wait, self.stdout)
def pprint_server(server, display_mails=False, stdout=None, title=None):
if stdout is None:
stdout = sys.stdout
if title is None:
title = "State of Server %s in DB" % server.id
ucache = UserCache(ASTAKOS_AUTH_URL, ASTAKOS_TOKEN)
userid = server.userid
try:
image = get_image(server.imageid, server.userid)['name']
except:
image = server.imageid
server_dict = OrderedDict([
("id", server.id),
("name", server.name),
("userid", server.userid),
("username", ucache.get_name(userid) if display_mails else None),
("project", server.project),
("shared_to_project", server.shared_to_project),
("flavor_id", server.flavor_id),
("flavor_name", server.flavor.name),
("imageid", server.imageid),
("image_name", image),
("created", server.created),
("state", server.operstate),
("backend", server.backend),
("deleted", server.deleted),
("action", server.action),
("task", server.task),
("task_job_id", server.task_job_id),
("backendjobid", server.backendjobid),
("backendopcode", server.backendopcode),
("backendjobstatus", server.backendjobstatus),
("backend_time", server.backendtime),
])
pprint_table(stdout, server_dict.items(), None, separator=" | ",
title=title)
def handle(self, *args, **options):
if len(args) != 1:
raise CommandError("Please provide a server ID")
server = get_vm(args[0])
flavor = '%s (%s)' % (server.flavor.id, server.flavor.name)
userid = server.userid
imageid = server.imageid
try:
image_name = get_image(imageid, userid).get('name')
except:
image_name = "None"
image = '%s (%s)' % (imageid, image_name)
usercache = UserCache(ASTAKOS_BASE_URL, ASTAKOS_TOKEN)
kv = {
'id': server.id,
'name': server.name,
'owner_uuid': userid,
'owner_name': usercache.get_name(userid),
'created': utils.format_date(server.created),
'updated': utils.format_date(server.updated),
'image': image,
'host id': server.hostid,
'flavor': flavor,
'deleted': utils.format_bool(server.deleted),
'suspended': utils.format_bool(server.suspended),
'state': format_vm_state(server),
}
utils.pprint_table(self.stdout, [kv.values()],
kv.keys(),
options["output_format"],
vertical=True)
def handle(self, *args, **options):
if len(args) != 1:
raise CommandError("Please provide a server ID")
vm = common.get_vm(args[0])
displayname = options['displayname']
ucache = UserCache(ASTAKOS_BASE_URL, ASTAKOS_TOKEN)
try:
image = common.get_image(vm.imageid, vm.userid)['name']
except:
image = vm.imageid
sep = '-' * 80 + '\n'
labels = filter(lambda x: x is not Omit,
['name', 'owner_uuid',
'owner_name' if displayname else Omit,
'flavor', 'image', 'state', 'backend', 'deleted',
'action', 'backendjobid', 'backendopcode',
'backendjobstatus', 'backend_time'])
uuid = vm.userid
if displayname:
dname = ucache.get_name(uuid)
fields = filter(lambda x: x is not Omit,
[vm.name, uuid, dname if displayname else Omit,
vm.flavor.name, image, common.format_vm_state(vm),
str(vm.backend), str(vm.deleted), str(vm.action),
str(vm.backendjobid), str(vm.backendopcode),
str(vm.backendjobstatus), str(vm.backendtime)])
self.stdout.write(sep)
self.stdout.write('State of Server in DB\n')
self.stdout.write(sep)
for l, f in zip(labels, fields):
self.stdout.write(l.ljust(18) + ': ' + f.ljust(20) + '\n')
self.stdout.write('\n')
for nic in vm.nics.all():
params = (nic.index, nic.ipv4, nic.mac, nic.ipv6, nic.network)
self.stdout.write("nic/%d: IPv4: %s, MAC: %s, IPv6:%s,"
" Network: %s\n" % params)
client = vm.get_client()
try:
g_vm = client.GetInstance(vm.backend_vm_id)
self.stdout.write('\n')
self.stdout.write(sep)
self.stdout.write('State of Server in Ganeti\n')
self.stdout.write(sep)
for i in GANETI_INSTANCE_FIELDS:
try:
value = g_vm[i]
if i.find('time') != -1:
value = datetime.fromtimestamp(value)
self.stdout.write(i.ljust(14) + ': ' + str(value) + '\n')
except KeyError:
pass
except GanetiApiError as e:
if e.code == 404:
self.stdout.write('Server does not exist in backend %s\n' %
vm.backend.clustername)
else:
raise e
if not options['jobs']:
return
self.stdout.write('\n')
self.stdout.write(sep)
self.stdout.write('Non-archived jobs concerning Server in Ganeti\n')
self.stdout.write(sep)
jobs = client.GetJobs()
for j in jobs:
info = client.GetJobStatus(j)
summary = ' '.join(info['summary'])
job_is_relevant = summary.startswith("INSTANCE") and\
(summary.find(vm.backend_vm_id) != -1)
if job_is_relevant:
for i in GANETI_JOB_FIELDS:
value = info[i]
if i.find('_ts') != -1:
value = merge_time(value)
try:
self.stdout.write(i.ljust(14) + ': ' + str(value) +
'\n')
except KeyError:
pass
self.stdout.write('\n' + sep)
# Return the RAPI client to pool
vm.put_client(client)
