dynamicweb/opennebula_api/models.py

647 lines
22 KiB
Python
Raw Normal View History

2017-05-12 17:13:18 +00:00
import logging
import socket
2017-05-12 17:13:18 +00:00
import oca
from django.conf import settings
from oca.exceptions import OpenNebulaException
from oca.pool import WrongNameError, WrongIdError
from hosting.models import HostingOrder
from utils.models import CustomUser
2017-08-31 21:03:31 +00:00
from utils.tasks import save_ssh_key, save_ssh_key_error_handler
from .exceptions import KeyExistsError, UserExistsError, UserCredentialError
2017-05-31 16:01:54 +00:00
2017-05-12 17:13:18 +00:00
logger = logging.getLogger(__name__)
2017-05-10 02:06:12 +00:00
class OpenNebulaManager():
"""This class represents an opennebula manager."""
def __init__(self, email=None, password=None):
self.email = email
self.password = password
# Get oneadmin client
self.oneadmin_client = self._get_opennebula_client(
settings.OPENNEBULA_USERNAME,
settings.OPENNEBULA_PASSWORD
)
# Get or create oppenebula user using given credentials
try:
self.opennebula_user = self._get_or_create_user(
email,
password
)
# If opennebula user was created/obtained, get his client
self.client = self._get_opennebula_client(
email,
password
)
except:
pass
2017-05-31 16:01:54 +00:00
def _get_client(self, user):
"""Get a opennebula client object for a CustomUser object
2017-05-31 16:01:54 +00:00
Args:
user (CustomUser): dynamicweb CustomUser object
Returns:
oca.Client: Opennebula client object
Raise:
ConnectionError: If the connection to the opennebula server can't be
established
2017-05-31 16:01:54 +00:00
"""
return oca.Client("{0}:{1}".format(
user.email,
user.password),
"{protocol}://{domain}:{port}{endpoint}".format(
protocol=settings.OPENNEBULA_PROTOCOL,
domain=settings.OPENNEBULA_DOMAIN,
port=settings.OPENNEBULA_PORT,
endpoint=settings.OPENNEBULA_ENDPOINT
2018-05-23 22:27:01 +00:00
))
def _get_opennebula_client(self, username, password):
return oca.Client("{0}:{1}".format(
username,
2017-05-31 16:01:54 +00:00
password),
"{protocol}://{domain}:{port}{endpoint}".format(
protocol=settings.OPENNEBULA_PROTOCOL,
domain=settings.OPENNEBULA_DOMAIN,
port=settings.OPENNEBULA_PORT,
endpoint=settings.OPENNEBULA_ENDPOINT
2018-05-23 22:27:01 +00:00
))
2017-05-31 16:01:54 +00:00
def _get_user(self, user):
"""Get the corresponding opennebula user for a CustomUser object
2017-05-31 16:01:54 +00:00
Args:
user (CustomUser): dynamicweb CustomUser object
Returns:
oca.User: Opennebula user object
Raise:
WrongNameError: If no openebula user with this credentials exists
ConnectionError: If the connection to the opennebula server can't be
established
2017-05-31 16:01:54 +00:00
"""
user_pool = self._get_user_pool()
return user_pool.get_by_name(user.email)
def create_user(self, user: CustomUser):
"""Create a new opennebula user or a corresponding CustomUser object
2017-05-31 16:01:54 +00:00
Args:
user (CustomUser): dynamicweb CustomUser object
Returns:
int: Return the opennebula user id
2017-05-31 16:01:54 +00:00
Raises:
ConnectionError: If the connection to the opennebula server can't be
established
2017-05-31 16:01:54 +00:00
UserExistsError: If a user with this credeintals already exits on the
server
UserCredentialError: If a user with this email exists but the
password is worng
"""
try:
self._get_user(user)
try:
2017-05-31 16:01:54 +00:00
self._get_client(self, user)
logger.debug('User already exists')
raise UserExistsError()
except OpenNebulaException as err:
logger.error('OpenNebulaException error: {0}'.format(err))
logger.debug('User exists but password is wrong')
raise UserCredentialError()
except WrongNameError:
user_id = self.oneadmin_client.call(oca.User.METHODS['allocate'],
user.email, user.password,
'core')
logger.debug(
'Created a user for CustomObject: {user} with user id = {u_id}',
user=user,
u_id=user_id
)
return user_id
2017-05-31 16:01:54 +00:00
except ConnectionRefusedError:
logger.error(
'Could not connect to host: {host} via protocol {protocol}'.format(
host=settings.OPENNEBULA_DOMAIN,
protocol=settings.OPENNEBULA_PROTOCOL)
2017-05-31 16:01:54 +00:00
)
raise ConnectionRefusedError
def _get_or_create_user(self, email, password):
try:
2017-05-09 22:39:41 +00:00
user_pool = self._get_user_pool()
opennebula_user = user_pool.get_by_name(email)
return opennebula_user
except WrongNameError as wrong_name_err:
opennebula_user = self.oneadmin_client.call(
oca.User.METHODS['allocate'], email,
password, 'core')
logger.debug(
2017-09-23 20:33:48 +00:00
"User {} does not exist. Created the user. User id = {}".format(
2017-09-27 23:27:40 +00:00
email,
opennebula_user
)
)
2017-05-10 00:49:03 +00:00
return opennebula_user
2017-05-09 22:39:41 +00:00
except ConnectionRefusedError:
logger.info(
'Could not connect to host: {host} via protocol {protocol}'.format(
host=settings.OPENNEBULA_DOMAIN,
protocol=settings.OPENNEBULA_PROTOCOL)
)
raise ConnectionRefusedError
2017-05-09 15:15:12 +00:00
def _get_user_pool(self):
2017-05-09 22:39:41 +00:00
try:
user_pool = oca.UserPool(self.oneadmin_client)
user_pool.info()
except ConnectionRefusedError:
logger.info(
'Could not connect to host: {host} via protocol {protocol}'.format(
host=settings.OPENNEBULA_DOMAIN,
protocol=settings.OPENNEBULA_PROTOCOL)
)
raise
2017-05-09 15:15:12 +00:00
return user_pool
2017-05-09 23:31:27 +00:00
def _get_vm_pool(self):
try:
2017-05-11 10:45:09 +00:00
vm_pool = oca.VirtualMachinePool(self.client)
vm_pool.info()
return vm_pool
2017-05-11 10:45:09 +00:00
except AttributeError:
logger.info('Could not connect via client, using oneadmin instead')
2017-05-14 10:44:36 +00:00
try:
vm_pool = oca.VirtualMachinePool(self.oneadmin_client)
vm_pool.info(filter=-2)
return vm_pool
2017-05-14 10:44:36 +00:00
except:
raise ConnectionRefusedError
2017-05-11 10:45:09 +00:00
except ConnectionRefusedError:
logger.info(
'Could not connect to host: {host} via protocol {protocol}'.format(
host=settings.OPENNEBULA_DOMAIN,
protocol=settings.OPENNEBULA_PROTOCOL)
)
raise ConnectionRefusedError
2017-05-14 10:22:10 +00:00
# For now we'll just handle all other errors as connection errors
except:
raise ConnectionRefusedError
def get_vms(self):
try:
return self._get_vm_pool()
except ConnectionRefusedError:
2017-05-14 10:22:10 +00:00
raise ConnectionRefusedError
def get_vm(self, vm_id):
2017-05-13 04:59:57 +00:00
vm_id = int(vm_id)
try:
vm_pool = self._get_vm_pool()
2017-05-13 04:59:57 +00:00
return vm_pool.get_by_id(vm_id)
except WrongIdError:
raise WrongIdError
except:
2017-05-14 10:22:10 +00:00
raise ConnectionRefusedError
2017-05-09 23:31:27 +00:00
def is_public_ipv4(self, ipv4):
"""
Checks whether the passed ipv4 is a public IP.
:param ipv4:
:return: Returns true if it is a public IP else returns false
"""
if ipv4.startswith("10."):
return False
else:
return True
def get_primary_ip(self, vm_id):
"""
Returns primary ipv4 if it exists and is a public ip. Otherwise returns
the IPv6 of the machine
:param vm_id:
:return:
"""
ipv4 = self.get_primary_ipv4(vm_id)
if self.is_public_ipv4(ipv4):
return ipv4
else:
return self.get_primary_ipv6(vm_id)
def get_primary_ipv6(self, vm_id):
"""
Returns the primary IPv6 of the given vm.
For now, we return the first available IPv6 (to be changed later)
:return: An IP address string, if it exists else returns None
"""
all_ipv4s = self.get_vm_ipv4_addresses(vm_id)
if len(all_ipv4s) > 0:
return all_ipv4s[0]
else:
return None
def get_vm_ipv6_addresses(self, vm_id):
"""
Returns a list of IPv6 addresses of the given vm
:param vm_id: The ID of the vm
:return:
"""
ipv6s = []
vm = self.get_vm(vm_id)
for nic in vm.template.nics:
if hasattr(nic, 'ip6_global'):
ipv6s.append(nic.ip6_global)
return ipv6s
2017-08-31 16:33:07 +00:00
def get_primary_ipv4(self, vm_id):
"""
Returns the primary IPv4 of the given vm.
To be changed later.
:return: An IP address string, if it exists else returns None
"""
all_ipv4s = self.get_vm_ipv4_addresses(vm_id)
if len(all_ipv4s) > 0:
return all_ipv4s[0]
else:
return None
def get_vm_ipv4_addresses(self, vm_id):
"""
Returns a list of IPv4 addresses of the given vm
:param vm_id: The ID of the vm
:return:
"""
ipv4s = []
vm = self.get_vm(vm_id)
for nic in vm.template.nics:
if hasattr(nic, 'ip'):
ipv4s.append(nic.ip)
return ipv4s
2017-06-29 16:23:25 +00:00
def create_vm(self, template_id, specs, ssh_key=None, vm_name=None):
2017-05-13 04:59:57 +00:00
2017-05-13 11:47:53 +00:00
template = self.get_template(template_id)
vm_specs_formatter = """<TEMPLATE>
<MEMORY>{memory}</MEMORY>
<VCPU>{vcpu}</VCPU>
<CPU>{cpu}</CPU>
"""
2017-05-14 00:18:16 +00:00
try:
disk = template.template.disks[0]
image_id = disk.image_id
vm_specs = vm_specs_formatter.format(
vcpu=int(specs['cpu']),
cpu=0.1 * int(specs['cpu']),
memory=1024 * int(specs['memory']),
)
2017-05-14 00:18:16 +00:00
vm_specs += """<DISK>
<TYPE>fs</TYPE>
<SIZE>{size}</SIZE>
<DEV_PREFIX>vd</DEV_PREFIX>
<IMAGE_ID>{image_id}</IMAGE_ID>
</DISK>
""".format(size=1024 * int(specs['disk_size']),
image_id=image_id)
except:
disk = template.template.disks[0]
image = disk.image
image_uname = disk.image_uname
vm_specs = vm_specs_formatter.format(
vcpu=int(specs['cpu']),
cpu=0.1 * int(specs['cpu']),
memory=1024 * int(specs['memory']),
)
2017-05-14 00:18:16 +00:00
vm_specs += """<DISK>
<TYPE>fs</TYPE>
<SIZE>{size}</SIZE>
<DEV_PREFIX>vd</DEV_PREFIX>
<IMAGE>{image}</IMAGE>
<IMAGE_UNAME>{image_uname}</IMAGE_UNAME>
</DISK>
""".format(size=1024 * int(specs['disk_size']),
image=image,
image_uname=image_uname)
2017-06-21 07:43:10 +00:00
vm_specs += "<CONTEXT>"
if ssh_key:
vm_specs += "<SSH_PUBLIC_KEY>{ssh}</SSH_PUBLIC_KEY>".format(
ssh=ssh_key)
2017-06-21 07:43:10 +00:00
vm_specs += """<NETWORK>YES</NETWORK>
</CONTEXT>
2017-06-21 07:43:10 +00:00
</TEMPLATE>
"""
2017-11-29 05:45:09 +00:00
try:
vm_id = self.client.call(
oca.VmTemplate.METHODS['instantiate'], template.id, '', True,
vm_specs, False
)
except OpenNebulaException as err:
logger.error("OpenNebulaException: {0}".format(err))
return None
2017-05-13 04:59:57 +00:00
self.oneadmin_client.call(
oca.VirtualMachine.METHODS['action'],
'release',
vm_id
)
2017-06-29 16:23:25 +00:00
if vm_name is not None:
self.oneadmin_client.call(
'vm.rename',
vm_id,
vm_name
)
2017-05-09 23:31:27 +00:00
return vm_id
def delete_vm(self, vm_id):
2017-05-12 17:13:18 +00:00
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.info("Socket timeout error: {0}".format(socket_err))
except OpenNebulaException as opennebula_err:
logger.info(
"OpenNebulaException error: {0}".format(opennebula_err))
2017-05-12 17:13:18 +00:00
except OSError as os_err:
logger.info("OSError : {0}".format(os_err))
except ValueError as value_err:
logger.info("ValueError : {0}".format(value_err))
return vm_terminated
def _get_template_pool(self):
try:
template_pool = oca.VmTemplatePool(self.oneadmin_client)
template_pool.info()
return template_pool
except ConnectionRefusedError:
logger.info(
2017-09-14 13:27:25 +00:00
"""Could not connect to host: {host} via protocol
{protocol}""".format(
host=settings.OPENNEBULA_DOMAIN,
protocol=settings.OPENNEBULA_PROTOCOL)
)
raise ConnectionRefusedError
2017-05-14 10:22:10 +00:00
except:
raise ConnectionRefusedError
2018-05-23 22:27:01 +00:00
def get_templates(self, prefix='public-'):
try:
public_templates = [
template
for template in self._get_template_pool()
2018-05-23 22:27:01 +00:00
if template.name.startswith(prefix)
]
return public_templates
except ConnectionRefusedError:
2017-05-14 10:22:10 +00:00
raise ConnectionRefusedError
except:
raise ConnectionRefusedError
def try_get_templates(self):
try:
return self.get_templates()
except:
return []
def get_template(self, template_id):
2017-05-13 04:59:57 +00:00
template_id = int(template_id)
try:
template_pool = self._get_template_pool()
return template_pool.get_by_id(template_id)
except:
2017-05-14 10:22:10 +00:00
raise ConnectionRefusedError
def create_template(self, name, cores, memory, disk_size, core_price,
memory_price,
disk_size_price, ssh=''):
2017-05-10 00:49:03 +00:00
"""Create and add a new template to opennebula.
:param name: A string representation describing the template.
Used as label in view.
:param cores: Amount of virtual cpu cores for the VM.
:param memory: Amount of RAM for the VM (GB)
:param disk_size: Amount of disk space for VM (GB)
:param core_price: Price of virtual cpu for the VM per core.
:param memory_price: Price of RAM for the VM per GB
:param disk_size_price: Price of disk space for VM per GB
:param ssh: User public ssh key
2017-05-10 00:49:03 +00:00
"""
2017-05-09 23:11:49 +00:00
template_string_formatter = """<TEMPLATE>
<NAME>{name}</NAME>
<MEMORY>{memory}</MEMORY>
<VCPU>{vcpu}</VCPU>
<CPU>{cpu}</CPU>
<DISK>
<TYPE>fs</TYPE>
<SIZE>{size}</SIZE>
<DEV_PREFIX>vd</DEV_PREFIX>
</DISK>
<CPU_COST>{cpu_cost}</CPU_COST>
<MEMORY_COST>{memory_cost}</MEMORY_COST>
<DISK_COST>{disk_cost}</DISK_COST>
<SSH_PUBLIC_KEY>{ssh}</SSH_PUBLIC_KEY>
2017-05-09 23:11:49 +00:00
</TEMPLATE>
"""
template_id = oca.VmTemplate.allocate(
self.oneadmin_client,
template_string_formatter.format(
name=name,
vcpu=cores,
cpu=0.1 * cores,
2017-05-09 23:11:49 +00:00
size=1024 * disk_size,
memory=1024 * memory,
# * 10 because we set cpu to *0.1
cpu_cost=10 * core_price,
memory_cost=memory_price,
disk_cost=disk_size_price,
ssh=ssh
2017-05-09 23:11:49 +00:00
)
)
return template_id
def delete_template(self, template_id):
self.oneadmin_client.call(oca.VmTemplate.METHODS[
2018-05-23 22:27:01 +00:00
'delete'], template_id, False)
2017-09-25 07:35:18 +00:00
def change_user_password(self, passwd_hash):
self.oneadmin_client.call(
oca.User.METHODS['passwd'],
self.opennebula_user.id,
2017-09-25 07:35:18 +00:00
passwd_hash
)
2017-05-31 16:01:54 +00:00
def add_public_key(self, user, public_key='', merge=False):
"""
2017-05-31 16:01:54 +00:00
Args:
user (CustomUser): Dynamicweb user
2017-05-31 16:01:54 +00:00
public_key (string): Public key to add to the user
merge (bool): Optional if True the new public key replaces the old
2017-05-31 16:01:54 +00:00
Raises:
KeyExistsError: If replace is False and the user already has a
public key
2017-05-31 16:01:54 +00:00
WrongNameError: If no openebula user with this credentials exists
ConnectionError: If the connection to the opennebula server can't be
established
2017-05-31 16:01:54 +00:00
Returns:
True if public_key was added
"""
# TODO: Check if we can remove this first try because we basically just
# raise the possible Errors
2017-05-31 16:01:54 +00:00
try:
open_user = self._get_user(user)
try:
old_key = open_user.template.ssh_public_key
if not merge:
2017-05-31 16:01:54 +00:00
raise KeyExistsError()
public_key += '\n{key}'.format(key=old_key)
2017-05-31 16:01:54 +00:00
except AttributeError:
pass
self.oneadmin_client.call('user.update', open_user.id,
'<CONTEXT><SSH_PUBLIC_KEY>{key}</SSH_PUBLIC_KEY></CONTEXT>'
.format(key=public_key))
2017-05-31 16:01:54 +00:00
return True
except WrongNameError:
raise
except ConnectionError:
raise
def remove_public_key(self, user, public_key=''):
"""
Args:
user (CustomUser): Dynamicweb user
public_key (string): Public key to be removed to the user
Raises:
KeyDoesNotExistsError: If replace is False and the user already has a
public key
WrongNameError: If no openebula user with this credentials exists
ConnectionError: If the connection to the opennebula server can't be
established
Returns:
True if public_key was removed
"""
try:
open_user = self._get_user(user)
try:
old_key = open_user.template.ssh_public_key
if public_key not in old_key:
2017-06-11 16:44:14 +00:00
return False
# raise KeyDoesNotExistsError()
if '\n{}'.format(public_key) in old_key:
public_key = old_key.replace('\n{}'.format(public_key), '')
else:
public_key = old_key.replace(public_key, '')
except AttributeError:
2017-06-11 17:59:57 +00:00
return False
# raise KeyDoesNotExistsError()
self.oneadmin_client.call('user.update', open_user.id,
'<CONTEXT><SSH_PUBLIC_KEY>{key}</SSH_PUBLIC_KEY></CONTEXT>'
.format(key=public_key))
return True
except WrongNameError:
raise
except ConnectionError:
raise
2017-08-31 16:33:07 +00:00
def manage_public_key(self, keys, hosts=None, countdown=0):
"""
2017-08-31 16:33:07 +00:00
A function that manages the supplied keys in the
authorized_keys file of the given list of hosts. If hosts
parameter is not supplied, all hosts of this customer
will be configured with the supplied keys
2017-08-30 07:43:54 +00:00
2017-08-31 16:33:07 +00:00
:param keys: A list of ssh keys that are to be added/removed
2017-08-30 07:43:54 +00:00
A key should be a dict of the form
{
'value': 'sha-.....', # public key as string
'state': True # whether key is to be added or
} # removed
2017-08-31 16:33:07 +00:00
:param hosts: A list of hosts IP addresses
:param countdown: Parameter to be passed to celery apply_async
Allows to delay a task by `countdown` number of seconds
:return:
"""
2017-08-31 16:33:07 +00:00
if hosts is None:
hosts = self.get_all_hosts()
if len(hosts) > 0 and len(keys) > 0:
2017-08-31 21:03:31 +00:00
save_ssh_key.apply_async((hosts, keys), countdown=countdown,
link_error=save_ssh_key_error_handler.s())
2017-08-31 16:33:07 +00:00
else:
2017-09-13 10:24:08 +00:00
logger.debug(
"Keys and/or hosts are empty, so not managing any keys")
2017-08-31 16:33:07 +00:00
def get_all_hosts(self):
"""
A utility function to obtain all hosts of this owner
:return: A list of hosts IP addresses, empty if none exist
"""
owner = CustomUser.objects.filter(
email=self.email).first()
all_orders = HostingOrder.objects.filter(customer__user=owner)
2017-08-31 16:33:07 +00:00
hosts = []
if len(all_orders) > 0:
logger.debug("The user {} has 1 or more VMs. We need to configure "
"the ssh keys.".format(self.email))
for order in all_orders:
try:
vm = self.get_vm(order.vm_id)
for nic in vm.template.nics:
if hasattr(nic, 'ip'):
if str(nic.ip).startswith("10."):
if hasattr(nic, 'ip6_global'):
hosts.append(nic.ip6_global)
else:
hosts.append(nic.ip)
except WrongIdError:
logger.debug(
"VM with ID {} does not exist".format(order.vm_id))
else:
logger.debug("The user {} has no VMs. We don't need to configure "
"the ssh keys.".format(self.email))
2017-08-31 16:33:07 +00:00
return hosts