Пример #1
0
    def _req_to_bkr_job(self, req):
        """Transform requirement to beaker job xml."""
        specs = deepcopy(req)  # work with own copy, do not modify the input

        # Job attributes:
        specs.update({"retention_tag": "audit"})
        specs.update({"product": "[internal]"})
        specs.update({"whiteboard": "This job has been created using mrack."})

        # RecipeSet attributes
        specs.update({"priority": "Normal"})

        # Add allowed keys
        specs.update({"ks_append": self._allow_ssh_key(self.pubkey)})

        # Use ks_meta
        specs.update({"ks_meta": "harness='restraint-rhts beakerlib-redhat'"})

        # Recipe task definition
        specs.update(
            {  # we use dummy task because beaker reuire a task in recipe
                "tasks": [{"name": "/distribution/dummy", "role": "STANDALONE"}]
            }
        )

        # Create recipe with the specifications
        recipe = BeakerRecipe(**specs)
        recipe.addBaseRequires(**specs)

        # Specify the architecture
        arch_node = xml_doc().createElement("distro_arch")
        arch_node.setAttribute("op", "=")
        arch_node.setAttribute("value", specs["arch"])
        recipe.addDistroRequires(arch_node)

        # Specify the custom xml distro_tag node with values from provisioning config
        distro_tags = global_context["config"]["beaker"].get("distro_tags")
        if distro_tags:
            for tag in distro_tags.get(specs["distro"], []):
                tag_node = xml_doc().createElement("distro_tag")
                tag_node.setAttribute("op", "=")
                tag_node.setAttribute("value", tag)
                recipe.addDistroRequires(tag_node)

        # Add ReserveSys element to reserve system after provisioning
        recipe.addReservesys(duration=str(self.reserve_duration))

        for task in specs["tasks"]:
            recipe.addTask(task=task["name"], role=task["role"])

        # Create RecipeSet and add our Recipe to it.
        recipe_set = BeakerRecipeSet(**specs)
        recipe_set.addRecipe(recipe)

        # Create job instance and inject created RecipeSet to it
        job = BeakerJob(**specs)
        job.addRecipeSet(recipe_set)

        return job
    def run(self, *args, **kwargs):
        whiteboard = kwargs.pop('whiteboard')
        # We treat these options as filters, meaning if nothing is given we 
        # will run all possible combinations.
        kwargs.pop('family')
        requested_distro = kwargs.pop('distro')
        requested_variant = kwargs.pop('variant')
        requested_arches = kwargs.pop('arches')

        self.set_hub(**kwargs)

        job = BeakerJob(whiteboard=whiteboard, **kwargs)

        for distro, variant, arch, harness in distros_variants_arches_harness(multihost=False):
            if requested_distro and requested_distro != distro:
                continue
            if requested_variant and requested_variant != variant:
                continue
            if requested_arches and arch not in requested_arches:
                continue
            task_names = [
                '/distribution/beaker/Sanity/Skip-result',
                '/distribution/beaker/Sanity/reboot-tests',
            ]
            if distro not in ext4_unsupported_distros:
                task_names.append('/CoreOS/examples/Sanity/ext4-test')
            recipe = self.recipe(harness, distro, variant, arch, task_names=task_names, **kwargs)
            job.addRecipe(recipe)

        for distro, variant, arch, harness in distros_variants_arches_harness(multihost=True):
            if requested_distro and requested_distro != distro:
                continue
            if requested_variant and requested_variant != variant:
                continue
            if requested_arches and arch not in requested_arches:
                continue

            rs = BeakerRecipeSet(**kwargs)
            for role in ['SERVERS', 'CLIENTONE', 'CLIENTTWO']:
                recipe = self.recipe(harness, distro, variant, arch,
                        task_names=['/distribution/beaker/Sanity/sync-set_block-tests'],
                        role=role, **kwargs)
                rs.addRecipe(recipe)
            job.addRecipeSet(rs)

        jobxml = job.toxml(**kwargs)
        if kwargs.get('debug', False):
            print job.node.toprettyxml()
        if not kwargs.get('dryrun', False):
            t_id = self.hub.jobs.upload(jobxml)
            print 'Submitted: %s' % [t_id]
Пример #3
0
    def run(self, *args, **kwargs):
        debug = kwargs.get("debug", False)
        dryrun = kwargs.get("dryrun", False)
        family = kwargs.get("family", None)
        distro = kwargs.get("distro", None)
        arches = kwargs.get("arches", [])
        taskParams = kwargs.get("taskparam", [])
        ksTemplate = kwargs.get("template", None)

        # todo: fetch family mapping based on distro from the server
        if not family and not distro:
            sys.stderr.write("No Family or Distro specified\n")
            sys.exit(1)

        if not arches:
            sys.stderr.write(
                "No arches specified, you must specify at least one\n")
            sys.exit(1)

        if not ksTemplate:
            sys.stderr.write(
                "You must specify kickstart template to run this workflow\n")
            sys.exit(1)

        if family:
            kwargs['os_major'] = int(self._get_os_major_version(family))
        else:  # get family data based on distro
            if not hasattr(self, 'hub'):
                self.set_hub(**kwargs)

            # this will return info about all arches and variants
            # but the family string is the same so break after the first iteration
            for distro in self.hub.distrotrees.filter({
                    'name': distro,
                    'family': family
            }):
                family = distro[
                    "distro_osmajor"]  # e.g. RedHatEnterpriseLinux6
                os_version = distro[
                    "distro_osversion"]  # e.g. RedHatEnterpriseLinux6.3
                kwargs["os_major"] = int(self._get_os_major_version(family))
                kwargs["family"] = family
                kwargs["os_minor"] = int(
                    os_version.replace(family, "").replace(".", ""))
                break

        # Add kickstart and kernel options
        ks_args = {}

        # make ksmeta from command line options and taskParams
        for parameter in [
                "distro", "family", "variant", "os_major", "os_minor"
        ]:
            if kwargs.get(parameter, None):
                ks_args[parameter.upper()] = kwargs.get(parameter)

        # allow taskParams to override existing values
        try:
            for param in taskParams:
                (name, value) = param.split('=', 1)
                # use both upper case and regular case variable names
                ks_args[name.upper()] = value
                ks_args[name] = value
        except:
            print >> sys.stderr, "Every task param has to have a value."
            sys.exit(1)

        if kwargs['kernel_options'] is None:
            kwargs['kernel_options'] = ""
        pristine_kernel_options = kwargs['kernel_options']

        # get all tasks requested
        requestedTasks = self.getTasks(*args, **kwargs)

        # Create Job
        job = BeakerJob(*args, **kwargs)

        # Add Host Requirements
        for arch in arches:
            ks_args["ARCH"] = arch
            # Create Base Recipe
            recipeTemplate = BeakerRecipe()
            # get kickstart and add it to recipes
            kickstart = generateKickstart(ksTemplate, ks_args)
            kernel_options = generateKernelOptions(ksTemplate, ks_args)

            kwargs[
                'kernel_options'] = pristine_kernel_options + " " + kernel_options
            kwargs['kernel_options'] = kwargs['kernel_options'].strip()

            recipeTemplate.addKickstart(kickstart)

            # Add Distro Requirements
            recipeTemplate.addBaseRequires(*args, **kwargs)

            arch_node = self.doc.createElement('distro_arch')
            arch_node.setAttribute('op', '=')
            arch_node.setAttribute('value', arch)
            recipeSet = BeakerRecipeSet(**kwargs)
            if self.multi_host:
                for i in range(self.n_servers):
                    recipeSet.addRecipe(
                        self.processTemplate(recipeTemplate,
                                             requestedTasks,
                                             taskParams=taskParams,
                                             distroRequires=arch_node,
                                             role='SERVERS',
                                             arch=arch,
                                             **kwargs))
                for i in range(self.n_clients):
                    recipeSet.addRecipe(
                        self.processTemplate(recipeTemplate,
                                             requestedTasks,
                                             taskParams=taskParams,
                                             distroRequires=arch_node,
                                             role='CLIENTS',
                                             arch=arch,
                                             **kwargs))
                job.addRecipeSet(recipeSet)
            else:
                recipe = self.processTemplate(recipeTemplate,
                                              requestedTasks,
                                              taskParams=taskParams,
                                              distroRequires=arch_node,
                                              arch=arch,
                                              **kwargs)
                recipeSet.addRecipe(recipe)
                job.addRecipeSet(recipeSet)

        # jobxml
        jobxml = job.toxml(**kwargs)

        if debug:
            print jobxml

        if not dryrun:
            if not hasattr(self, 'hub'):
                self.set_hub(**kwargs)
            try:
                job = self.hub.jobs.upload(jobxml)
            except Exception, ex:
                print >> sys.stderr, unicode(ex)
                sys.exit(1)
            else:
                print "Submitted: %s" % job
Пример #4
0
    def run(self, *args, **kwargs):
        self.set_hub(**kwargs)

        debug = kwargs.get("debug", False)
        dryrun = kwargs.get("dryrun", False)
        wait = kwargs.get("wait", False)
        machine = kwargs.get("machine", None)
        family = kwargs.get("family", [])
        taskParams = kwargs.get("taskparam", [])

        # Add in Inventory if requested
        if kwargs.get("inventory"):
            kwargs['task'].append('/distribution/inventory')

        if not machine:
            self.parser.error('Use --machine to specify machine to be tested')

        if not kwargs.get("whiteboard"):
            kwargs["whiteboard"] = "Test %s" % machine

        # If family is specified on command line just do it.
        if family:
            if not kwargs['arches']:
                self.parser.error(
                    "If family is specified you must specify arches as well")
            families = dict((family, [arch for arch in kwargs['arches']])
                            for family in family)
        else:
            families = self.get_system_os_major_arches(*args, **kwargs)

        # Exit early
        if not families:
            sys.stderr.write(
                'Could not find an appropriate distro to provision system with.'
            )
            sys.exit(1)

        # Create Job
        job = BeakerJob(*args, **kwargs)

        for family, arches in families.items():
            kwargs['family'] = family
            # get all tasks requested
            requestedTasks = self.get_tasks(*args, **kwargs)
            # If arch is specified on command line limit to just those. (if they match)
            if kwargs['arches']:
                arches = set(kwargs['arches']).intersection(set(arches))
            for arch in arches:
                recipeTemplate = BeakerRecipe()
                # Add Distro Requirements
                temp = dict(kwargs)
                temp['family'] = family
                recipeTemplate.add_base_requires(*args, **temp)
                arch_node = self.doc.createElement('distro_arch')
                arch_node.setAttribute('op', '=')
                arch_node.setAttribute('value', arch)
                recipe_set = BeakerRecipeSet(**kwargs)
                recipe_set.add_recipe(
                    self.process_template(recipeTemplate,
                                          requestedTasks,
                                          taskParams=taskParams,
                                          allow_empty_recipe=True,
                                          distroRequires=arch_node,
                                          **temp))
                job.add_recipe_set(recipe_set)

        # jobxml
        jobxml = job.toxml(**kwargs)

        if debug:
            print(jobxml)

        submitted_jobs = []
        failed = False

        if not dryrun:
            try:
                submitted_jobs.append(self.hub.jobs.upload(jobxml))
            except Exception as ex:
                failed = True
                sys.stderr.write(ex)
        if not dryrun:
            print("Submitted: %s" % submitted_jobs)
            if wait:
                watch_tasks(self.hub, submitted_jobs)
            if failed:
                sys.exit(1)
Пример #5
0
    def run(self, *args, **kwargs):
        self.set_hub(**kwargs)

        debug = kwargs.get("debug", False)
        dryrun = kwargs.get("dryrun", False)
        wait = kwargs.get("wait", False)
        family = kwargs.get("family", None)
        distro = kwargs.get("distro", None)
        machine = kwargs.get("machine", None)
        arches = kwargs.get("arches", [])
        if machine:
            kwargs['ignore_system_status'] = True
            if not arches:
                arches = [self.default_distro_tree(machine)['arch']]
            if not family and not distro:
                kwargs['distro'] = self.default_distro_tree(
                    machine)['distro']['name']
        else:
            if not family and not distro:
                sys.stderr.write("No Family or Distro specified\n")
                sys.exit(1)
            # defaults to 'x86_64' instead of all the known arches
            if not arches:
                arches = ['x86_64']
        kwargs['reserve'] = True

        # Create Job
        job = BeakerJob(*args, **kwargs)

        # Create Base Recipe
        recipeTemplate = BeakerRecipe()

        # Add Distro Requirements
        recipeTemplate.addBaseRequires(*args, **kwargs)

        for arch in arches:
            arch_node = self.doc.createElement('distro_arch')
            arch_node.setAttribute('op', '=')
            arch_node.setAttribute('value', arch)
            recipeSet = BeakerRecipeSet(**kwargs)
            recipeSet.addRecipe(
                self.processTemplate(recipeTemplate, [],
                                     distroRequires=arch_node,
                                     **kwargs))
            job.addRecipeSet(recipeSet)

        # jobxml
        jobxml = job.toxml(**kwargs)
        if debug:
            print jobxml
        if not dryrun:
            try:
                job = self.hub.jobs.upload(jobxml)
                print "Submitted: %s" % job
            except (KeyboardInterrupt, SystemExit):
                raise
            except Exception, ex:
                sys.stderr.write('Exception: %s\n' % ex)
                sys.exit(1)
            if wait:
                sys.exit(watch_tasks(self.hub, [job]))
Пример #6
0
    def provision(self, *args, **kwargs):
        """
            provision resources in Beaker
        """
        # Break down kwargs for debug, dryrun, recipesets, and whiteboard
        debug = kwargs.get("debug", False)
        dryrun = kwargs.get("dryrun", False)
        recipesets = kwargs.get("recipesets", [])

        # Create Job
        job = BeakerJob(*args, **kwargs)

        # Add All Host Requirements
        for recipeset in recipesets:
            kwargs = self.create_recipesets(recipeset, **kwargs)
            family = kwargs.get("family", None)
            distro = kwargs.get("distro", None)
            task_params = kwargs.get("taskparam", [])
            # tasks are list of dictionaries which follows format
            # for beaker in a box
            # tasks = [ {arches:[], 'name': '/distribution/utils/dummy'}]
            # for beaker production
            # tasks = [ {arches:[], 'name': '/distribution/dummy'}]
            tasks = kwargs.get("tasks", [{
                'arches': [],
                'name': '/distribution/dummy'
            }])
            arch = kwargs.get("arch", "x86_64")
            ks_meta = kwargs.get("ks_meta", "")
            method = kwargs.get("method", "nfs")
            priority = kwargs.get("priority", "Normal")
            hostrequires = kwargs.get("hostrequires", [])
            reserve_duration = kwargs.get("reserve_duration", None)
            if reserve_duration:
                kwargs.update({"reserve_duration": "%s" % reserve_duration})
            tags = kwargs.get("tags", [])
            if tags:
                kwargs.update({"tag": tags})

            requested_tasks = []

            # adding arches=[] to every task definition
            for task in tasks:
                if not ('arches' in task.keys()):
                    task['arches'] = []
                requested_tasks.append(task)

            # Tasks and harnesses
            if 'harness' in ks_meta:
                # Disable report plugins
                task_params.append("RSTRNT_DISABLED=01_dmesg_check "
                                   "10_avc_check")

                # Reserve the system after its installed
                kwargs.update({"reserve": True})
                # We don't need to run a task but beaker needs one.
                # therefore its defaulted to
                # [{arches:[], 'name': '/distribution/dummy'}]
                # if no repos are defined but with no value use default repo
                # This default will not work for Fedora
                repos = kwargs.get("repos", [
                    "http://file.bos.redhat.com/~bpeck/restraint/rhel"
                    "$releasever"
                ])
                kwargs.update({'repo': repos})
            else:
                requested_tasks.append({
                    'arches': [],
                    'name': '/distribution/reservesys'
                })

            # Update defaults
            kwargs.update({"suppress_install_task": True})
            kwargs.update({"method": method})
            kwargs.update({"priority": priority})

            # Must have family or distro
            if not family and not distro and not arch:
                sys.stderr.write("No Family or Distro and arch specified\n")
                sys.exit(1)

            if not requested_tasks:
                sys.stderr.write("You must specify a task to run\n")
                sys.exit(1)

            # Create Workflow
            wrkflow = BeakerWorkflow('BeakerWorkflow')

            # Create Base Recipe
            recipe_template = BeakerRecipe(*args, **kwargs)

            # Add Host Requirements
            for requirement in hostrequires:
                if 'force' in requirement:
                    # hostRequires element is created by BeakerRecipe, use it
                    hostrequires_node = recipe_template.node.getElementsByTagName(
                        'hostRequires')[0]  # noqa E501
                    # all other filters are ignored if the hostname is forced,
                    # so the use of 'force' is mutually exclusive with the use
                    # of any other 'hostRequires' filters
                    hostrequires_node.setAttribute('force',
                                                   requirement['force'])
                elif 'rawxml' in requirement:
                    requirement_node = xml.dom.minidom.parseString(
                        requirement['rawxml']).documentElement
                    recipe_template.addHostRequires(requirement_node)
                else:
                    # If force is not used, a requirement can be any number
                    # of differently formatted XML elements, each with their
                    # own combination of element name and valid attrs. So,
                    # the best we can do is generate XML based on the input,
                    # and only the "tag" key is required.
                    tag_name = requirement['tag']
                    requirement_node = self.doc.createElement(tag_name)
                    for attr, value in requirement.items():
                        # Force all values to str, which the XML writer expects.
                        requirement_node.setAttribute(attr, str(value))
                    # use the BeakerRecipe API to add the element
                    recipe_template.addHostRequires(requirement_node)

            # Add Distro Requirements
            recipe_template.addBaseRequires(*args, **kwargs)
            arch_node = self.doc.createElement('distro_arch')
            arch_node.setAttribute('op', '=')
            arch_node.setAttribute('value', arch)
            recipe_set = BeakerRecipeSet(**kwargs)
            if wrkflow.multi_host:
                for i in range(self.n_servers):
                    recipe_set.addRecipe(
                        wrkflow.processTemplate(recipe_template,
                                                requested_tasks,
                                                taskParams=task_params,
                                                distroRequires=arch_node,
                                                role='SERVERS',
                                                **kwargs))
                for i in range(self.n_clients):
                    recipe_set.addRecipe(
                        wrkflow.processTemplate(recipe_template,
                                                requested_tasks,
                                                taskParams=task_params,
                                                distroRequires=arch_node,
                                                role='CLIENTS',
                                                **kwargs))
            else:
                recipe_set.addRecipe(
                    wrkflow.processTemplate(recipe_template,
                                            requested_tasks,
                                            taskParams=task_params,
                                            distroRequires=arch_node,
                                            **kwargs))
            job.addRecipeSet(recipe_set)

        # jobxml
        jobxml = job.toxml(**kwargs)

        if debug:
            LOG.debug(jobxml)

        self.submitted_jobs = []

        if not dryrun:
            self.submitted_jobs.append(self.hub.jobs.upload(jobxml))
            LOG.info("Submitted: %s" % self.submitted_jobs)
        return self.submitted_jobs
Пример #7
0
    def run(self, *args, **kwargs):

        if not kwargs.get("package", []) and not kwargs.get("task", []) \
                and not kwargs.get("taskfile", []) and not kwargs.get("type", []):
            self.parser.error('No tasks specified to be run\nHint: '
                              'Use --task, --package, --taskfile or --task-type to select tasks\n')

        self.set_hub(**kwargs)

        debug = kwargs.get("debug", False)
        dryrun = kwargs.get("dryrun", False)
        wait = kwargs.get("wait", False)
        family = kwargs.get("family", None)
        distro = kwargs.get("distro", None)
        arches = kwargs.get("arches", [])
        taskParams = kwargs.get("taskparam", [])

        if not family and not distro:
            sys.stderr.write("No Family or Distro specified\n")
            sys.exit(1)

        if not arches:
            # Get default arches that apply for this distro/family
            arches = self.getArches(*args, **kwargs)

        # get all tasks requested
        try:
            requestedTasks = self.getTasks(*args, **kwargs)
        except xmlrpclib.Fault:
            requestedTasks = None

        if not requestedTasks:
            sys.stderr.write("No tasks match the specified option(s)\n")
            sys.exit(1)

        # Create Job
        job = BeakerJob(*args, **kwargs)

        # Create Base Recipe
        recipeTemplate = BeakerRecipe()

        # Add Distro Requirements
        recipeTemplate.addBaseRequires(*args, **kwargs)

        # Add Host Requirements


        for arch in arches:
            arch_node = self.doc.createElement('distro_arch')
            arch_node.setAttribute('op', '=')
            arch_node.setAttribute('value', arch)
            recipeSet = BeakerRecipeSet(**kwargs)
            if self.multi_host:
                for i in range(self.n_servers):
                    recipeSet.addRecipe(self.processTemplate(recipeTemplate, 
                                                             requestedTasks,
                                                             taskParams=taskParams,
                                                             distroRequires=arch_node, 
                                                             role='SERVERS',
                                                             arch=arch,
                                                             **kwargs))
                for i in range(self.n_clients):
                    recipeSet.addRecipe(self.processTemplate(recipeTemplate, 
                                                             requestedTasks,
                                                             taskParams=taskParams,
                                                             distroRequires=arch_node, 
                                                             role='CLIENTS',
                                                             arch=arch,
                                                             **kwargs))
            else:
                recipeSet.addRecipe(self.processTemplate(recipeTemplate,
                                                         requestedTasks,
                                                         taskParams=taskParams,
                                                         distroRequires=arch_node,
                                                         arch=arch,
                                                         **kwargs))
            job.addRecipeSet(recipeSet)

        # jobxml
        jobxml = job.toxml(**kwargs)

        if debug:
            print jobxml

        submitted_jobs = []
        is_failed = False

        if not dryrun:
            try:
                submitted_jobs.append(self.hub.jobs.upload(jobxml))
                print "Submitted: %s" % submitted_jobs
            except (KeyboardInterrupt, SystemExit):
                raise
            except Exception, ex:
                is_failed = True
                sys.stderr.write('Exception: %s\n' % ex)
            if wait:
                is_failed |= watch_tasks(self.hub, submitted_jobs)
Пример #8
0
    def run(self, *args, **kwargs):
        self.set_hub(**kwargs)

        debug = kwargs.pop('debug', False)
        dryrun = kwargs.pop('dryrun', False)
        wait = kwargs.pop('wait', False)
        taskParams = kwargs.pop('taskparam', [])
        families = kwargs.pop('family', [])
        kwargs.pop('variant', None)
        kwargs.pop('arch', None)

        if not kwargs.get('whiteboard'):
            kwargs['whiteboard'] = 'Test harness installation'

        if not families:
            families = self.get_os_majors(**kwargs)
            # filter out any junky old distros with no family
            families = [f for f in families if f]

        fva = set()  # all family-variant-arch combinations
        for family in families:
            dts = self.hub.distrotrees.filter({'family': family})
            for dt in dts:
                fva.add((family, dt['variant'] or '', dt['arch']))
            # if this family has any variants, discard combinations which have blank variant
            if any(f == family and v for f, v, a in fva):
                fva.difference_update([(f, v, a) for f, v, a in fva
                                       if f == family and not v])

        job = BeakerJob(**kwargs)
        for family, variant, arch in sorted(fva):
            requestedTasks = self.get_tasks(family=family, **kwargs)
            recipe = BeakerRecipe()
            recipe.add_base_requires(family=family, variant=variant, arch=arch, **kwargs)
            arch_node = self.doc.createElement('distro_arch')
            arch_node.setAttribute('op', '=')
            arch_node.setAttribute('value', arch)
            recipe = self.process_template(recipe, requestedTasks, taskParams=taskParams,
                                           distroRequires=arch_node, arch=arch, family=family,
                                           allow_empty_recipe=True, **kwargs)
            recipe.whiteboard = ' '.join([family, variant, arch])
            recipeset = BeakerRecipeSet(**kwargs)
            recipeset.add_recipe(recipe)
            job.add_recipe_set(recipeset)

        jobxml = job.toxml(**kwargs)

        if debug:
            print(jobxml)

        submitted_jobs = []
        failed = False

        if not dryrun:
            try:
                submitted_jobs.append(self.hub.jobs.upload(jobxml))
                print("Submitted: %s" % submitted_jobs)
            except (KeyboardInterrupt, SystemError):
                raise
            except Exception as ex:
                failed = True
                sys.stderr.write('Exception: %s\n' % ex)
            if wait:
                failed |= watch_tasks(self.hub, submitted_jobs)
        sys.exit(failed)
Пример #9
0
    def provision(self, *args, **kwargs):
        """
            provision resources in Beaker
        """
        # Break down kwargs for debug, dryrun, wait, and recipesets
        debug = kwargs.get("debug", False)
        dryrun = kwargs.get("dryrun", False)
        wait = kwargs.get("wait", False)
        recipesets = kwargs.get("recipesets", [])

        # Create Job
        job = BeakerJob(*args, **kwargs)

        # Add All Host Requirements
        for recipeset in recipesets:
            kwargs = self.create_recipesets(recipeset, **kwargs)
            family = kwargs.get("family", None)
            distro = kwargs.get("distro", None)
            task_params = kwargs.get("taskparam", [])
            arch = kwargs.get("arch", None)
            ks_meta = kwargs.get("ks_meta", "")
            method = kwargs.get("method", "nfs")
            priority = kwargs.get("priority", "Normal")

            # Tasks and harnesses
            if 'harness' in ks_meta:
                # Disable report plugins
                task_params.append("RSTRNT_DISABLED=01_dmesg_check "
                                   "10_avc_check")

                # Reserve the system after its installed
                kwargs.update({"reserve": True})
                # We don't need to run a task but beaker needs one.
                requested_tasks = \
                    [{'arches': [], 'name': '/distribution/dummy'}]

                # if no repos are defined but with no value use default repo
                # This default will not work for Fedora
                repos = kwargs.get("repos", [
                    "http://file.bos.redhat.com/~bpeck/restraint/rhel"
                    "$releasever"
                ])
                kwargs.update({'repo': repos})
            else:
                requested_tasks = \
                    [{'arches': [], 'name': '/distribution/dummy'},
                     {'arches': [], 'name': '/distribution/reservesys'}]

            # Update defaults
            kwargs.update({"suppress_install_task": True})
            kwargs.update({"method": method})
            kwargs.update({"priority": priority})

            # Must have family or distro
            if not family and not distro and not arch:
                sys.stderr.write("No Family or Distro and arch specified\n")
                sys.exit(1)

            if not requested_tasks:
                sys.stderr.write("You must specify a task to run\n")
                sys.exit(1)

            # Create Workflow
            wrkflow = BeakerWorkflow('BeakerWorkflow')

            # Create Base Recipe
            recipe_template = BeakerRecipe(*args, **kwargs)

            # Add Distro Requirements
            recipe_template.addBaseRequires(*args, **kwargs)
            arch_node = self.doc.createElement('distro_arch')
            arch_node.setAttribute('op', '=')
            arch_node.setAttribute('value', arch)
            recipe_set = BeakerRecipeSet(**kwargs)
            if wrkflow.multi_host:
                for i in range(self.n_servers):
                    recipe_set.addRecipe(
                        wrkflow.processTemplate(recipe_template,
                                                requested_tasks,
                                                taskParams=task_params,
                                                distroRequires=arch_node,
                                                role='SERVERS',
                                                **kwargs))
                for i in range(self.n_clients):
                    recipe_set.addRecipe(
                        wrkflow.processTemplate(recipe_template,
                                                requested_tasks,
                                                taskParams=task_params,
                                                distroRequires=arch_node,
                                                role='CLIENTS',
                                                **kwargs))
            else:
                recipe_set.addRecipe(
                    wrkflow.processTemplate(recipe_template,
                                            requested_tasks,
                                            taskParams=task_params,
                                            distroRequires=arch_node,
                                            **kwargs))
            job.addRecipeSet(recipe_set)

        # jobxml
        jobxml = job.toxml(**kwargs)

        if debug:
            LOG.debug(jobxml)

        self.submitted_jobs = []
        is_failed = False

        if not dryrun:
            try:
                self.submitted_jobs.append(self.hub.jobs.upload(jobxml))
                LOG.info("Submitted: %s" % self.submitted_jobs)
                return self.submitted_jobs
            except (KeyboardInterrupt, SystemExit):
                raise
            except Exception, ex:
                is_failed = True
                sys.stderr.write('Exception: %s\n' % ex)
            if wait:
                is_failed |= watch_tasks(self.hub, self.submitted_jobs)
Пример #10
0
    def provision(self, *args, **kwargs):
        """
            provision resources in Beaker
        """
        # Break down kwargs for debug, dryrun, recipesets, and whiteboard
        debug = kwargs.get("debug", False)
        dryrun = kwargs.get("dryrun", False)
        recipesets = kwargs.get("recipesets", [])
        keys_path = kwargs.get('ssh_keys_path', '')

        # Create Job
        job = BeakerJob(*args, **kwargs)

        # Add All Host Requirements
        for recipeset in recipesets:
            kwargs = self.create_recipesets(recipeset, **kwargs)
            family = kwargs.get("family", None)
            distro = kwargs.get("distro", None)
            task_params = kwargs.get("taskparam", [])
            # tasks are list of dictionaries which follows format
            # for beaker in a box
            # tasks = [ {arches:[], 'name': '/distribution/utils/dummy'}]
            # for beaker production
            # tasks = [ {arches:[], 'name': '/distribution/dummy'}]
            tasks = kwargs.get("tasks", [{
                'arches': [],
                'name': '/distribution/dummy'
            }])
            arch = kwargs.get("arch", "x86_64")
            ks_meta = kwargs.get("ks_meta", "")
            method = kwargs.get("method", "nfs")
            priority = kwargs.get("priority", "Normal")
            hostrequires = kwargs.get("hostrequires", [])
            reserve_duration = kwargs.get("reserve_duration", None)
            if reserve_duration:
                kwargs.update({"reserve_duration": "%s" % reserve_duration})
            tags = kwargs.get("tags", [])
            if tags:
                kwargs.update({"tag": tags})
            repos = kwargs.get("repos", [])
            baseurls = []
            for repo in repos:
                if "baseurl" in repo:
                    baseurls.append(repo.get("baseurl"))
            else:
                kwargs.update({"repo": baseurls})
            ks_append = kwargs.get("ks_append", [])
            ssh_key = kwargs.get("ssh_key", [])

            for key_file in kwargs.get("ssh_key_file", []):
                file_path = os.path.join(keys_path, key_file)
                try:
                    with open(file_path, "r") as f:
                        ssh_key.append(f.read())
                except (OSError, IOError):
                    LOG.info("Unable to read from ssh key file: %s" %
                             file_path)

            if ssh_key:
                ks_append.append("""%%post
mkdir -p /root/.ssh
cat >>/root/.ssh/authorized_keys << "__EOF__"
%s
__EOF__
restorecon -R /root/.ssh
chmod go-w /root /root/.ssh /root/.ssh/authorized_keys
%%end""" % '\n'.join(ssh_key))
                kwargs.update({"ks_append": ks_append})

            requested_tasks = []

            # adding arches=[] to every task definition
            for task in tasks:
                if not ('arches' in list(task.keys())):
                    task['arches'] = []
                requested_tasks.append(task)

            # Tasks and harnesses
            if 'harness' in ks_meta:
                # Disable report plugins
                task_params.append("RSTRNT_DISABLED=01_dmesg_check "
                                   "10_avc_check")

                # Reserve the system after its installed
                kwargs.update({"reserve": True})
            else:
                requested_tasks.append({
                    'arches': [],
                    'name': '/distribution/reservesys'
                })
                if reserve_duration:
                    task_params.append("RESERVETIME=%s" % reserve_duration)

            # Update defaults
            kwargs.update({"suppress_install_task": True})
            kwargs.update({"method": method})
            kwargs.update({"priority": priority})

            # Must have family or distro
            if not family and not distro and not arch:
                sys.stderr.write("No Family or Distro and arch specified\n")
                sys.exit(1)

            if not requested_tasks:
                sys.stderr.write("You must specify a task to run\n")
                sys.exit(1)

            # Create Workflow
            wrkflow = BeakerWorkflow('BeakerWorkflow')

            # Create Base Recipe
            recipe_template = BeakerRecipe(*args, **kwargs)

            # Add Host Requirements
            for requirement in hostrequires:
                if 'force' in requirement:
                    # hostRequires element is created by BeakerRecipe, use it
                    hostrequires_node = recipe_template.node.getElementsByTagName(
                        'hostRequires')[0]  # noqa E501
                    # all other filters are ignored if the hostname is forced,
                    # so the use of 'force' is mutually exclusive with the use
                    # of any other 'hostRequires' filters
                    hostrequires_node.setAttribute('force',
                                                   requirement['force'])
                elif 'rawxml' in requirement:
                    requirement_node = xml.dom.minidom.parseString(
                        requirement['rawxml']).documentElement
                    recipe_template.addHostRequires(requirement_node)
                else:
                    # If force is not used, a requirement can be any number
                    # of differently formatted XML elements, each with their
                    # own combination of element name and valid attrs. So,
                    # the best we can do is generate XML based on the input,
                    # and only the "tag" key is required.
                    tag_name = requirement['tag']
                    requirement_node = self.doc.createElement(tag_name)
                    for attr, value in requirement.items():
                        # Force all values to str, which the XML writer expects.
                        requirement_node.setAttribute(attr, str(value))
                    # use the BeakerRecipe API to add the element
                    recipe_template.addHostRequires(requirement_node)

            # Add Distro Requirements
            recipe_template.addBaseRequires(*args, **kwargs)
            for partition in kwargs.get("partitions", []):
                recipe_template.addPartition(**partition)
            arch_node = self.doc.createElement('distro_arch')
            arch_node.setAttribute('op', '=')
            arch_node.setAttribute('value', arch)
            recipe_set = BeakerRecipeSet(**kwargs)
            if wrkflow.multi_host:
                for i in range(self.n_servers):
                    recipe_set.addRecipe(
                        wrkflow.processTemplate(recipe_template,
                                                requested_tasks,
                                                taskParams=task_params,
                                                distroRequires=arch_node,
                                                role='SERVERS',
                                                **kwargs))
                for i in range(self.n_clients):
                    recipe_set.addRecipe(
                        wrkflow.processTemplate(recipe_template,
                                                requested_tasks,
                                                taskParams=task_params,
                                                distroRequires=arch_node,
                                                role='CLIENTS',
                                                **kwargs))
            else:
                recipe_set.addRecipe(
                    wrkflow.processTemplate(recipe_template,
                                            requested_tasks,
                                            taskParams=task_params,
                                            distroRequires=arch_node,
                                            **kwargs))
            job.addRecipeSet(recipe_set)

        # jobxml
        jobxml = job.toxml(**kwargs)

        if debug:
            LOG.debug(jobxml)

        self.submitted_jobs = []

        if not dryrun:
            self.submitted_jobs.append(self.hub.jobs.upload(jobxml))
            LOG.info("Submitted: %s" % self.submitted_jobs)
        return self.submitted_jobs