Levi Velázquez
GitHub
commit
68c0a6cec6
7 changed files with 108 additions and 613 deletions
|
|
@ -7,7 +7,6 @@ import oca
|
|||
from django.db import models
|
||||
from django.utils.translation import ugettext_lazy as _
|
||||
from django.utils.functional import cached_property
|
||||
from hosting.opennebula_functions import OpenNebulaManager
|
||||
|
||||
from django.conf import settings
|
||||
|
||||
|
|
@ -18,8 +17,6 @@ from membership.models import StripeCustomer, CustomUser
|
|||
from utils.models import BillingAddress
|
||||
from utils.mixins import AssignPermissionsMixin
|
||||
from .managers import VMPlansManager
|
||||
from oca.exceptions import OpenNebulaException
|
||||
from oca.pool import WrongNameError
|
||||
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
|
|
|||
|
|
@ -1,567 +0,0 @@
|
|||
import logging
|
||||
import random
|
||||
import socket
|
||||
import string
|
||||
|
||||
import oca
|
||||
from django.conf import settings
|
||||
from django.conf.urls import url
|
||||
from django.contrib import admin
|
||||
from django.contrib import messages
|
||||
from django.shortcuts import redirect
|
||||
from django.template.response import TemplateResponse
|
||||
from django.utils.translation import ugettext_lazy as _
|
||||
from oca.exceptions import OpenNebulaException
|
||||
from oca.pool import WrongNameError
|
||||
|
||||
from django import forms
|
||||
# Get an instance of a logger
|
||||
logger = logging.getLogger(__name__)
|
||||
|
||||
|
||||
class OpenNebulaManager:
|
||||
|
||||
VM_STATE = {
|
||||
'0': 'INIT',
|
||||
'1': 'PENDING',
|
||||
'2': 'HOLD',
|
||||
'3': 'ACTIVE',
|
||||
'4': 'STOPPED',
|
||||
'5': 'SUSPENDED',
|
||||
'6': 'DONE',
|
||||
'8': 'POWEROFF',
|
||||
'9': 'UNDEPLOYED',
|
||||
'10': 'CLONING',
|
||||
'11': 'CLONING_FAILURE',
|
||||
}
|
||||
|
||||
def __init__(self, email=None, password=None):
|
||||
|
||||
# Get oneadmin client
|
||||
self.oneadmin_client = self._get_opennebula_client(
|
||||
settings.OPENNEBULA_USERNAME,
|
||||
settings.OPENNEBULA_PASSWORD
|
||||
)
|
||||
|
||||
# Get or create oppenebula user using given credentials
|
||||
self.opennebula_user = self._get_or_create_user(
|
||||
email,
|
||||
password
|
||||
)
|
||||
|
||||
# If opennebula user was created/obtained, get his client
|
||||
if self.opennebula_user:
|
||||
self.client = self._get_opennebula_client(
|
||||
email,
|
||||
password
|
||||
)
|
||||
|
||||
def _get_opennebula_client(self, username, password):
|
||||
return oca.Client("{0}:{1}".format(
|
||||
username,
|
||||
password),
|
||||
"{protocol}://{domain}:{port}{endpoint}".format(
|
||||
protocol=settings.OPENNEBULA_PROTOCOL,
|
||||
domain=settings.OPENNEBULA_DOMAIN,
|
||||
port=settings.OPENNEBULA_PORT,
|
||||
endpoint=settings.OPENNEBULA_ENDPOINT
|
||||
))
|
||||
|
||||
def _get_or_create_user(self, email, password):
|
||||
try:
|
||||
user_pool = oca.UserPool(self.oneadmin_client)
|
||||
user_pool.info()
|
||||
opennebula_user = user_pool.get_by_name(email)
|
||||
return opennebula_user
|
||||
except WrongNameError as wrong_name_err:
|
||||
# TODO: Store this password so that we can use it later to
|
||||
# connect to opennebula
|
||||
opennebula_user = self.oneadmin_client.call(oca.User.METHODS['allocate'], email,
|
||||
password, 'core')
|
||||
logger.debug(
|
||||
"User {0} does not exist. Created the user. User id = {1}",
|
||||
email,
|
||||
opennebula_user
|
||||
)
|
||||
return opennebula_user
|
||||
except OpenNebulaException as err:
|
||||
logger.error("Error : {0}".format(err))
|
||||
|
||||
@classmethod
|
||||
def get_vm_state(self, state):
|
||||
return self.VM_STATE.get(str(state))
|
||||
|
||||
@classmethod
|
||||
def parse_vm(self, vm):
|
||||
name = vm.name
|
||||
cores = int(vm.template.vcpu)
|
||||
memory = int(vm.template.memory) / 1024
|
||||
# Check if vm has more than one disk
|
||||
if 'DISK' in vm.template.multiple:
|
||||
disk_size = 0
|
||||
for disk in vm.template.disks:
|
||||
disk_size += int(disk.size) / 1024
|
||||
else:
|
||||
disk_size = int(vm.template.disk.size) / 1024
|
||||
|
||||
#TODO: Replace with vm plan
|
||||
price = 0.6 * disk_size + 2 * memory + 5 * cores
|
||||
vm_data = {}
|
||||
vm_data['name'] = name
|
||||
vm_data['price'] = price
|
||||
vm_data['disk_size'] = disk_size
|
||||
vm_data['cores'] = cores
|
||||
vm_data['memory'] = memory
|
||||
vm_data['deploy_id'] = vm.deploy_id
|
||||
vm_data['id'] = vm.id
|
||||
vm_data['state'] = self.get_vm_state(vm.state)
|
||||
|
||||
return vm_data
|
||||
|
||||
def change_user_password(self, new_password):
|
||||
self.oneadmin_client.call(
|
||||
oca.User.METHODS['passwd'],
|
||||
self.opennebula_user.id,
|
||||
new_password
|
||||
)
|
||||
|
||||
def create_vm(self, specs):
|
||||
vm_id = None
|
||||
try:
|
||||
|
||||
# We do have the vm_template param set. Get and parse it
|
||||
# and check it to be in the desired range.
|
||||
# We have 8 possible VM templates for the moment which are 1x, 2x, 4x ...
|
||||
# the basic template of 10GB disk, 1GB ram, 1 vcpu, 0.1 cpu
|
||||
vm_string_formatter = """<VM>
|
||||
<MEMORY>{memory}</MEMORY>
|
||||
<VCPU>{vcpu}</VCPU>
|
||||
<CPU>{cpu}</CPU>
|
||||
<DISK>
|
||||
<TYPE>{disk_type}</TYPE>
|
||||
<SIZE>{size}</SIZE>
|
||||
</DISK>
|
||||
<CONTEXT>
|
||||
<SSH_PUBLIC_KEY>{ssh_key}</SSH_PUBLIC_KEY>
|
||||
</CONTEXT>
|
||||
</VM>
|
||||
"""
|
||||
vm_id = oca.VirtualMachine.allocate(
|
||||
self.oneadmin_client,
|
||||
vm_string_formatter.format(
|
||||
memory=1024 * specs.get('memory'),
|
||||
vcpu=specs.get('cores'),
|
||||
cpu=0.1 * specs.get('cores'),
|
||||
disk_type='fs',
|
||||
size=10000 * specs.get('disk_size'),
|
||||
ssh_key=specs.get('ssh_key')
|
||||
)
|
||||
)
|
||||
|
||||
self.oneadmin_client.call(
|
||||
oca.VirtualMachine.METHODS['chown'],
|
||||
vm_id,
|
||||
self.opennebula_user.id,
|
||||
self.opennebula_user.group_ids[0]
|
||||
)
|
||||
|
||||
except socket.timeout as socket_err:
|
||||
logger.error("Socket timeout error: {0}".format(socket_err))
|
||||
except OpenNebulaException as opennebula_err:
|
||||
logger.error("OpenNebulaException error: {0}".format(opennebula_err))
|
||||
except OSError as os_err:
|
||||
logger.error("OSError : {0}".format(os_err))
|
||||
except ValueError as value_err:
|
||||
logger.error("ValueError : {0}".format(value_err))
|
||||
|
||||
return vm_id
|
||||
|
||||
def terminate_vm(self, vm_id):
|
||||
|
||||
TERMINATE_ACTION = 'terminate'
|
||||
vm_terminated = False
|
||||
|
||||
try:
|
||||
self.oneadmin_client.call(
|
||||
oca.VirtualMachine.METHODS['action'],
|
||||
TERMINATE_ACTION,
|
||||
int(vm_id),
|
||||
)
|
||||
vm_terminated = True
|
||||
except socket.timeout as socket_err:
|
||||
logger.error("Socket timeout error: {0}".format(socket_err))
|
||||
except OpenNebulaException as opennebula_err:
|
||||
logger.error("OpenNebulaException error: {0}".format(opennebula_err))
|
||||
except OSError as os_err:
|
||||
logger.error("OSError : {0}".format(os_err))
|
||||
except ValueError as value_err:
|
||||
logger.error("ValueError : {0}".format(value_err))
|
||||
|
||||
return vm_terminated
|
||||
|
||||
def get_vm_templates(self):
|
||||
template_pool = oca.VmTemplatePool(self.oneadmin_client)
|
||||
template_pool.info()
|
||||
return template_pool
|
||||
|
||||
def get_vm(self, email, vm_id):
|
||||
# Get vm's
|
||||
vms = self.get_vms(email)
|
||||
|
||||
# Filter vm by given id
|
||||
return vms.get_by_id(int(vm_id))
|
||||
|
||||
def get_vms(self, email):
|
||||
client = self.oneadmin_client
|
||||
|
||||
# Get open nebula user id for given email
|
||||
user_pool = oca.UserPool(client)
|
||||
user_pool.info()
|
||||
|
||||
# TODO: handle potential name error
|
||||
user_id = user_pool.get_by_name(email).id
|
||||
|
||||
# Get vm_pool for given user_id
|
||||
vm_pool = oca.VirtualMachinePool(client)
|
||||
vm_pool.info()
|
||||
|
||||
# TODO: this is just to test with oneadmin user, remove this
|
||||
# user_id = 0
|
||||
vm_pool.info(filter=user_id)
|
||||
|
||||
return vm_pool
|
||||
|
||||
class HostingManageVMAdmin(admin.ModelAdmin):
|
||||
client = None
|
||||
oneadmin_client = None
|
||||
|
||||
def get_urls(self):
|
||||
urls = super().get_urls()
|
||||
my_urls = [
|
||||
url(r'^$', self.admin_site.admin_view(self.show_vms, cacheable=True), name='showvms'),
|
||||
url(r'^create_vm/$', self.admin_site.admin_view(self.create_vm, cacheable=True), name='createvm'),
|
||||
url(r'^delete_vm/(?P<vmid>\d+)/$', self.admin_site.admin_view(self.delete_vm, cacheable=True),
|
||||
name='deletevm'),
|
||||
url(r'^stop_vm/(?P<vmid>\d+)/$', self.admin_site.admin_view(self.stop_vm, cacheable=True), name='stopvm'),
|
||||
url(r'^start_vm/(?P<vmid>\d+)/$', self.admin_site.admin_view(self.start_vm, cacheable=True),
|
||||
name='startvm'),
|
||||
]
|
||||
return my_urls + urls
|
||||
|
||||
# Function to initialize opennebula client based on the logged in
|
||||
# user
|
||||
def init_opennebula_client(self, request):
|
||||
if self.oneadmin_client is None:
|
||||
self.oneadmin_client = oca.Client("{0}:{1}".format(settings.OPENNEBULA_USERNAME,
|
||||
settings.OPENNEBULA_PASSWORD),
|
||||
"{protocol}://{domain}:{port}{endpoint}".format(
|
||||
protocol=settings.OPENNEBULA_PROTOCOL,
|
||||
domain=settings.OPENNEBULA_DOMAIN,
|
||||
port=settings.OPENNEBULA_PORT,
|
||||
endpoint=settings.OPENNEBULA_ENDPOINT
|
||||
))
|
||||
logger.debug("{0}:{1}".format(settings.OPENNEBULA_USERNAME,
|
||||
settings.OPENNEBULA_PASSWORD))
|
||||
logger.debug("{protocol}://{domain}:{port}{endpoint}".format(
|
||||
protocol=settings.OPENNEBULA_PROTOCOL,
|
||||
domain=settings.OPENNEBULA_DOMAIN,
|
||||
port=settings.OPENNEBULA_PORT,
|
||||
endpoint=settings.OPENNEBULA_ENDPOINT
|
||||
))
|
||||
self.create_opennebula_user(request)
|
||||
if self.client is None:
|
||||
opennebula_user = request.user.email
|
||||
# TODO: get the password stored in django
|
||||
opennebula_user_password ='19737450'
|
||||
self.client = oca.Client("{0}:{1}".format(opennebula_user, opennebula_user_password),
|
||||
"{protocol}://{domain}:{port}{endpoint}".format(
|
||||
protocol=settings.OPENNEBULA_PROTOCOL,
|
||||
domain=settings.OPENNEBULA_DOMAIN,
|
||||
port=settings.OPENNEBULA_PORT,
|
||||
endpoint=settings.OPENNEBULA_ENDPOINT
|
||||
))
|
||||
|
||||
# Function that shows the VMs of the current user
|
||||
def show_vms(self, request):
|
||||
vm_pool = None
|
||||
try:
|
||||
self.init_opennebula_client(request)
|
||||
vm_pool = oca.VirtualMachinePool(self.client)
|
||||
vm_pool.info()
|
||||
except socket.timeout:
|
||||
messages.add_message(request, messages.ERROR, _("Socket timeout error."))
|
||||
except OpenNebulaException as opennebula_err:
|
||||
messages.add_message(request, messages.ERROR, _("OpenNebulaException occurred. {0}".format(opennebula_err)))
|
||||
except OSError as err:
|
||||
messages.add_message(request, messages.ERROR, "OS error: {0}".format(err))
|
||||
context = dict(
|
||||
# Include common variables for rendering the admin template.
|
||||
self.admin_site.each_context(request),
|
||||
vms=vm_pool,
|
||||
form=HostingManageVMForm
|
||||
)
|
||||
return TemplateResponse(request, "hosting/managevms.html", context)
|
||||
|
||||
# Function that shows the VMs of the current user
|
||||
def show_vms_view(self, request):
|
||||
"""
|
||||
Implemented by Levi for the API
|
||||
"""
|
||||
vm_pool = None
|
||||
try:
|
||||
self.init_opennebula_client(request)
|
||||
vm_pool = oca.VirtualMachinePool(self.client)
|
||||
vm_pool.info()
|
||||
except socket.timeout as socket_err:
|
||||
logger.error("Socket timeout error.".format(socket_err))
|
||||
except OpenNebulaException as opennebula_err:
|
||||
logger.error("OpenNebulaException error: {0}".format(opennebula_err))
|
||||
except OSError as os_err:
|
||||
logger.error("OSError : {0}".format(os_err))
|
||||
except ValueError as value_err:
|
||||
logger.error("ValueError : {0}".format(value_err))
|
||||
context = dict(
|
||||
# Include common variables for rendering the admin template.
|
||||
# self.admin_site.each_context(request),
|
||||
vms=vm_pool,
|
||||
)
|
||||
return context
|
||||
|
||||
|
||||
def create_vm_view(self, specs):
|
||||
vm_id = None
|
||||
try:
|
||||
# We do have the vm_template param set. Get and parse it
|
||||
# and check it to be in the desired range.
|
||||
# We have 8 possible VM templates for the moment which are 1x, 2x, 4x ...
|
||||
# the basic template of 10GB disk, 1GB ram, 1 vcpu, 0.1 cpu
|
||||
vm_string_formatter = """<VM>
|
||||
<MEMORY>{memory}</MEMORY>
|
||||
<VCPU>{vcpu}</VCPU>
|
||||
<CPU>{cpu}</CPU>
|
||||
<DISK>
|
||||
<TYPE>{disk_type}</TYPE>
|
||||
<SIZE>{size}</SIZE>
|
||||
</DISK>
|
||||
</VM>
|
||||
"""
|
||||
vm_id = oca.VirtualMachine.allocate(
|
||||
self.client,
|
||||
vm_string_formatter.format(
|
||||
memory=1024 * specs.get('memory'),
|
||||
vcpu=specs.get('cores'),
|
||||
cpu=0.1 * specs.get('cores'),
|
||||
disk_type='fs',
|
||||
size=10000 * specs.get('disk_size')
|
||||
)
|
||||
)
|
||||
# message = _("Created with id = " + str(vm_id))
|
||||
# messages.add_message(request, messages.SUCCESS, message)
|
||||
except socket.timeout as socket_err:
|
||||
logger.error("Socket timeout error: {0}".format(socket_err))
|
||||
except OpenNebulaException as opennebula_err:
|
||||
logger.error("OpenNebulaException error: {0}".format(opennebula_err))
|
||||
except OSError as os_err:
|
||||
logger.error("OSError : {0}".format(os_err))
|
||||
except ValueError as value_err:
|
||||
logger.error("ValueError : {0}".format(value_err))
|
||||
|
||||
return vm_id
|
||||
|
||||
|
||||
|
||||
# Creating VM by using method allocate(client, template)
|
||||
def create_vm(self, request):
|
||||
# check if the request contains the template parameter, if it is
|
||||
# not set warn the user of setting this.
|
||||
vm_template = request.POST.get('vm_template')
|
||||
if vm_template == 'select':
|
||||
messages.add_message(request, messages.ERROR, "Please select a vm template")
|
||||
else:
|
||||
try:
|
||||
# We do have the vm_template param set. Get and parse it
|
||||
# and check it to be in the desired range.
|
||||
# We have 8 possible VM templates for the moment which are 1x, 2x, 4x ...
|
||||
# the basic template of 10GB disk, 1GB ram, 1 vcpu, 0.1 cpu
|
||||
vm_template_int = int(vm_template)
|
||||
if 1 <= vm_template_int <= 8:
|
||||
vm_string_formatter = """<VM>
|
||||
<CONTEXT>
|
||||
<SSH_PUBLIC_KEY>
|
||||
{ssh_key}
|
||||
</SSH_PUBLIC_KEY>
|
||||
</CONTEXT>
|
||||
<MEMORY>{memory}</MEMORY>
|
||||
<VCPU>{vcpu}</VCPU>
|
||||
<CPU>{cpu}</CPU>
|
||||
<DISK>
|
||||
<TYPE>{disk_type}</TYPE>
|
||||
<SIZE>{size}</SIZE>
|
||||
<DEV_PREFIX>{dev_prefix}</DEV_PREFIX>
|
||||
</DISK>
|
||||
</VM>
|
||||
"""
|
||||
vm_id = oca.VirtualMachine.allocate(self.client,
|
||||
vm_string_formatter.format(
|
||||
ssh_key='', # public key of the user
|
||||
memory=1024 * vm_template_int, # memory in MB
|
||||
vcpu=vm_template_int, # vpcu
|
||||
cpu=0.1 * vm_template_int, # cpu
|
||||
disk_type='fs',
|
||||
size=10000 * vm_template_int,
|
||||
dev_prefix='vd')) # We need KVM virtual disk
|
||||
message = _("Created with id = " + str(vm_id))
|
||||
messages.add_message(request, messages.SUCCESS, message)
|
||||
else:
|
||||
messages.add_message(request, messages.ERROR,
|
||||
_("Please select an appropriate value for vm template."))
|
||||
except socket.timeout as socket_err:
|
||||
messages.add_message(request, messages.ERROR, _("Socket timeout error."))
|
||||
logger.error("Socket timeout error: {0}".format(socket_err))
|
||||
except OpenNebulaException as opennebula_err:
|
||||
messages.add_message(request, messages.ERROR,
|
||||
_("OpenNebulaException occurred. {0}".format(opennebula_err)))
|
||||
logger.error("OpenNebulaException error: {0}".format(opennebula_err))
|
||||
except OSError as os_err:
|
||||
messages.add_message(request, messages.ERROR, _("OS error: {0}".format(os_err)))
|
||||
logger.error("OSError : {0}".format(os_err))
|
||||
except ValueError as value_err:
|
||||
messages.add_message(request, messages.ERROR,
|
||||
_("Please select an appropriate value for vm template."))
|
||||
logger.error("ValueError : {0}".format(value_err))
|
||||
return redirect('admin:showvms')
|
||||
|
||||
# Delete VM from the pool and DB by using method finalize()
|
||||
def delete_vm(self, request, vmid):
|
||||
vm_id = int(vmid)
|
||||
# get the desired vm from the pool
|
||||
logger.debug("Deleting vm with id {0}".format(vm_id))
|
||||
vm = self.get_vm_by_id(vm_id)
|
||||
if vm is None:
|
||||
messages.add_message(request, messages.ERROR, _("Did not find a vm with id = {0}".format(vm_id)))
|
||||
else:
|
||||
logger.debug("Deleting vm_id = " + str(vm_id) + " state = " + vm.str_state)
|
||||
if vm.str_state == 'PENDING' or vm.str_state == 'POWEROFF' or vm.str_state == 'ACTIVE':
|
||||
vm.delete()
|
||||
messages.add_message(request, messages.SUCCESS,
|
||||
_("Deleted from {0} state vm with id = {1}".format(vm.str_state, str(vm_id))))
|
||||
else:
|
||||
vm.finalize()
|
||||
messages.add_message(request, messages.SUCCESS,
|
||||
_("Deleted (using finalize()) from {0} state vm with id = {1}".format(vm.str_state,
|
||||
str(vm_id))))
|
||||
return redirect('admin:showvms')
|
||||
|
||||
def stop_vm(self, request, vmid):
|
||||
vm_id = int(vmid)
|
||||
vm = self.get_vm_by_id(vm_id)
|
||||
if vm is None:
|
||||
messages.add_message(request, messages.ERROR, _("Did not find a vm with id = {0}", vm_id))
|
||||
else:
|
||||
vm.stop()
|
||||
messages.add_message(request, messages.SUCCESS, _("Stopped the vm with id = {0}", vm_id))
|
||||
return redirect('admin:showvms')
|
||||
|
||||
def start_vm(self, request, vmid):
|
||||
vm_id = int(vmid)
|
||||
vm = self.get_vm_by_id(vm_id)
|
||||
if vm is None:
|
||||
messages.add_message(request, messages.ERROR, _("Did not find a vm with id = {0}", vm_id))
|
||||
else:
|
||||
vm.resume()
|
||||
messages.add_message(request, messages.SUCCESS, _("Started the vm with id = {0}", vm_id))
|
||||
return redirect('admin:showvms')
|
||||
|
||||
# Retrives virtual machine pool information
|
||||
def get_vm_pool(self):
|
||||
vm_pool = oca.VirtualMachinePool(self.client)
|
||||
vm_pool.info()
|
||||
return vm_pool
|
||||
|
||||
def get_vm_by_id(self, vmid):
|
||||
vm_pool = self.get_vm_pool()
|
||||
return vm_pool.get_by_id(vmid)
|
||||
|
||||
def create_opennebula_user(self, request):
|
||||
# Notes:
|
||||
# 1. python-oca library's oca.User.allocate(client, user, pass)
|
||||
# method does not work with python-oca version oca-4.15.0a1-py3.5
|
||||
# This is because the call is missing a fourth parameter
|
||||
# auth_driver.
|
||||
# To overcome this issue, we make a direct call to xml-rpc method
|
||||
# 'user.allocate' passing this fourth parameter.
|
||||
#
|
||||
# 2. We have a dummy authentication driver in opennebula and we
|
||||
# use this so as to avoid opennebula authentication. However, we
|
||||
# need to supply a dummy password. Without this, we can not
|
||||
# create an OpenNebula user. We use dummy string 'a' as password
|
||||
# for all users.
|
||||
#
|
||||
# 3. We user the user's email as the user name.
|
||||
# 4. If the user's email is not registered with OpenNebula,
|
||||
# WrongNameError is raised. We create an OpenNebula user in
|
||||
# such case.
|
||||
try:
|
||||
user_pool = oca.UserPool(self.oneadmin_client)
|
||||
user_pool.info()
|
||||
opennebula_user = user_pool.get_by_name(request.user.email)
|
||||
logger.debug("User {0} exists. User id = {1}".format(request.user.email, opennebula_user.id))
|
||||
except WrongNameError as wrong_name_err:
|
||||
# TODO: Store this password so that we can use it later to
|
||||
# connect to opennebula
|
||||
password = get_random_password()
|
||||
oca.User.allocate(self.oneadmin_client, request.user.email, password)
|
||||
logger.debug("User {0} does not exist. Created the user. User id = {1}", request.user.email, user_id)
|
||||
except OpenNebulaException as err:
|
||||
messages.add_message(request, messages.ERROR,
|
||||
"Error : {0}".format(err))
|
||||
logger.error("Error : {0}".format(err))
|
||||
|
||||
def set_field_html_name(cls, new_name):
|
||||
"""
|
||||
This creates wrapper around the normal widget rendering,
|
||||
allowing for a custom field name (new_name).
|
||||
"""
|
||||
old_render = cls.widget.render
|
||||
def _widget_render_wrapper(name, value, attrs=None):
|
||||
return old_render(new_name, value, attrs)
|
||||
cls.widget.render = _widget_render_wrapper
|
||||
|
||||
class HostingManageVMForm(forms.Form):
|
||||
vm_templates = []
|
||||
VM_CHOICES = (('1', 'disk = 10GB, vcpu=1, ram=1GB'),
|
||||
('2', 'disk = 20GB, vcpu=2, ram=2GB'),
|
||||
('3', 'disk = 40GB, vcpu=4, ram=4GB'),
|
||||
('4', 'disk = 80GB, vcpu=8, ram=8GB'),
|
||||
('5', 'disk = 160GB, vcpu=16, ram=16GB'),
|
||||
('6', 'disk = 320GB, vcpu=32, ram=32GB'),
|
||||
('7', 'disk = 640GB, vcpu=64, ram=64GB'),
|
||||
('8', 'disk = 1280GB, vcpu=128, ram=128GB'))
|
||||
#for i in range(0,8):
|
||||
# factor = pow(2, i)
|
||||
# vm_templates.append(VMTemplate(i, VM_CHOICES[i], 10000 * factor, factor , 0.1 * factor, 1024 * factor))
|
||||
field = forms.ChoiceField(label="Choose a VM Template ", choices=VM_CHOICES, widget=forms.Select(attrs={"id": "vm_template"}))
|
||||
set_field_html_name(field, 'vm_template')
|
||||
|
||||
|
||||
|
||||
class VMTemplate:
|
||||
"""A simple representation of a VM template.
|
||||
|
||||
:param template_id: The id of the template
|
||||
:param label: A string representation describing the template. Used as the label in view
|
||||
:param disk: VM disk space in MB
|
||||
:param vcpu: Virtual cpu for the VM
|
||||
:param cpu: CPU for the VM
|
||||
:param ram: The RAM for the VM
|
||||
"""
|
||||
def __init__(self, template_id, label, disk, vcpu, cpu, ram):
|
||||
self.template_id = template_id
|
||||
self.label = label
|
||||
self.disk = disk
|
||||
self.vcpu = vcpu
|
||||
self.cpu = cpu
|
||||
|
||||
# Returns random password that is needed by OpenNebula
|
||||
def get_random_password():
|
||||
return ''.join(random.SystemRandom().choice(string.ascii_uppercase + string.digits) for _ in range(20))
|
||||
|
|
@ -24,16 +24,16 @@
|
|||
{% endfor %}
|
||||
</select>
|
||||
</div>
|
||||
<!-- <div class="form-group">
|
||||
<div class="form-group">
|
||||
Select VM Configuration:
|
||||
<select name="configuration">
|
||||
{% for config in configuration_options %}
|
||||
<select name="vm_image_id">
|
||||
{% for image in images %}
|
||||
|
||||
<option value="{{config.0}}">{{config.1}} </option>
|
||||
<option value="{{image.id}}">{{image.name}} </option>
|
||||
|
||||
{% endfor %}
|
||||
</select>
|
||||
</div> -->
|
||||
</div>
|
||||
<div class="form-group">
|
||||
<button class="btn btn-success" >{% trans "Start VM"%} </button>
|
||||
</div>
|
||||
|
|
|
|||
|
|
@ -31,7 +31,9 @@ from .mixins import ProcessVMSelectionMixin
|
|||
|
||||
from opennebula_api.models import OpenNebulaManager
|
||||
from opennebula_api.serializers import VirtualMachineSerializer,\
|
||||
VirtualMachineTemplateSerializer
|
||||
VirtualMachineTemplateSerializer,\
|
||||
ImageSerializer
|
||||
|
||||
|
||||
from oca.exceptions import OpenNebulaException
|
||||
from oca.pool import WrongNameError
|
||||
|
|
@ -392,6 +394,7 @@ class PaymentVMView(LoginRequiredMixin, FormView):
|
|||
specifications = request.session.get('template')
|
||||
|
||||
vm_template_id = specifications.get('id', 1)
|
||||
vm_image_id = request.session.get('image').get('id', 1)
|
||||
|
||||
final_price = specifications.get('price', 1)
|
||||
|
||||
|
|
@ -428,8 +431,6 @@ class PaymentVMView(LoginRequiredMixin, FormView):
|
|||
# Create OpenNebulaManager
|
||||
manager = OpenNebulaManager(email=owner.email,
|
||||
password=owner.password)
|
||||
template = manager.get_template(vm_template_id)
|
||||
|
||||
# Get user ssh key
|
||||
try:
|
||||
user_key = UserHostingKey.objects.get(
|
||||
|
|
@ -441,8 +442,9 @@ class PaymentVMView(LoginRequiredMixin, FormView):
|
|||
|
||||
# Create a vm using logged user
|
||||
vm_id = manager.create_vm(
|
||||
vm_template_id,
|
||||
ssh_key=user_key.public_key
|
||||
template_id=vm_template_id,
|
||||
ssh_key=user_key.public_key,
|
||||
image_id=vm_image_id,
|
||||
)
|
||||
|
||||
# Create a Hosting Order
|
||||
|
|
@ -567,21 +569,24 @@ class CreateVirtualMachinesView(LoginRequiredMixin, View):
|
|||
)
|
||||
return HttpResponseRedirect(reverse('hosting:key_pair'))
|
||||
|
||||
#TODO: Replace with OpenNebulaManager.get_apps
|
||||
templates = OpenNebulaManager().get_templates()
|
||||
data = VirtualMachineTemplateSerializer(templates, many=True).data
|
||||
manager = OpenNebulaManager()
|
||||
templates = manager.get_templates()
|
||||
images = manager.get_images()
|
||||
|
||||
context = {
|
||||
'templates': data,
|
||||
'templates': VirtualMachineTemplateSerializer(templates, many=True).data,
|
||||
'images' : ImageSerializer(images, many=True).data
|
||||
}
|
||||
# context = {}
|
||||
return render(request, self.template_name, context)
|
||||
|
||||
def post(self, request):
|
||||
template_id = int(request.POST.get('vm_template_id'))
|
||||
template = OpenNebulaManager().get_template(template_id)
|
||||
data = VirtualMachineTemplateSerializer(template).data
|
||||
request.session['template'] = data
|
||||
manager = OpenNebulaManager()
|
||||
template_id = request.POST.get('vm_template_id')
|
||||
template = manager.get_template(template_id)
|
||||
image_id = request.POST.get('vm_image_id')
|
||||
image = manager.get_image(image_id)
|
||||
request.session['template'] = VirtualMachineTemplateSerializer(template).data
|
||||
request.session['image'] = ImageSerializer(image).data
|
||||
return redirect(reverse('hosting:payment'))
|
||||
|
||||
|
||||
|
|
|
|||
|
|
@ -102,23 +102,43 @@ class OpenNebulaManager():
|
|||
return []
|
||||
|
||||
def get_vm(self, vm_id):
|
||||
vm_id = int(vm_id)
|
||||
try:
|
||||
vm_pool = self._get_vm_pool()
|
||||
return vm_pool.get_by_id(int(vm_id))
|
||||
return vm_pool.get_by_id(vm_id)
|
||||
except:
|
||||
return None
|
||||
|
||||
#TODO: get app with id
|
||||
def create_vm(self, template_id, app_id=None, ssh_key=None):
|
||||
extra_template = "<CONTEXT><SSH_PUBLIC_KEY>{ssh_key}</SSH_PUBLIC_KEY></CONTEXT>".format(
|
||||
ssh_key=ssh_key
|
||||
def create_vm(self, template_id, image_id=None, ssh_key=None):
|
||||
extra_template_formater = """<CONTEXT>
|
||||
<SSH_PUBLIC_KEY>{ssh_key}</SSH_PUBLIC_KEY>
|
||||
</CONTEXT>
|
||||
<DISK>
|
||||
<IMAGE_ID>{image_id}</IMAGE_ID>
|
||||
</DISK>
|
||||
"""
|
||||
|
||||
template = self.get_template(template_id)
|
||||
vm_id = template.instantiate(name ='', pending=False, extra_template='')
|
||||
image = self.get_image(image_id)
|
||||
|
||||
image_name = "{image_name}{template_name}{vm_id}".format(
|
||||
image_name=image.name,
|
||||
template_name=template.name,
|
||||
vm_id = vm_id,
|
||||
)
|
||||
vm_id = self.oneadmin_client.call(
|
||||
oca.VmTemplate.METHODS['instantiate'],
|
||||
template_id,
|
||||
'',
|
||||
False,
|
||||
extra_template
|
||||
|
||||
image_id = image.clone(name=image_name)
|
||||
|
||||
self.oneadmin_client.call(
|
||||
oca.VmTemplate.METHODS['update'],
|
||||
vm_id,
|
||||
extra_template_formater.format(
|
||||
ssh_key=ssh_key,
|
||||
image_id=image_id
|
||||
),
|
||||
# 0 = Replace / 1 = Merge
|
||||
1,
|
||||
)
|
||||
try:
|
||||
self.oneadmin_client.call(
|
||||
|
|
@ -177,8 +197,12 @@ class OpenNebulaManager():
|
|||
return []
|
||||
|
||||
def get_template(self, template_id):
|
||||
template_id = int(template_id)
|
||||
try:
|
||||
template_pool = self._get_template_pool()
|
||||
return template_pool.get_by_id(template_id)
|
||||
except:
|
||||
return None
|
||||
|
||||
|
||||
|
||||
|
|
@ -238,3 +262,38 @@ class OpenNebulaManager():
|
|||
self.opennebula_user.id,
|
||||
new_password
|
||||
)
|
||||
|
||||
|
||||
def _get_image_pool(self):
|
||||
try:
|
||||
image_pool = oca.ImagePool(self.oneadmin_client)
|
||||
image_pool.info()
|
||||
#TODO: Replace with logger
|
||||
except ConnectionRefusedError:
|
||||
logger.info('Could not connect to host: {host} via protocol {protocol}'.format(
|
||||
host=settings.OPENNEBULA_DOMAIN,
|
||||
protocol=settings.OPENNEBULA_PROTOCOL)
|
||||
)
|
||||
raise ConnectionRefusedError
|
||||
return image_pool
|
||||
|
||||
def get_images(self):
|
||||
try:
|
||||
public_images = [
|
||||
image
|
||||
for image in self._get_image_pool()
|
||||
if 'public-' in image.name
|
||||
]
|
||||
return public_images
|
||||
except ConnectionRefusedError:
|
||||
return []
|
||||
pass
|
||||
|
||||
def get_image(self, image_id):
|
||||
image_id = int(image_id)
|
||||
try:
|
||||
image_pool = self._get_image_pool()
|
||||
return image_pool.get_by_id(image_id)
|
||||
except:
|
||||
return None
|
||||
|
||||
|
|
|
|||
|
|
@ -31,7 +31,7 @@ class VirtualMachineTemplateSerializer(serializers.Serializer):
|
|||
core_price = template.pop('cpu_cost')
|
||||
memory_price = template.pop('memory_cost')
|
||||
disk_size_price = template.pop('disk_cost')
|
||||
manager = OpenNebulaManager(create_user = False)
|
||||
manager = OpenNebulaManager()
|
||||
|
||||
try:
|
||||
opennebula_id = manager.create_template(name=name, cores=cores,
|
||||
|
|
@ -92,7 +92,7 @@ class VirtualMachineSerializer(serializers.Serializer):
|
|||
try:
|
||||
manager = OpenNebulaManager(email=owner.email,
|
||||
password=owner.password,
|
||||
create_user = True)
|
||||
)
|
||||
opennebula_id = manager.create_vm(template_id)
|
||||
except OpenNebulaException as err:
|
||||
raise serializers.ValidationError("OpenNebulaException occured. {0}".format(err))
|
||||
|
|
@ -117,3 +117,8 @@ class VirtualMachineSerializer(serializers.Serializer):
|
|||
price += int(disk.size)/1024 * float(template.disk_cost)
|
||||
return price
|
||||
|
||||
class ImageSerializer(serializers.Serializer):
|
||||
"""Serializer to map the image instance into JSON format."""
|
||||
id = serializers.IntegerField(read_only=True)
|
||||
name = serializers.CharField()
|
||||
|
||||
|
|
|
|||
|
|
@ -47,8 +47,7 @@ class VmCreateView(generics.ListCreateAPIView):
|
|||
def get_queryset(self):
|
||||
owner = self.request.user
|
||||
manager = OpenNebulaManager(email=owner.email,
|
||||
password=owner.password,
|
||||
create_user=True)
|
||||
password=owner.password)
|
||||
return manager.get_vms()
|
||||
|
||||
def perform_create(self, serializer):
|
||||
|
|
@ -64,21 +63,18 @@ class VmDetailsView(generics.RetrieveUpdateDestroyAPIView):
|
|||
def get_queryset(self):
|
||||
owner = self.request.user
|
||||
manager = OpenNebulaManager(email=owner.email,
|
||||
password=owner.password,
|
||||
create_user=True)
|
||||
password=owner.password)
|
||||
return manager.get_vms()
|
||||
|
||||
def get_object(self):
|
||||
owner = self.request.user
|
||||
manager = OpenNebulaManager(email=owner.email,
|
||||
password=owner.password,
|
||||
create_user=True)
|
||||
password=owner.password)
|
||||
return manager.get_vm(self.kwargs.get('pk'))
|
||||
|
||||
def perform_destroy(self, instance):
|
||||
owner = self.request.user
|
||||
manager = OpenNebulaManager(email=owner.email,
|
||||
password=owner.password,
|
||||
create_user = True)
|
||||
password=owner.password)
|
||||
manager.delete_vm(instance.id)
|
||||
|
||||
|
|
|
|||
Loading…
Reference in a new issue