system_image.py

Go to the documentation of this file.

# -*- coding: utf-8 -*-
# @COPYRIGHT_begin
#
# Copyright [2010-2014] Institute of Nuclear Physics PAN, Krakow, Poland
#
# Licensed under the Apache License, Version 2.0 (the "License");
#    you may not use this file except in compliance with the License.
#    You may obtain a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
#    distributed under the License is distributed on an "AS IS" BASIS,
#    WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
#    See the License for the specific language governing permissions and
#    limitations under the License.
#
# @COPYRIGHT_end

##
# @package src.cm.models.system_image
# 

import os
import subprocess

from django.db import models

from cm.models.image import Image
from cm.utils import log
from cm.utils.exception import CMException
from common.hardware import video_devices, network_devices, \
    video_devices_reversed, network_devices_reversed
from common.states import image_access, vm_states
from cm.utils import message


##
# 
#     @model{SYSTEM_IMAGE} VM type image's class.
# 
#     System image is one of the Images type. SystemImage class extends
#     src.cm.models.image.Image class.
#     By default virtual machine boots from copy of the stored VM image.
#     At the VM's creation moment it's required to choose one VM image
# 
#     We can distinguish:
#     - public images
#     - private images
#     - group images
# 
#     VM images are mutable while VM is running. When closing VM, the copy
#     of the image that virtual machine is running from may be saved to
#     private images' pool.
# 
#     Despite the ability of VM images to store data it's not their purpose.
#     It is far more convenient and recommended to store data on
#     Storage Images (StorageImages).
#     
class SystemImage(Image):
    platform = models.IntegerField()

    # default values are taken from hardware.py
    network_device = models.IntegerField(default=network_devices['virtio'])
    video_device = models.IntegerField(default=video_devices['cirrus'])

    @classmethod
    def create(cls, name, description, user, platform, disk_controller, network_device, video_device):
        image = Image.create(cls, name=name, description=description, user=user, size=0, progress=0,
                             disk_dev=1, disk_controller=disk_controller)
        image.platform = platform
        image.access = image_access['private']
        image.network_device = network_device
        image.video_device = video_device
        return image

    # TODO: is vms and user_group necessary too?
    @property
    ##
    # 
    #         @returns{dict} image's data
    #         \n fields:
    #         @dictkey{id}
    #         @dictkey{user_id,int}
    #         @dictkey{name}
    #         @dictkey{platform}
    #         @dictkey{description}
    #         @dictkey{creation_date}
    #         
    def dict(self):
        d = self.dictImg()

        if self.disk_dev is not None:
            d['disk_dev'] = 'sd%s' % chr(self.disk_dev + 96)
        else:
            d['disk_dev'] = ''

        # fields for vm image:
        d['user_id'] = self.user.id
        d['access'] = self.access
        d['disk_controller'] = self.disk_controller
        d['platform'] = self.platform
        d['system_image_id'] = self.id

        # TODO:
        # set of vms with this image attached
        d['vms'] = list(self.vm_set.filter(state__in=[vm_states['running'], vm_states['running']]).values_list('id', flat=True)) or []

        # groups image belongs (only one group for now)
        grouplist = self.systemimagegroup_set.values_list('group_id', flat=True)
        d['group_id'] = grouplist[0] if len(grouplist) > 0 else ''

        d['disk_controller'] = self.disk_controller
        d['video_device'] = self.video_device
        d['network_device'] = self.network_device

        return d

    # returns image id if it belongs to user user_id
    # (and optionally to listed groups, if any given)
    # also check if user has permissions
    @staticmethod
    ##
    # 
    #         Method returns requested VMImage, provided specified User actually
    #         has right to access it:
    #         - either as it's owner,
    #         - or as member of a Group VMImage belongs to.
    # 
    #         @parameter{user_id,int} User for whom VMImage should be obtained
    #         @parameter{sys_image_id,int} id of the requested VMImage
    #         @parameter{groups,list(int)} ids of the Groups that User belongs to @optional{None}
    # 
    #         @returns{Image} requested VMImage instance, provided specified User
    #         actually has right to access it
    # 
    #         @raises{image_get,CMException} no such VMImage
    #         
    def get(user_id, sys_image_id, groups=None):

        try:
            image = SystemImage.objects.get(pk=sys_image_id)
        except:
            raise CMException('system_image_get')

        # TODO:
        # should check on state and storage? it was in get image old code
        # if image.state != image_states['ok'] and image.storage.state != storage_states['ok']:
        #    raise CMException('image_unavailable')

        image.has_access(user_id, groups)
        return image

    # @returns VMImage instance for admin user
    @staticmethod
    ##
    # 
    #         Getter, which should be called by admin. It doesn't check Image's ownership.
    # 
    #         @parameter{sys_img_id,int} primary index of the @type{VMImage}
    # 
    #         @returns{SystemImage} instance of @type{SystemImage} based on primary index provided
    # 
    #         @raises{image_get,CMException}
    #         
    def admin_get(sys_image_id):

        try:
            image = SystemImage.objects.get(pk=sys_image_id)
        except:
            raise CMException('system_image_get')

        return image

    ##
    # 
    #         @parameter{user_id,int} id of the User to check for right to access
    #         @parameter{groups,list(int)} id if the Groups User belongs to; required
    #         if Image's access type is 'group'
    # 
    #         @returns{bool}
    #         True, if specified User or listed Groups have right to access this
    #         Image. Otherwise exception is thrown.
    # 
    #         @raises{system_image_permission,CMException} neither User nor listed Groups
    #         have right to access this Image.
    #         
    def has_access(self, user_id, groups=None):
        if self.user.id != user_id:
            if self.access == image_access['private']:
                raise CMException('system_image_permission')
                # if image has a groups access we need to check if image belongs to users groups or is group leader
            # elif self.access == image_access['group'] and (groups is None or self.image2group.group_id not in groups):
            elif self.access == image_access['group'] and ((groups is None) or (not(self.systemimagegroup_set.filter(group_id__in=groups).exists()))):
                raise CMException('system_image_permission')
        return True

    @property
    ##
    # 
    #         Method filters VIDEO_DEVICES list to find video device name by
    #         the video_device id that is assigned to this Image.
    #         @returns{string} name of this Image's the video device, if such a
    #         video device exists. otherwise 'vga'
    #         
    def video_device_name(self):
        try:
            return video_devices_reversed[self.video_device]
        except Exception:
            log.error(self.user.id, 'Cannot find video device')
            return 'vga'

    @property
    ##
    # 
    #         Method filters NETWORK_DEVICES list to find network device name by
    #         the network_device id with is assigned to this Image.
    #         @returns{string} name of this Image's network device, if such a
    #         network device exists.
    #         
    def network_device_name(self):
        try:
            return network_devices_reversed[self.network_device]
        except Exception:
            log.error(self.user.id, 'Cannot find network device')

    ##
    # 
    #         Copy vm image from storage to node
    # 
    #         @raises{vm_create,CMException}
    #         
    def copy_to_node(self, vm):
        log.debug(vm.user.id, "Copy image by ssh")
        log.debug(vm.user.id, str(['ssh', vm.node.ssh_string, 'cp %s /images/%d' % (vm.system_image.path, vm.id)]))

        if subprocess.call(['ssh', vm.node.ssh_string, 'cp %s /images/%d' % (vm.system_image.path, vm.id)]):
            message.error(vm.user_id, 'vm_create', {'id': vm.id, 'name': vm.name})
            raise CMException('vm_create')

        if subprocess.call(['ssh', vm.node.ssh_string, 'chmod a+rw /images/%d' % vm.id]):
            message.error(vm.user_id, 'vm_create', {'id': vm.id, 'name': vm.name})
            raise CMException('vm_create')
        return

    ##
    # 
    #         Copy vm image from node images pool to selected image on storage. Image
    #         entity should be createt before calling this function
    #         
    def copy_to_storage(self, vm, image):
        log.debug(vm.user.id, "Preparing temporary storage pool")
        if not os.path.exists(os.path.dirname(image.path)):
            os.makedirs(os.path.dirname(image.path))
        log.debug(vm.user.id, str(['ssh', vm.node.ssh_string, 'cp /images/%d %s' % (vm.id, image.path)]))

        if subprocess.call(['ssh', vm.node.ssh_string, 'cp /images/%d %s' % (vm.id, image.path)]):
            raise CMException('image_copy_to_storage')