def download(caller_id, description, name, path, disk_controller, network_device, platform, video_device):
"""
Downloads image depending on the \c data parameter.
@cmview_user
@parameter{path,string} HTTP or FTP path to image to download
@parameter{name,string}
@parameter{description,string}
@parameter{type,image_types} type of image, automatically set, type is in the URL requested
@response{None}
@raises{image_not_found,CMException}
@raises{image_create,CMException}
"""
user = User.get(caller_id)
if not any([path.startswith("http://"), path.startswith("https://"), path.startswith("ftp://")]):
path = "http://" + path.strip()
# size value is taken
try:
connection = urllib.urlopen(path)
size = int(connection.info()["Content-Length"])
except IOError:
log.exception(caller_id, "Cannot find image")
raise CMException("image_not_found")
except KeyError:
log.exception(caller_id, "Cannot calculate size")
raise CMException("image_calculate_size")
user = User.get(caller_id)
user.check_storage(size / (1024 * 1024))
image = SystemImage.create(
name=name,
description=description,
user=user,
platform=platform,
disk_controller=disk_controller,
network_device=network_device,
video_device=video_device,
)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException("image_create")
def add(caller_id, user_id):
"""
Adds specified CC1 User to current CM.
@cmview_user
@note This method is decorated by user_log decorator, not by admin_cm_log.
This is caused by the fact that CLMAdmin doesn't need to be CMAdmin and
despite not having rights to call CMAdmin functions he needs to call it on
CMAdmin privileges.
@param_post{user_id}
"""
User.create(user_id)
def multiple_change_quota(caller_id, user_ids, memory=None, cpu=None, storage=None, public_ip=None, points=None):
"""
Method changes quota of multiple users.
@cmview_admin_cm
@dictkey{users,list(int)} ids of the users to change quota
@dictkey{cpu,int} cpu to set
@dictkey{storage,int} storage to set
@dictkey{public_ip,int} number of public_ips to set
@dictkey{points,int} points to set
@response{None}
"""
for user_id in user_ids:
user = User.get(user_id)
user.memory = memory or user.memory
user.cpu = cpu or user.cpu
user.storage = storage or user.storage
user.public_ip = public_ip or user.public_ip
user.points = points or user.points
try:
user.save()
except:
raise CMException('user_change_quota')
def change_quota(caller_id, user_id, memory, cpu, storage, public_ip, points):
"""
Function changes quota for user @prm{user_id}.
@cmview_admin_cm
@parameter{user_id}
@parameter{memory}
@parameter{cpu,int}
@parameter{storage,int}
@parameter{public_ip,int}
@parameter{points,int}
"""
user = User.get(user_id)
user.memory = memory
user.cpu = cpu
user.storage = storage
user.public_ip = public_ip
user.points = points
try:
user.save()
except:
raise CMException('user_change_quota')
def add(caller_id, user_id):
"""
Function adds new user to DB and creates its home directory.
@cmview_user
@note This method is decorated by user_log decorator, not by admin_cm_log.
This is caused by the fact that CLMAdmin doesn't need to be CMAdmin and
despite not having rights to call CMAdmin functions he needs to call it on
CMAdmin priviledges.
@parameter{user_id}
@response{None}
"""
User.create(user_id)
def change_quota(caller_id, user_id, memory, cpu, storage, public_ip, points):
"""
Changes specified User's quota.
@cmview_admin_cm
@param_post{user_id}
@param_post{memory}
@param_post{cpu,int}
@param_post{storage,int}
@param_post{public_ip,int}
@param_post{points,int}
"""
user = User.get(user_id)
user.memory = memory
user.cpu = cpu
user.storage = storage
user.public_ip = public_ip
user.points = points
try:
user.save()
except:
raise CMException('user_change_quota')
def download(caller_id, description, name, path, disk_dev, disk_controller):
"""
Downloads specified StorateImage from remote path.
@cmview_admin_cm
@param_post{description,string}
@param_post{name,string} how to name newly downloaded storage image
@param_post{path,string} HTTP or FTP path to download StorageImage.
@param_post{disk_dev}
@param_post{disk_controller}
"""
# size value is taken
try:
connection = urllib.urlopen(path)
size = int(connection.info()["Content-Length"])
except IOError:
log.exception('Cannot find image')
raise CMException('image_not_found')
except KeyError:
log.exception(caller_id, 'Cannot calculate size')
raise CMException('image_calculate_size')
user = User.get(caller_id)
image = StorageImage.create(name=name, description=description, user=user, disk_dev=disk_dev, disk_controller=disk_controller)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
def request(caller_id, mask, name):
"""
Tries to allocate network with specified mask for caller.
@cmview_user
@param_post{mask}
@param_post{name}
@response{dict} UserNetwork.dict property of the newly created UserNetwork
"""
new_net = None
user = User.get(caller_id)
for available_network in AvailableNetwork.objects.all():
log.debug(user.id, "Trying to allocate in %s" % str(available_network.to_ipnetwork()))
if available_network.state == available_network_states['ok']:
try:
net = available_network.get_unused_ipnetwork(mask)
new_net = UserNetwork()
new_net.address = str(net.network)
new_net.mask = mask
new_net.name = name
new_net.available_network = available_network
new_net.user = user
new_net.save()
new_net.allocate()
return new_net.dict
except:
continue
if new_net == None:
raise CMException('available_network_not_found')
def download(caller_id, name, description, path, disk_controller):
"""
Downloads specified IsoImage and saves it with specified name and description.
@cmview_user
@param_post{name,string}
@param_post{description,string}
@param_post{path,string} HTTP or FTP path to IsoImage to download
@param_post{disk_controller}
"""
user = User.get(caller_id)
if not any([path.startswith('http://'), path.startswith('https://'), path.startswith('ftp://')]):
path = 'http://' + path.strip()
# size value is taken
try:
connection = urllib.urlopen(path)
size = int(connection.info()["Content-Length"])
except IOError:
log.exception('Cannot find image')
raise CMException('image_not_found')
except KeyError:
log.exception(caller_id, 'Cannot calculate size')
raise CMException('image_calculate_size')
user.check_storage(size / (1024 * 1024))
image = IsoImage.create(user=user, description=description, name=name, disk_controller=disk_controller, disk_dev=1)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
def multiple_change_quota(caller_id,
user_ids,
memory=None,
cpu=None,
storage=None,
public_ip=None,
points=None):
"""
Changes quota of multiple users.
@cmview_admin_cm
@param_post{user_ids,list(int)}
@param_post{memory,int} new RAM memory limit [MB]
@param_post{cpu,int} new CPU's limit
@param_post{storage,int} new storage space's limit [MB]
@param_post{public_ip,int} new limit of public_ips
@param_post{points,int} new monthly points limit
"""
for user_id in user_ids:
user = User.get(user_id)
user.memory = memory or user.memory
user.cpu = cpu or user.cpu
user.storage = storage or user.storage
user.public_ip = public_ip or user.public_ip
user.points = points or user.points
try:
user.save()
except:
raise CMException('user_change_quota')
def request(caller_id, mask, name):
"""
Tries to allocate network with specified mask for caller.
@cmview_user
@param_post{mask}
@param_post{name}
@response{dict} UserNetwork.dict property of the newly created UserNetwork
"""
new_net = None
user = User.get(caller_id)
for available_network in AvailableNetwork.objects.all():
log.debug(
user.id,
"Trying to allocate in %s" % str(available_network.to_ipnetwork()))
if available_network.state == available_network_states['ok']:
try:
net = available_network.get_unused_ipnetwork(mask)
new_net = UserNetwork()
new_net.address = str(net.network)
new_net.mask = mask
new_net.name = name
new_net.available_network = available_network
new_net.user = user
new_net.save()
new_net.allocate()
return new_net.dict
except:
continue
if new_net == None:
raise CMException('available_network_not_found')
def download(caller_id, description, name, path, disk_controller, network_device, platform, video_device):
"""
Downloads image depending on the \c data parameter.
@cmview_admin_cm
@parameter{description,string}
@parameter{name,string}
@parameter{path,string} HTTP or FTP path to image to download
@parameter{type,image_types} type of image, automatically set, type is in the URL requested
@response{None}
"""
# size value is taken
try:
connection = urllib.urlopen(path)
size = int(connection.info()["Content-Length"])
except IOError:
log.exception(caller_id, 'Cannot find image')
raise CMException('image_not_found')
except KeyError:
log.exception(caller_id, 'Cannot calculate size')
raise CMException('image_calculate_size')
user = User.get(caller_id)
image = SystemImage.create(name=name, description=description, user=user, platform=platform,
disk_controller=disk_controller, network_device=network_device,
video_device=video_device)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
def points_history(caller_id):
"""
@cmview_user
@response caller's point history
"""
return User.get(caller_id).points_history()
def create(caller_id, name, description, filesystem, size, disk_controller):
"""
Creates new StorageImage.
@cmview_user
@param_post{name,string}
@param_post{description,string}
@param_post{filesystem,int} id of the filesystem. Supported filesystems are
common.hardware.disk_filesystems
@param_post{size,int} size of the SystemImage to create [MB]
@param_post{disk_controller}
@response{dict} StorageImage.dict property of newly created StorageImage
"""
if size < 1:
raise CMException('image_invalid_size')
user = User.get(caller_id)
user.check_storage(size)
image = StorageImage.create(user=user, disk_controller=disk_controller, description=description, name=name,
size=size)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
def request(caller_id):
"""
Method requests single PublicIP address for caller. If caller's quota
is exceeded, exception is raised. Otherwise caller obtains a new PublicIP
address.
@cmview_user
@response{string} newly obtained PublicIP's address
@raises{public_lease_not_found,CMException}
@raises{public_lease_request,CMException}
"""
user = User.get(caller_id)
if len(user.public_ips.all()) >= user.public_ip:
raise CMException('public_lease_limit')
ips = PublicIP.objects.filter(user=None).all()
if len(ips) == 0:
raise CMException('public_lease_not_found')
ip = ips[0]
ip.user = user
ip.request_time = datetime.now()
ip.release_time = None
try:
ip.save()
except Exception:
raise CMException('public_lease_request')
return ip.address
def list_user_networks(caller_id, user_id=None):
"""
@cmview_admin_cm
@param_post{user_id,int} (optional) if specified, only networks belonging
to specigied User are fetched.
@param_post{only_unused,bool} (optional) if @val{True}, only unused
networks are returned
@response{list(dict)} UserNetwork.dict property for each requested
UserNetwork
"""
try:
user_networks = []
if user_id:
user = User.get(user_id)
user_networks = UserNetwork.objects.filter(user=user)
else:
user_networks = UserNetwork.objects.all()
except:
raise CMException('network_not_found')
response = []
for network in user_networks:
response.append(network.dict)
return response
def request(caller_id):
"""
Method requests single PublicIP address for caller. If caller's quota
is exceeded, exception is raised. Otherwise caller obtains a new PublicIP
address.
@cmview_user
@response{string} newly obtained PublicIP's address
@raises{public_lease_not_found,CMException}
@raises{public_lease_request,CMException}
"""
user = User.get(caller_id)
if len(user.public_ips.all()) >= user.public_ip:
raise CMException('public_lease_limit')
ips = PublicIP.objects.filter(user=None).all()
if len(ips) == 0:
raise CMException('public_lease_not_found')
ip = ips[0]
ip.user = user
ip.request_time = datetime.now()
ip.release_time = None
try:
ip.save()
except Exception:
raise CMException('public_lease_request')
return ip.address
def points_history(caller_id):
"""
@cmview_user
@response caller's point history
"""
return User.get(caller_id).points_history()
def create(caller_id, name, description, filesystem, size, disk_controller):
"""
Method creates new Image. It's only used by disk_volume type (only url view with create)
@cmview_user
@parameter{name,string}
@parameter{description,string}
@parameter{filesystem,int} id of the filesystem. Supported filesystems are listed in settings
@parameter{size,int} size of the Image to create [MB]
@parameter{disk_controller}
@response{dict} Image's dictionary
"""
if size < 1:
raise CMException('image_invalid_size')
user = User.get(caller_id)
user.check_storage(size)
image = StorageImage.create(user=user, disk_controller=disk_controller, description=description, name=name,
size=size)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
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 list_user_networks(caller_id, user_id=None):
"""
@cmview_admin_cm
@param_post{user_id,int} (optional) if specified, only networks belonging
to specigied User are fetched.
@param_post{only_unused,bool} (optional) if @val{True}, only unused
networks are returned
@response{list(dict)} UserNetwork.dict property for each requested
UserNetwork
"""
try:
user_networks = []
if user_id:
user = User.get(user_id)
user_networks = UserNetwork.objects.filter(user=user)
else:
user_networks = UserNetwork.objects.all()
except:
raise CMException('network_not_found')
response = []
for network in user_networks:
response.append(network.dict)
return response
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 check_quota(caller_id):
"""
Check quota for caller user.
@cmview_user
@response{dict} extended caller's data
"""
return User.get(caller_id).long_dict
def get_list(caller_id):
"""
@cmview_user
@response{list(dict)} PublicIP.dict property for each caller's PublicIP
"""
user = User.get(caller_id)
ips = PublicIP.objects.filter(user=user).all()
return [ip.dict for ip in ips]
def check_quota(caller_id):
"""
Check quota for caller user.
@cmview_user
@response{dict} extended caller's data
"""
return User.get(caller_id).long_dict
def get_list(caller_id):
"""
@cmview_user
@response{list(dict)} PublicIP.dict property for each caller's PublicIP
"""
user = User.get(caller_id)
ips = PublicIP.objects.filter(user=user).all()
return [ip.dict for ip in ips]
def list_leases(caller_id, network_id):
user = User.get(caller_id)
try:
user_network = UserNetwork.objects.filter(user=user).get(id=network_id)
except:
raise CMException('network_not_found')
response = []
for lease in user_network.lease_set.all():
response.append(lease.dict)
return response
def download(caller_id, description, name, path, disk_controller, network_device, platform, video_device):
"""
Downloads image depending on the \c data parameter.
@cmview_user
@parameter{path,string} HTTP or FTP path to image to download
@parameter{name,string}
@parameter{description,string}
@parameter{type,image_types} type of image, automatically set, type is in the URL requested
@response{None}
@raises{image_not_found,CMException}
@raises{image_create,CMException}
"""
user = User.get(caller_id)
if not any([path.startswith('http://'), path.startswith('https://'), path.startswith('ftp://')]):
path = 'http://' + path.strip()
# size value is taken
try:
connection = urllib.urlopen(path)
size = int(connection.info()["Content-Length"])
except IOError:
log.exception(caller_id, 'Cannot find image')
raise CMException('image_not_found')
except KeyError:
log.exception(caller_id, 'Cannot calculate size')
raise CMException('image_calculate_size')
user = User.get(caller_id)
user.check_storage(size / (1024 * 1024))
image = SystemImage.create(name=name, description=description, user=user, platform=platform,
disk_controller=disk_controller, network_device=network_device, video_device=video_device)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
def add_missing(caller_id, remote):
"""
Adds Users whose ids are listed in @prm{remote} and who are locally
missing.
@cmview_user
@param_post{remote,list(int)} ids of the remote Users
"""
# remote must be passed through POST as a list
# it is a list of users id
try:
# put all the user ids in a list
local = User.objects.all().values_list('id', flat=True)
# create user for all the ids which are in remote but not in the local cm
for user_id in [uid for uid in remote if uid not in local]:
User.create(user_id)
except:
raise CMException('user_create')
def check_quota(caller_id, user_id):
"""
Get specified User's qouta.
@cmview_admin_cm
@param_post{user_id,int}
@response{dict} Full User's quota
"""
return User.get(user_id).long_dict
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 check_quota(caller_id, user_id):
"""
Check quota of the user @prm{user_id}.
@cmview_admin_cm
@parameter{user_id,int}
@response{dict} extended user's data
"""
return User.get(user_id).long_dict
def list_user_networks(caller_id):
user = User.get(caller_id)
try:
user_networks = UserNetwork.objects.filter(user=user)
except:
raise CMException('network_not_found')
response = []
for network in user_networks:
if network.available_network.state == available_network_states['ok']:
response.append(network.dict)
return response
def release(caller_id, network_id):
user = User.get(caller_id)
try:
user_network = UserNetwork.objects.filter(user=user).get(id=network_id)
except:
raise CMException('network_not_found')
if user_network.is_in_use():
raise CMException('network_in_use')
user_network.release()
user_network.delete()
def add_missing(caller_id, remote):
"""
Function adds missing users listed in remote that don't belong to local.
@cmview_user
@parameter{remote,list of int}
@response{None}
"""
# remote must be passed through POST as a list
# it is a list of users id
try:
# put all the user ids in a list
local = User.objects.all().values_list('id', flat=True)
# create user for all the ids which are in remote but not in the local cm
for user_id in [uid for uid in remote if uid not in local]:
User.create(user_id)
except:
raise CMException('user_create')
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 Farm for caller:
-#. Creates VMs described by \c machine dict.
-#. Creates farm named by \c machine[name] consisting of those VMs.
-#. Creates thread for this farm.
@decoratedby{src.cm.utils.decorators.user_log}
@parameter{machine,dict}
\n fields:
@dictkey{name,string} farm's name
@dictkey{count,int} number of Worker Nodes
@dictkey{template_id,int} Worker Node's template
@dictkey{head_template_id,int} Head's template
@dictkey{image_id,int} image for WNs and Head
@dictkey{groups,list} optional
@dictkey{node_id} optional on which node farm is to be created
@dictkey{description,string} description of the farm
@response{None}
@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 add(new_user_id):
"""
Adds existing CLM User to CM Users.
@cmview_guest
@param_post{new_user_id,int} id of the existing CLM User
@response{None}
"""
user = User.create(new_user_id)
try:
user.save()
except Exception, e:
log.debug(0, "Adding to DB: %s" % str(e))
raise CMException('user_create')
def add(new_user_id):
"""
Adds existing CLM User to CM Users.
@cmview_guest
@param_post{new_user_id,int} id of the existing CLM User
@response{None}
"""
user = User.create(new_user_id)
try:
user.save()
except Exception, e:
log.debug(0, "Adding to DB: %s" % str(e))
raise CMException('user_create')
def add(new_user_id):
"""
Function adds new user to DB and creates its home directory.
@cmview_guest
@dictkey{new_user_id,int}
@response{None}
"""
user = User.create(new_user_id)
try:
user.save()
except Exception, e:
log.debug(0, "Adding to DB: %s" % str(e))
raise CMException('user_create')
def list_user_networks(caller_id):
"""
@cmview_user
@response{list(dict)} UserNetwork.dict property for each caller's
UserNetwork
"""
user = User.get(caller_id)
try:
user_networks = UserNetwork.objects.filter(user=user)
except:
raise CMException('network_not_found')
response = []
for network in user_networks:
if network.available_network.state == available_network_states['ok']:
response.append(network.dict)
return response
def list_user_networks(caller_id):
"""
@cmview_user
@response{list(dict)} UserNetwork.dict property for each caller's
UserNetwork
"""
user = User.get(caller_id)
try:
user_networks = UserNetwork.objects.filter(user=user)
except:
raise CMException('network_not_found')
response = []
for network in user_networks:
if network.available_network.state == available_network_states['ok']:
response.append(network.dict)
return response
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 save_and_shutdown(caller_id, vm_id, name, description):
"""
Calls VM.save_and_shutdown() on specified VM
@cmview_user
@param_post{vm_id,int} id of the VM to save and shutdown.
@param_post{name,string} name of the new SystemImage VM should be saved to
@param_post{description,string} description of the new SystemImage VM
should be saved to
"""
user = User.get(caller_id)
vm = VM.get(caller_id, vm_id)
if user.used_storage + vm.system_image.size > user.storage:
raise CMException('user_storage_limit')
VM.save_and_shutdown(caller_id, vm, name, description)
def save_and_shutdown(caller_id, vm_id, name, description):
"""
Calls VM.save_and_shutdown() on specified VM
@cmview_user
@param_post{vm_id,int} id of the VM to save and shutdown.
@param_post{name,string} name of the new SystemImage VM should be saved to
@param_post{description,string} description of the new SystemImage VM
should be saved to
"""
user = User.get(caller_id)
vm = VM.get(caller_id, vm_id)
if user.used_storage + vm.system_image.size > user.storage:
raise CMException('user_storage_limit')
VM.save_and_shutdown(caller_id, vm, name, description)
def save_and_shutdown(caller_id, vm_id, name, description):
"""
Calls src.cm.views.utils.image.save_and_shutdown() for the VM selected.
@cmview_user
@parameter{vm_id,int} id of the VM to save and shutdown.
@parameter{name,string}
@parameter{description,string}
"""
user = User.get(caller_id)
vm = VM.get(caller_id, vm_id)
if user.used_storage + vm.system_image.size > user.storage:
raise CMException('user_storage_limit')
VM.save_and_shutdown(caller_id, vm, name, description)
def save_and_shutdown(caller_id, vm_id, name, description):
"""
Saves and shutdowns specified VM, without checking User quota.
@cmview_admin_cm
@param_post{vm_id,string} id of the VM to save
@param_post{name,string}
@param_post{description,string}
"""
vm = VM.admin_get(vm_id)
user = User.get(vm.user.id)
if user.used_storage + vm.system_image.size > user.storage:
raise CMException('user_storage_limit')
VM.save_and_shutdown(user.id, vm, name, description)
def list_leases(caller_id, network_id):
"""
Returns all Leases in specified UserNetwork
@cmview_user
@param_post{network_id} id of the UserNetwork which Leases should be listed
from
@response{list(dict)} Lease.dict property for each Lease in specified UserNetwork
"""
user = User.get(caller_id)
try:
user_network = UserNetwork.objects.filter(user=user).get(id=network_id)
except:
raise CMException('network_not_found')
response = []
for lease in user_network.lease_set.all():
response.append(lease.dict)
return response
def copy(caller_id, src_image_id, dest_user_id):
"""
Copy selected StorageImage to user's StorageImages
@cmview_admin_cm
@param_post{src_image_id,int}
@param_post{dest_user_id,int}
"""
src_image = StorageImage.admin_get(src_image_id)
dest_user = User.get(dest_user_id)
dest_image = StorageImage.create(name=src_image.name, description=src_image.description, user=dest_user,
disk_controller=src_image.disk_controller, size=src_image.size)
try:
dest_image.save()
except Exception, e:
log.error(caller_id, "Unable to commit: %s" % str(e))
raise CMException('image_create')
def unassign(caller_id, lease_id):
"""
Method detaches PublicIP from caller's VM.
@cmview_user
@param_post{lease_id,int} id of the VM's Lease from which PublicIP should
be detached.
@raises{lease_not_found,CMException}
@raises{public_lease_unassign,CMException}
"""
user = User.get(caller_id)
try:
lease = Lease.objects.get(id=lease_id)
except Exception, e:
log.exception(caller_id, str(e))
raise CMException("lease_not_found")
def release(caller_id, network_id):
"""
When UserNetwork isn't needed anymore, it should be explicitly released
by User. If UserNetwork is in use, exception is thrown. Released
UserNetwork is deleted.
@cmview_user
@param_post{network_id}
"""
user = User.get(caller_id)
try:
user_network = UserNetwork.objects.filter(user=user).get(id=network_id)
except:
raise CMException('network_not_found')
if user_network.is_in_use():
raise CMException('network_in_use')
user_network.release()
user_network.delete()
def release(caller_id, public_ip_id):
"""
Removes PublicIP from caller's pool and returns it to publicly available
pool, provided PublicIP isn't in use.
@note There's very low probability of obtaining the same PublicIP address
once again.
@cmview_user
@param_post{public_ip_id,int} id of the PublicIP to release
"""
user = User.get(caller_id)
public_lease = PublicIP.objects.filter(user=user).get(id=public_ip_id)
if public_lease.lease:
raise CMException('public_lease_assigned')
public_lease.user = None
public_lease.save()
def download(caller_id, name, description, path, disk_controller):
"""
Downloads specified IsoImage and saves it with specified name and description.
@cmview_user
@param_post{name,string}
@param_post{description,string}
@param_post{path,string} HTTP or FTP path to IsoImage to download
@param_post{disk_controller}
"""
user = User.get(caller_id)
if not any([
path.startswith('http://'),
path.startswith('https://'),
path.startswith('ftp://')
]):
path = 'http://' + path.strip()
# size value is taken
try:
connection = urllib.urlopen(path)
size = int(connection.info()["Content-Length"])
except IOError:
log.exception('Cannot find image')
raise CMException('image_not_found')
except KeyError:
log.exception(caller_id, 'Cannot calculate size')
raise CMException('image_calculate_size')
user.check_storage(size / (1024 * 1024))
image = IsoImage.create(user=user,
description=description,
name=name,
disk_controller=disk_controller,
disk_dev=1)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
def first_admin_add(caller_id, new_password, clm_address):
"""
Creates first admin of the cluster. It should be called right after
submiting the form for adding new CM. System will not operate properly
with no CM admin existing.
@note It can be run only if no CM admin exists in the CM database.
@cmview_user
@param_post{new_password,string} first *CM admin password* to set
@param_post{clm_address,string}
"""
user = User.create(1)
user.save()
# creates a new admin, which is the caller
admin = Admin()
admin.user = user
admin.password = new_password
try:
admin.save()
except:
raise CMException('admin_add')
# Update config and setup CLM address
try:
lines = []
config = open('/usr/lib/cc1/cm/config.py', 'r')
for line in config.readlines():
if line.startswith('CLM_ADDRESS') and 'NOT_CONFIGURED' in line:
lines.append('CLM_ADDRESS = "https://%s:8000/"\n' %
clm_address)
else:
lines.append(line)
config.close()
config = open('/usr/lib/cc1/cm/config.py', 'w')
config.write(''.join(lines))
config.close()
except:
log.exception(caller_id, 'config_update')
raise CMException('config_update')
def download(caller_id, description, name, path, disk_controller,
network_device, platform, video_device):
"""
Downloads specified SystemImage.
@cmview_admin_cm
@param_post{description,string}
@param_post{name,string}
@param_post{path,string} HTTP or FTP path to image to download
@param_post{disk_controller}
@param_post{network_device}
@param_post{platform}
@param_post{video_device}
"""
# size value is taken
try:
connection = urllib.urlopen(path)
size = int(connection.info()["Content-Length"])
except IOError:
log.exception(caller_id, 'Cannot find image')
raise CMException('image_not_found')
except KeyError:
log.exception(caller_id, 'Cannot calculate size')
raise CMException('image_calculate_size')
user = User.get(caller_id)
image = SystemImage.create(name=name,
description=description,
user=user,
platform=platform,
disk_controller=disk_controller,
network_device=network_device,
video_device=video_device)
try:
image.save()
except Exception, e:
log.error(caller_id, "Unable to save image to DB: %s" % str(e))
raise CMException('image_create')
def assign(caller_id, lease_id, public_ip_id):
"""
Method attaches caller's PublicIP to his VM. VM's Lease instance's is
assigned to PublicIP.
@cmview_user
@param_post{lease_id} id of the Lease in caller's UserNetwork
@param_post{public_ip_id} id of the Public_IP to be attached to VM
@raises{lease_not_found,CMException}
@raises{lease_not_assigned,CMException}
@raises{public_lease_assign,CMException}
"""
user = User.get(caller_id)
try:
lease = Lease.objects.filter(user_network__user=user).get(id=lease_id)
public_ip = PublicIP.objects.filter(user=user).get(id=public_ip_id)
except Exception, e:
log.exception(caller_id, str(e))
raise CMException("lease_not_found")
def copy(caller_id, src_image_id, dest_user_id):
"""
Copy selected image to user's images
@cmview_admin_cm
@param_post{src_image_id,int}
@param_post{dest_user_id,int}
"""
src_image = SystemImage.admin_get(src_image_id)
dest_user = User.get(dest_user_id)
dest_image = SystemImage.create(name=src_image.name,
description=src_image.description,
user=dest_user,
platform=src_image.platform,
disk_controller=src_image.disk_controller,
network_device=src_image.network_device,
video_device=src_image.video_device)
try:
dest_image.save()
except Exception, e:
log.error(caller_id, "Unable to commit: %s" % str(e))
raise CMException('image_create')
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]
