def create(caller_id, name, description, image_id, template_id, public_ip_id,
iso_list, disk_list, vnc, node_id):
"""
Creates new VM with specified attributes.
@cmview_admin_cm
@param_post{name,string}
@param_post{description,string}
@param_post{image_id,int}
@param_post{template_id,int}
@param_post{public_ip_id,int}
@param_post{iso_list,list(int)}
@param_post{disk_list,list(int)}
@param_post{vnc}
@param_post{node_id}
"""
user = User.get(caller_id)
vms = VM.create(user,
name=name,
description=description,
image_id=image_id,
template_id=template_id,
public_ip_id=public_ip_id,
iso_list=iso_list,
disk_list=disk_list,
vnc=vnc,
groups=[],
node_id=node_id)
for vm in vms:
thread = VMThread(vm, 'create')
thread.start()
return [vm.dict for vm in vms]
def create(caller_id, name, description, image_id, template_id, public_ip_id, iso_list, disk_list, vnc, groups, count=1, user_data=None,
ssh_key=None, ssh_username=None):
"""
Creates virtual machines.
@cmview_user
@parameter{name,string}
@parameter{description,string}
@parameter{image_id,int}
@parameter{template_id,int}
@parameter{ip_id,int}
@parameter{iso_list,list(int)} ISOs' ids
@parameter{vnc}
@parameter{groups}
@parameter{user_data} data accessible via ec2ctx
@parameter{ssh_key}
@parameter{ssh_username}
@returns @asreturned{src.cm.views.utils.vm.create()}
"""
user = User.get(caller_id)
try:
user.check_points()
except:
message.warn(caller_id, 'point_limit', {'used_points': user.used_points, 'point_limit': user.points})
vms = VM.create(user, name=name, description=description, image_id=image_id,
template_id=template_id, public_ip_id=public_ip_id, iso_list=iso_list, disk_list=disk_list,
vnc=vnc, groups=groups, count=count, user_data=user_data, ssh_key=ssh_key, ssh_username=ssh_username)
for vm in vms:
thread = VMThread(vm, 'create')
thread.start()
return [vm.dict for vm in vms]
def create(caller_id, name, description, image_id, template_id, public_ip_id, iso_list, disk_list, vnc, node_id):
user = User.get(caller_id)
vms = VM.create(user, name=name, description=description, image_id=image_id,
template_id=template_id, public_ip_id=public_ip_id, iso_list=iso_list, disk_list=disk_list,
vnc=vnc, groups=[], node_id=node_id)
for vm in vms:
thread = VMThread(vm, 'create')
thread.start()
return [vm.dict for vm in vms]
def register_head(vm):
"""
Head registration process:
- Creates ssh keys and sets their values for WN;
- Inserts VMs into the database;
- Then starts VMThreads which create actual machines.
Called when registering farms head.
@parameter{vm,VM} instance of the VM to be registered as head
"""
log.debug(vm.user_id, "machine %d: registered as head" % vm.id)
log.debug(vm.user_id, "creating lock for machine %d in farm %d" % (vm.id, vm.farm_id))
# skip if farm is already configured - reboot head
if vm.is_head() == True and vm.farm.state == farm_states['running']:
return
vms = []
if vm.farm.state == farm_states['init_head']:
vm.farm.state = farm_states['running']
vm.farm.save()
log.info(vm.user_id, 'generating ssh keys on head %d' % vm.id)
try:
r = Command.execute('generate_key', vm.user_id, vm.id)
r = json.loads(r)
log.info(vm.user_id, 'generated key: %s for machine %d' % (r, vm.id))
for wn in vm.farm.vms.all():
wn.ssh_username = '******'
wn.ssh_key = r
wn.save()
if not wn.is_head():
vms.append(wn)
ssh_username = '******'
ssh_key = r
log.debug(vm.user_id, 'appended %d vms to farm [id:%d]' % (vm.farm.vms.count() - 1, vm.id)) # excluding head
Command.add_command('add_ssh_key', vm.user_id, vm.id, user=ssh_username, ssh_key=ssh_key)
Command.add_command('update_hosts', vm.user_id, vm.id, hosts_list=vm.farm.hosts(), user=ssh_username)
Command.execute('set_hostname', vm.user_id, vm.id, hostname=vm.name.replace(vm.farm.name, 'farm'))
except Exception:
log.exception(vm.user_id, '')
vm.farm.state = farm_states['unconfigured']
message.error(vm.id, 'farm_create', {'id': vm.farm.id, 'name': vm.farm.name})
log.info(vm.user_id, 'Head %d registered' % vm.id)
shared = {"counter": len(vms), "lock": threading.Lock()}
for vm in vms:
thread = VMThread(vm, 'create', shared)
thread.start()
log.debug(vm.user_id, 'vm thread created [vm id:%d]' % vm.id)
def reset(vms):
from cm.utils.threads.vm import VMThread
results = []
for vm in vms:
if vm.state in (vm_states['running'], vm_states['running ctx']):
thread = VMThread(vm, 'reset')
thread.start()
results.append({'status': 'ok', 'data': ''})
else:
results.append({'status': 'vm_wrong_state', 'data': ''})
return results
def reset(vms):
from cm.utils.threads.vm import VMThread
results = []
for vm in vms:
if vm.state in (vm_states['running'], vm_states['running ctx']):
thread = VMThread(vm, 'reset')
thread.start()
results.append({'status': 'ok', 'data': ''})
else:
results.append({'status': 'vm_wrong_state', 'data': ''})
return results
def update_state(remote_ip, vm_name, action, state):
"""
@cmview_ci
@param_post{remote_ip,string}
@param_post{vm_name}
@param_post{action}
@param_post{state}
"""
try:
node = Node.objects.get(address=remote_ip)
except:
raise CMException('node_not_found')
try:
vm_id = int(vm_name.split('-')[1])
user_id = int(vm_name.split('-')[2])
except:
log.debug(0, "Unknown vm from hook: %s" % vm_name)
raise CMException('vm_not_found')
if action != "stopped":
log.debug(user_id, "Not updating vm state: action is %s" % str(action))
return ''
try:
VM.objects.update()
vm = VM.objects.get(id=vm_id)
except:
log.error(user_id, 'Cannot find vm in database!')
raise CMException('vm_not_found')
if not vm.state in [vm_states['running ctx'], vm_states['running']]:
log.error(user_id, 'VM is not running!')
raise CMException('vm_not_running')
if vm.state == vm_states['restart']:
raise CMException('vm_restart')
thread = VMThread(vm, 'delete')
thread.start()
return ''
def update_state(remote_ip, vm_name, action, state):
"""
@cmview_ci
@param_post{remote_ip,string}
@param_post{vm_name}
@param_post{action}
@param_post{state}
"""
try:
node = Node.objects.get(address=remote_ip)
except:
raise CMException('node_not_found')
try:
vm_id = int(vm_name.split('-')[1])
user_id = int(vm_name.split('-')[2])
except:
log.debug(0, "Unknown vm from hook: %s" % vm_name)
raise CMException('vm_not_found')
if action != "stopped":
log.debug(user_id, "Not updating vm state: action is %s" % str(action))
return ''
try:
VM.objects.update()
vm = VM.objects.get(id=vm_id)
except:
log.error(user_id, 'Cannot find vm in database!')
raise CMException('vm_not_found')
if not vm.state in [vm_states['running ctx'], vm_states['running']]:
log.error(user_id, 'VM is not running!')
raise CMException('vm_not_running')
if vm.state == vm_states['restart']:
raise CMException('vm_restart')
thread = VMThread(vm, 'delete')
thread.start()
return ''
def create(caller_id, name, description, image_id, template_id, public_ip_id, iso_list, disk_list, vnc, node_id):
"""
Creates new VM with specified attributes.
@cmview_admin_cm
@param_post{name,string}
@param_post{description,string}
@param_post{image_id,int}
@param_post{template_id,int}
@param_post{public_ip_id,int}
@param_post{iso_list,list(int)}
@param_post{disk_list,list(int)}
@param_post{vnc}
@param_post{node_id}
"""
user = User.get(caller_id)
vms = VM.create(user, name=name, description=description, image_id=image_id,
template_id=template_id, public_ip_id=public_ip_id, iso_list=iso_list, disk_list=disk_list,
vnc=vnc, groups=[], node_id=node_id)
for vm in vms:
thread = VMThread(vm, 'create')
thread.start()
return [vm.dict for vm in vms]
def create(caller_id,
name,
description,
image_id,
template_id,
public_ip_id,
iso_list,
disk_list,
vnc,
groups,
count=1,
user_data=None,
ssh_key=None,
ssh_username=None):
"""
Creates virtual machines.
@cmview_user
@param_post{name,string}
@param_post{description,string}
@param_post{image_id,int}
@param_post{template_id,int}
@param_post{public_ip_id,int}
@param_post{iso_list,list(int)} ISOs' ids
@param_post{disk_list,list(int)}
@param_post{vnc}
@param_post{count}
@param_post{groups}
@param_post{user_data} data accessible via ec2ctx
@param_post{ssh_key}
@param_post{ssh_username}
@returns @asreturned{src.cm.views.utils.vm.create()}
"""
user = User.get(caller_id)
try:
user.check_points()
except:
message.warn(caller_id, 'point_limit', {
'used_points': user.used_points,
'point_limit': user.points
})
vms = VM.create(user,
name=name,
description=description,
image_id=image_id,
template_id=template_id,
public_ip_id=public_ip_id,
iso_list=iso_list,
disk_list=disk_list,
vnc=vnc,
groups=groups,
count=count,
user_data=user_data,
ssh_key=ssh_key,
ssh_username=ssh_username)
for vm in vms:
thread = VMThread(vm, 'create')
thread.start()
return [vm.dict for vm in vms]
def create(caller_id, name, description, image_id, head_template_id,
worker_template_id, public_ip_id, iso_list, disk_list, vnc, groups,
count):
"""
Method creates new caller's Farm.
@cmview_user
@param_post{name,string} Farm's name
@param_post{description,string}
@param_post{image_id,int} image for WNs and Head
@param_post{head_template_id,int} Head's template
@param_post{worker_template_id,int} Worker Node's template
@param_post{public_ip_id,int} Worker Node's template
@param_post{iso_list,list}
@param_post{disk_list,list}
@param_post{vnc,list}
@param_post{groups,list}
@param_post{count,int} number of Worker Nodes
@raises{farm_create,CMException}
"""
user = User.get(caller_id)
try:
user.check_points()
except:
message.warn(caller_id, 'point_limit', {
'used_points': user.used_points,
'point_limit': user.points
})
farm = Farm.create(user=user, name=name, description=description)
vms = VM.create(user,
name=name,
description=description,
image_id=image_id,
template_id=worker_template_id,
head_template_id=head_template_id,
public_ip_id=public_ip_id,
iso_list=iso_list,
disk_list=disk_list,
vnc=vnc,
groups=groups,
farm=farm,
count=count)
farm.save()
for vm in vms:
vm.farm = farm
if not vm.is_head():
# disable autosave
vm.save_vm = 0
vm.save()
try:
farm.save()
except Exception:
log.exception(caller_id, 'farm_create')
raise CMException('farm_create')
VMThread(vms[0], 'create').start()
return [vm.dict for vm in vms]
def register_head(vm):
"""
Head registration process:
- Creates ssh keys and sets their values for WN;
- Inserts VMs into the database;
- Then starts VMThreads which create actual machines.
Called when registering farms head.
@parameter{vm,VM} instance of the VM to be registered as head
"""
log.debug(vm.user_id, "machine %d: registered as head" % vm.id)
log.debug(
vm.user_id,
"creating lock for machine %d in farm %d" % (vm.id, vm.farm_id))
# skip if farm is already configured - reboot head
if vm.is_head() == True and vm.farm.state == farm_states['running']:
return
vms = []
if vm.farm.state == farm_states['init_head']:
vm.farm.state = farm_states['running']
vm.farm.save()
log.info(vm.user_id, 'generating ssh keys on head %d' % vm.id)
try:
r = Command.execute('generate_key', vm.user_id, vm.id)
r = json.loads(r)
log.info(vm.user_id,
'generated key: %s for machine %d' % (r, vm.id))
for wn in vm.farm.vms.all():
wn.ssh_username = '******'
wn.ssh_key = r
wn.save()
if not wn.is_head():
vms.append(wn)
ssh_username = '******'
ssh_key = r
log.debug(vm.user_id, 'appended %d vms to farm [id:%d]' %
(vm.farm.vms.count() - 1, vm.id)) # excluding head
Command.add_command('add_ssh_key',
vm.user_id,
vm.id,
user=ssh_username,
ssh_key=ssh_key)
Command.add_command('update_hosts',
vm.user_id,
vm.id,
hosts_list=vm.farm.hosts(),
user=ssh_username)
Command.execute('set_hostname',
vm.user_id,
vm.id,
hostname=vm.name.replace(vm.farm.name, 'farm'))
except Exception:
log.exception(vm.user_id, '')
vm.farm.state = farm_states['unconfigured']
message.error(vm.id, 'farm_create', {
'id': vm.farm.id,
'name': vm.farm.name
})
log.info(vm.user_id, 'Head %d registered' % vm.id)
shared = {"counter": len(vms), "lock": threading.Lock()}
for vm in vms:
thread = VMThread(vm, 'create', shared)
thread.start()
log.debug(vm.user_id, 'vm thread created [vm id:%d]' % vm.id)
