Synnefo

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)