Synnefo

QADD = 1

QREMOVE = -1

QDISK = "cyclades.disk"

QVM = "cyclades.vm"

QPITHOS = "pithos.diskspace"

QRAM = "cyclades.ram"

QIP = "cyclades.floating_ip"

QCPU = "cyclades.cpu"

QNET = "cyclades.network.private"

    uuid = Proper(value=None)

        self.fail(msg % args)

        if self.uuid is None:

            authenticate = self.clients.astakos.authenticate()

            self.uuid = authenticate['access']['user']['id']

            self.info("User's uuid is %s", self.uuid)

        return self.uuid

    def _check_quotas(self, changes):

        @param changes: A dict of the changes that have been made in quotas

        if not changes:

            return

        # Take old_quotas and apply changes

        for prj, values in changes.items():

            self.assertIn(prj, old_quotas.keys())

            for q_name, q_mult, q_value, q_unit in values:

                if q_unit is None:

                    q_unit = 1

                q_value = q_mult*int(q_value)*q_unit

                assert isinstance(q_value, int), \

                    "Project %s: %s value has to be integer" % (prj, q_name)

                old_quotas[prj][q_name]['usage'] += q_value

                old_quotas[prj][q_name]['project_usage'] += q_value

        self.assertEqual(old_quotas, new_quotas)

from synnefo_tools.burnin.common import BurninTests, MB, GB, QADD, QREMOVE, \

    QDISK, QVM, QRAM, QIP, QCPU, QNET

    def _parse_images(self):

        """Find images given to command line"""

        if self.images is None:

            self.info("No --images given. Will use the default %s",

                      "^Debian Base$")

            filters = ["name:^Debian Base$"]

        else:

            filters = self.images

        avail_images = self._find_images(filters)

        self.info("Found %s images to choose from", len(avail_images))

        return avail_images

    def _parse_flavors(self):

        """Find flavors given to command line"""

        flavors = self._get_list_of_flavors(detail=True)

        if self.flavors is None:

            self.info("No --flavors given. Will use all of them")

            avail_flavors = flavors

        else:

            avail_flavors = self._find_flavors(self.flavors, flavors=flavors)

        self.info("Found %s flavors to choose from", len(avail_flavors))

        return avail_flavors

    # pylint: disable=too-many-arguments

    def _create_server(self, image, flavor, personality=None,

                       network=False, project_id=None):

            fip = self._create_floating_ip(project_id=project_id)

            personality=personality, networks=networks,

            project=project_id)

        if project_id is None:

            project_id = self._get_uuid()

        self.assertEqual(server['tenant_id'], project_id)

        changes = \

            {project_id:

                [(QDISK, QADD, flavor['disk'], GB),

                 (QVM, QADD, 1, None),

                 (QRAM, QADD, flavor['ram'], MB),

                 (QCPU, QADD, flavor['vcpus'], None)]}

        self._check_quotas(changes)

        self._verify_quotas_deleted(servers)

    def _verify_quotas_deleted(self, servers):

        changes = dict()

        for server in servers:

            project = server['tenant_id']

            if project not in changes:

                changes[project] = []

            flavor = \

                self.clients.compute.get_flavor_details(server['flavor']['id'])

            new_changes = [

                (QDISK, QREMOVE, flavor['disk'], GB),

                (QVM, QREMOVE, 1, None),

                (QRAM, QREMOVE, flavor['ram'], MB),

                (QCPU, QREMOVE, flavor['vcpus'], None)]

            changes[project].extend(new_changes)

        self._check_quotas(changes)

            self.assertEqual(IPy.IP(addr).version(), version)

    def _create_network(self, cidr="10.0.1.0/28", dhcp=True,

                        project_id=None):

            "MAC_FILTERED", name=name, shared=False,

            project=project_id)

        if project_id is None:

            project_id = self._get_uuid()

        changes = \

            {project_id: [(QNET, QADD, 1, None)]}

        self._check_quotas(changes)

        self.assertEqual(network['tenant_id'], project_id)

        changes = \

            {self._get_uuid(): [(QNET, QREMOVE, len(networks), None)]}

        self._check_quotas(changes)

    def _create_floating_ip(self, project_id=None):

        fip = self.clients.network.create_floatingip(

            pub_net['id'], project=project_id)

        if project_id is None:

            project_id = self._get_uuid()

        changes = \

            {project_id: [(QIP, QADD, 1, None)]}

        self._check_quotas(changes)

        self.assertEqual(IPy.IP(fip['floating_ip_address']).version(), 4)

        self.assertEqual(fip['tenant_id'], project_id)

        changes = dict()

        for fip in fips:

            project = fip['tenant_id']

            if project not in changes:

                changes[project] = []

            changes[project].append((QIP, QREMOVE, 1, None))

        self._check_quotas(changes)

    def _find_project(self, flavors, projects=None):

        """Return a pair of flavor, project that we can use"""

        if projects is None:

            projects = self.quotas.keys()

        # XXX: Well there seems to be no easy way to find how many resources

        # we have left in a project (we have to substract usage from limit,

        # check both per_user and project quotas, blah, blah). For now

        # just return the first flavor with the first project and lets hope

        # that it fits.

        return (flavors[0], projects[0])

        # # Get only the quotas for the given 'projects'

        # quotas = dict()

        # for prj, qts in self.quotas.items():

        #     if prj in projects:

        #         quotas[prj] = qts

        #

        # results = []

        # for flv in flavors:

        #     for prj, qts in quotas.items():

        #         self.debug("Testing flavor %s, project %s", flv['name'], prj)

        #         condition = \

        #             (flv['ram'] <= qts['cyclades.ram']['usage'] and

        #              flv['vcpus'] <= qts['cyclades.cpu']['usage'] and

        #              flv['disk'] <= qts['cyclades.disk']['usage'] and

        #              qts['cyclades.vm']['usage'] >= 1)

        #         if condition:

        #             results.append((flv, prj))

        #

        # if not results:

        #     msg = "Couldn't find a suitable flavor to use for current qutoas"

        #     self.error(msg)

        #

        # return random.choice(results)

from synnefo_tools.burnin.common import BurninTests, Proper, \

    QPITHOS, QADD, QREMOVE

        changes = \

            {self._get_uuid(): [(QPITHOS, QADD, file_size, None)]}

        self._check_quotas(changes)

        changes = \

            {self._get_uuid(): [(QPITHOS, QREMOVE, file_size, None)]}

        self._check_quotas(changes)

        self.avail_images = self._parse_images()

        self.avail_flavors = self._parse_flavors()

from synnefo_tools.burnin.common import BurninTests, Proper, \

    QPITHOS, QADD, QREMOVE

            size = os.fstat(fout.fileno()).st_size

            changes = \

                {self._get_uuid(): [(QPITHOS, QADD, size, None)]}

            self._check_quotas(changes)

        changes = \

            {self._get_uuid(): [(QPITHOS, QREMOVE, content_length, None)]}

        self._check_quotas(changes)

import random

from synnefo_tools.burnin.common import Proper

from synnefo_tools.burnin.cyclades_common import CycladesTests

class QuotasTestSuite(CycladesTests):

    server = Proper(value=None)

    def test_002_create(self):

        """Create a machine to a different project than base"""

        image = random.choice(self._parse_images())

        flavors = self._parse_flavors()

        # We want to create our machine in a project other than 'base'

        projects = self.quotas.keys()

        projects.remove(self._get_uuid())

        (flavor, project) = self._find_project(flavors, projects)

        # Create machine

        self.server = self._create_server(image, flavor, network=True,

                                          project_id=project)

        # Wait for server to become active

        self._insist_on_server_transition(

            self.server, ["BUILD"], "ACTIVE")

from synnefo_tools.burnin.common import Proper

class ServerTestSuite(CycladesTests):

        self.avail_images = self._parse_images()

        self.avail_flavors = self._parse_flavors()