teuthology 1.1.0__py3-none-any.whl → 1.2.0__py3-none-any.whl

teuthology/suite/placeholder.py

@@ -45,13 +45,13 @@ def substitute_placeholders(input_dict, values_dict):
 # Template for the config that becomes the base for each generated job config
 dict_templ = {
     'branch': Placeholder('ceph_branch'),
+    'expire': Placeholder('expire'),
     'sha1': Placeholder('ceph_hash'),
     'teuthology_branch': Placeholder('teuthology_branch'),
     'teuthology_sha1': Placeholder('teuthology_sha1'),
     'archive_upload': Placeholder('archive_upload'),
     'archive_upload_key': Placeholder('archive_upload_key'),
     'machine_type': Placeholder('machine_type'),
-    'nuke-on-error': True,
     'os_type': Placeholder('distro'),
     'os_version': Placeholder('distro_version'),
     'overrides': {
@@ -68,16 +68,13 @@ dict_templ = {
                     'debug mgr': 20,
                     'debug ms': 1},
                 'osd': {
-                    'debug filestore': 20,
-                    'debug journal': 20,
                     'debug ms': 1,
-                    'debug osd': 25
+                    'debug osd': 20
                 }
             },
-            'log-whitelist': ['\(MDS_ALL_DOWN\)',
-                              '\(MDS_UP_LESS_THAN_MAX\)'],
-            'log-ignorelist': ['\(MDS_ALL_DOWN\)',
-                              '\(MDS_UP_LESS_THAN_MAX\)'],
+            'flavor': Placeholder('flavor'),
+            'log-ignorelist': [r'\(MDS_ALL_DOWN\)',
+                              r'\(MDS_UP_LESS_THAN_MAX\)'],
             'sha1': Placeholder('ceph_hash'),
         },
         'ceph-deploy': {
@@ -86,13 +83,13 @@ dict_templ = {
                     'log file': '/var/log/ceph/ceph-$name.$pid.log'
                 },
                 'mon': {
-                    'osd default pool size': 2
                 }
             }
         },
         'install': {
             'ceph': {
                 'sha1': Placeholder('ceph_hash'),
+                'flavor': Placeholder('flavor'),
             }
         },
         'workunit': {

teuthology/suite/run.py

@@ -1,27 +1,30 @@
 import copy
+import datetime
 import logging
 import os
 import pwd
+import yaml
 import re
 import time
-import yaml
 
 from humanfriendly import format_timespan
 
-from datetime import datetime
 from tempfile import NamedTemporaryFile
+from teuthology import repo_utils
 
 from teuthology.config import config, JobConfig
 from teuthology.exceptions import (
-    BranchNotFoundError, CommitNotFoundError, VersionNotFoundError
+    BranchMismatchError, BranchNotFoundError, CommitNotFoundError,
 )
 from teuthology.misc import deep_merge, get_results_url
 from teuthology.orchestra.opsys import OS
 from teuthology.repo_utils import build_git_url
 
 from teuthology.suite import util
+from teuthology.suite.merge import config_merge
 from teuthology.suite.build_matrix import build_matrix
 from teuthology.suite.placeholder import substitute_placeholders, dict_templ
+from teuthology.util.time import parse_offset, parse_timestamp, TIMESTAMP_FMT
 
 log = logging.getLogger(__name__)
 
@@ -31,8 +34,7 @@ class Run(object):
     WAIT_PAUSE = 5 * 60
     __slots__ = (
         'args', 'name', 'base_config', 'suite_repo_path', 'base_yaml_paths',
-        'base_args', 'package_versions', 'kernel_dict', 'config_input',
-        'timestamp', 'user',
+        'base_args', 'kernel_dict', 'config_input', 'timestamp', 'user', 'os',
     )
 
     def __init__(self, args):
@@ -42,7 +44,7 @@ class Run(object):
         self.args = args
         # We assume timestamp is a datetime.datetime object
         self.timestamp = self.args.timestamp or \
-            datetime.now().strftime('%Y-%m-%d_%H:%M:%S')
+            datetime.datetime.now().strftime(TIMESTAMP_FMT)
         self.user = self.args.user or pwd.getpwuid(os.getuid()).pw_name
 
         self.name = self.make_run_name()
@@ -53,8 +55,6 @@ class Run(object):
             config.ceph_qa_suite_git_url = self.args.suite_repo
 
         self.base_config = self.create_initial_config()
-        # caches package versions to minimize requests to gbs
-        self.package_versions = dict()
 
         # Interpret any relative paths as being relative to ceph-qa-suite
         # (absolute paths are unchanged by this)
@@ -74,7 +74,7 @@ class Run(object):
                 self.args.suite,
                 self.args.ceph_branch,
                 self.args.kernel_branch or '-',
-                self.args.kernel_flavor, worker
+                self.args.flavor, worker
             ]
         ).replace('/', ':')
 
@@ -87,6 +87,16 @@ class Run(object):
 
         :returns: A JobConfig object
         """
+        now = datetime.datetime.now(datetime.timezone.utc)
+        expires = self.get_expiration()
+        if expires:
+            if now > expires:
+                util.schedule_fail(
+                    f"Refusing to schedule because the expiration date is in the past: {self.args.expire}",
+                    dry_run=self.args.dry_run,
+                )
+
+        self.os = self.choose_os()
         self.kernel_dict = self.choose_kernel()
         ceph_hash = self.choose_ceph_hash()
         # We don't store ceph_version because we don't use it yet outside of
@@ -98,7 +108,7 @@ class Run(object):
             self.suite_repo_path = self.args.suite_dir
         else:
             self.suite_repo_path = util.fetch_repos(
-                suite_branch, test_name=self.name)
+                suite_branch, test_name=self.name, dry_run=self.args.dry_run)
         teuthology_branch, teuthology_sha1 = self.choose_teuthology_branch()
 
 
@@ -115,15 +125,46 @@ class Run(object):
             teuthology_branch=teuthology_branch,
             teuthology_sha1=teuthology_sha1,
             machine_type=self.args.machine_type,
-            distro=self.args.distro,
-            distro_version=self.args.distro_version,
+            distro=self.os.name,
+            distro_version=self.os.version,
             archive_upload=config.archive_upload,
             archive_upload_key=config.archive_upload_key,
             suite_repo=config.get_ceph_qa_suite_git_url(),
             suite_relpath=self.args.suite_relpath,
+            flavor=self.args.flavor,
+            expire=expires.strftime(TIMESTAMP_FMT) if expires else None,
         )
         return self.build_base_config()
 
+    def get_expiration(self, _base_time: datetime.datetime | None = None) -> datetime.datetime | None:
+        """
+        _base_time: For testing, calculate relative offsets from this base time
+
+        :returns:   True if the job should run; False if it has expired
+        """
+        log.info(f"Checking for expiration ({self.args.expire})")
+        expires_str = self.args.expire
+        if expires_str is None:
+            return None
+        now = datetime.datetime.now(datetime.timezone.utc)
+        if _base_time is None:
+            _base_time = now
+        try:
+            expires = parse_timestamp(expires_str)
+        except ValueError:
+            expires = _base_time + parse_offset(expires_str)
+        return expires
+
+    def choose_os(self):
+        os_type = self.args.distro
+        os_version = self.args.distro_version
+        if not (os_type and os_version):
+            os_ = util.get_distro_defaults(
+                self.args.distro, self.args.machine_type)[2]
+        else:
+            os_ = OS(os_type, os_version)
+        return os_
+
     def choose_kernel(self):
         # Put together a stanza specifying the kernel hash
         if self.args.kernel_branch == 'distro':
@@ -134,20 +175,25 @@ class Run(object):
             kernel_hash = None
         else:
             kernel_hash = util.get_gitbuilder_hash(
-                'kernel', self.args.kernel_branch, self.args.kernel_flavor,
+                'kernel', self.args.kernel_branch, 'default',
                 self.args.machine_type, self.args.distro,
                 self.args.distro_version,
             )
             if not kernel_hash:
                 util.schedule_fail(
                     "Kernel branch '{branch}' not found".format(
-                     branch=self.args.kernel_branch)
+                     branch=self.args.kernel_branch),
+                     dry_run=self.args.dry_run,
                 )
+        kdb = True
+        if self.args.kdb is not None:
+            kdb = self.args.kdb
+
         if kernel_hash:
             log.info("kernel sha1: {hash}".format(hash=kernel_hash))
-            kernel_dict = dict(kernel=dict(kdb=True, sha1=kernel_hash))
+            kernel_dict = dict(kernel=dict(kdb=kdb, sha1=kernel_hash))
             if kernel_hash != 'distro':
-                kernel_dict['kernel']['flavor'] = self.args.kernel_flavor
+                kernel_dict['kernel']['flavor'] = 'default'
         else:
             kernel_dict = dict()
         return kernel_dict
@@ -160,6 +206,7 @@ class Run(object):
         """
         repo_name = self.ceph_repo_name
 
+        ceph_hash = None
         if self.args.ceph_sha1:
             ceph_hash = self.args.ceph_sha1
             if self.args.validate_sha1:
@@ -169,17 +216,18 @@ class Run(object):
                     self.args.ceph_sha1,
                     '%s.git' % repo_name
                 )
-                util.schedule_fail(message=str(exc), name=self.name)
+                util.schedule_fail(message=str(exc), name=self.name, dry_run=self.args.dry_run)
             log.info("ceph sha1 explicitly supplied")
 
         elif self.args.ceph_branch:
-            ceph_hash = util.git_ls_remote(repo_name, self.args.ceph_branch)
+            ceph_hash = util.git_ls_remote(
+                self.args.ceph_repo, self.args.ceph_branch)
             if not ceph_hash:
                 exc = BranchNotFoundError(
                     self.args.ceph_branch,
                     '%s.git' % repo_name
                 )
-                util.schedule_fail(message=str(exc), name=self.name)
+                util.schedule_fail(message=str(exc), name=self.name, dry_run=self.args.dry_run)
 
         log.info("ceph sha1: {hash}".format(hash=ceph_hash))
         return ceph_hash
@@ -188,13 +236,14 @@ class Run(object):
         if config.suite_verify_ceph_hash and not self.args.newest:
             # don't bother if newest; we'll search for an older one
             # Get the ceph package version
-            try:
-                ceph_version = util.package_version_for_hash(
-                    ceph_hash, self.args.kernel_flavor, self.args.distro,
-                    self.args.distro_version, self.args.machine_type,
-                )
-            except Exception as exc:
-                util.schedule_fail(str(exc), self.name)
+            ceph_version = util.package_version_for_hash(
+                ceph_hash, self.args.flavor, self.os.name,
+                self.os.version, self.args.machine_type,
+            )
+            if not ceph_version:
+                msg = f"Packages for os_type '{self.os.name}', flavor " \
+                    f"{self.args.flavor} and ceph hash '{ceph_hash}' not found"
+                util.schedule_fail(msg, self.name, dry_run=self.args.dry_run)
             log.info("ceph version: {ver}".format(ver=ceph_version))
             return ceph_version
         else:
@@ -219,7 +268,7 @@ class Run(object):
         of the teuthology config files ``$HOME/teuthology.yaml``
         or ``/etc/teuthology.yaml`` correspondingly.
 
-        Use ``master``.
+        Use ``main``.
 
         Generate exception if the branch is not present in the repo.
 
@@ -243,15 +292,32 @@ class Run(object):
                         log.warning(
                             'The teuthology branch config is empty, skipping')
         if not teuthology_branch:
-            teuthology_branch = config.get('teuthology_branch', 'master')
-
-        teuthology_sha1 = util.git_ls_remote(
-            'teuthology',
-            teuthology_branch
-        )
+            teuthology_branch = config.get('teuthology_branch')
+
+        if config.teuthology_path:
+            actual_branch = repo_utils.current_branch(config.teuthology_path)
+            if teuthology_branch and actual_branch != teuthology_branch:
+                raise BranchMismatchError(
+                    teuthology_branch,
+                    config.teuthology_path,
+                    "config.teuthology_path is set",
+                )
+            if not teuthology_branch:
+                teuthology_branch = actual_branch
+            teuthology_sha1 = util.git_ls_remote(
+                f"file://{config.teuthology_path}",
+                teuthology_branch
+            )
+        else:
+            if not teuthology_branch:
+                teuthology_branch = 'main'
+            teuthology_sha1 = util.git_ls_remote(
+                'teuthology',
+                teuthology_branch
+            )
         if not teuthology_sha1:
             exc = BranchNotFoundError(teuthology_branch, build_git_url('teuthology'))
-            util.schedule_fail(message=str(exc), name=self.name)
+            util.schedule_fail(message=str(exc), name=self.name, dry_run=self.args.dry_run)
         log.info("teuthology branch: %s %s", teuthology_branch, teuthology_sha1)
         return teuthology_branch, teuthology_sha1
 
@@ -271,32 +337,32 @@ class Run(object):
 
     @staticmethod
     def _repo_name(url):
-        return re.sub('\.git$', '', url.split('/')[-1])
+        return re.sub(r'\.git$', '', url.split('/')[-1])
 
     def choose_suite_branch(self):
         suite_repo_name = self.suite_repo_name
         suite_repo_project_or_url = self.args.suite_repo or 'ceph-qa-suite'
         suite_branch = self.args.suite_branch
         ceph_branch = self.args.ceph_branch
-        if suite_branch and suite_branch != 'master':
+        if suite_branch and suite_branch != 'main':
             if not util.git_branch_exists(
                 suite_repo_project_or_url,
                 suite_branch
             ):
                 exc = BranchNotFoundError(suite_branch, suite_repo_name)
-                util.schedule_fail(message=str(exc), name=self.name)
+                util.schedule_fail(message=str(exc), name=self.name, dry_run=self.args.dry_run)
         elif not suite_branch:
             # Decide what branch of the suite repo to use
             if util.git_branch_exists(suite_repo_project_or_url, ceph_branch):
                 suite_branch = ceph_branch
             else:
                 log.info(
-                    "branch {0} not in {1}; will use master for"
+                    "branch {0} not in {1}; will use main for"
                     " ceph-qa-suite".format(
                         ceph_branch,
                         suite_repo_name
                     ))
-                suite_branch = 'master'
+                suite_branch = 'main'
         return suite_branch
 
     def choose_suite_hash(self, suite_branch):
@@ -308,7 +374,7 @@ class Run(object):
         )
         if not suite_hash:
             exc = BranchNotFoundError(suite_branch, suite_repo_name)
-            util.schedule_fail(message=str(exc), name=self.name)
+            util.schedule_fail(message=str(exc), name=self.name, dry_run=self.args.dry_run)
         log.info("%s branch: %s %s", suite_repo_name, suite_branch, suite_hash)
         return suite_hash
 
@@ -320,6 +386,9 @@ class Run(object):
         job_config.user = self.user
         job_config.timestamp = self.timestamp
         job_config.priority = self.args.priority
+        job_config.seed = self.args.seed
+        if self.args.subset:
+            job_config.subset = '/'.join(str(i) for i in self.args.subset)
         if self.args.email:
             job_config.email = self.args.email
         if self.args.owner:
@@ -354,6 +423,8 @@ class Run(object):
         if self.args.subset:
             subset = '/'.join(str(i) for i in self.args.subset)
             args.extend(['--subset', subset])
+        if self.args.no_nested_subset:
+            args.extend(['--no-nested-subset'])
         args.extend(['--seed', str(self.args.seed)])
         util.teuthology_schedule(
             args=args,
@@ -402,16 +473,13 @@ class Run(object):
     def collect_jobs(self, arch, configs, newest=False, limit=0):
         jobs_to_schedule = []
         jobs_missing_packages = []
-        for description, fragment_paths in configs:
+        for description, fragment_paths, parsed_yaml in configs:
             if limit > 0 and len(jobs_to_schedule) >= limit:
                 log.info(
                     'Stopped after {limit} jobs due to --limit={limit}'.format(
                         limit=limit))
                 break
 
-            raw_yaml = '\n'.join([open(a, 'r').read() for a in fragment_paths])
-
-            parsed_yaml = yaml.safe_load(raw_yaml)
             os_type = parsed_yaml.get('os_type') or self.base_config.os_type
             os_version = parsed_yaml.get('os_version') or self.base_config.os_version
             exclude_arch = parsed_yaml.get('exclude_arch')
@@ -433,13 +501,16 @@ class Run(object):
                 '--',
             ])
             arg.extend(self.base_yaml_paths)
-            arg.extend(fragment_paths)
+
+            parsed_yaml_txt = yaml.dump(parsed_yaml)
+            arg.append('-')
 
             job = dict(
                 yaml=parsed_yaml,
                 desc=description,
                 sha1=self.base_config.sha1,
-                args=arg
+                args=arg,
+                stdin=parsed_yaml_txt,
             )
 
             sha1 = self.base_config.sha1
@@ -448,31 +519,16 @@ class Run(object):
                 full_job_config = copy.deepcopy(self.base_config.to_dict())
                 deep_merge(full_job_config, parsed_yaml)
                 flavor = util.get_install_task_flavor(full_job_config)
-                # Get package versions for this sha1, os_type and flavor. If
-                # we've already retrieved them in a previous loop, they'll be
-                # present in package_versions and gitbuilder will not be asked
-                # again for them.
-                try:
-                    self.package_versions = util.get_package_versions(
-                        sha1,
-                        os_type,
-                        os_version,
-                        flavor,
-                        self.package_versions
-                    )
-                except VersionNotFoundError:
-                    pass
-                if not util.has_packages_for_distro(
-                    sha1, os_type, os_version, flavor, self.package_versions
-                ):
-                    m = "Packages for os_type '{os}', flavor {flavor} and " + \
-                        "ceph hash '{ver}' not found"
-                    log.error(m.format(os=os_type, flavor=flavor, ver=sha1))
+                version = util.package_version_for_hash(sha1, flavor, os_type,
+                    os_version, self.args.machine_type)
+                if not version:
                     jobs_missing_packages.append(job)
+                    log.error(f"Packages for os_type '{os_type}', flavor {flavor} and "
+                         f"ceph hash '{sha1}' not found")
                     # optimization: one missing package causes backtrack in newest mode;
                     # no point in continuing the search
                     if newest:
-                        return jobs_missing_packages, None
+                        return jobs_missing_packages, []
 
             jobs_to_schedule.append(job)
         return jobs_missing_packages, jobs_to_schedule
@@ -486,20 +542,19 @@ class Run(object):
             log_prefix = ''
             if job in jobs_missing_packages:
                 log_prefix = "Missing Packages: "
-                if (
-                    not self.args.dry_run and
-                    not config.suite_allow_missing_packages
-                ):
+                if not config.suite_allow_missing_packages:
                     util.schedule_fail(
-                        "At least one job needs packages that don't exist for "
-                        "hash {sha1}.".format(sha1=self.base_config.sha1),
+                        "At least one job needs packages that don't exist "
+                        f"for hash {self.base_config.sha1}.",
                         name,
+                        dry_run=self.args.dry_run,
                     )
             util.teuthology_schedule(
                 args=job['args'],
                 dry_run=self.args.dry_run,
                 verbose=self.args.verbose,
                 log_prefix=log_prefix,
+                stdin=job['stdin'],
             )
             throttle = self.args.throttle
             if not self.args.dry_run and throttle:
@@ -513,17 +568,28 @@ class Run(object):
 Use the following testing priority
 10 to 49: Tests which are urgent and blocking other important development.
 50 to 74: Testing a particular feature/fix with less than 25 jobs and can also be used for urgent release testing.
-75 to 99: Tech Leads usually schedule integration tests with this priority to verify pull requests against master.
+75 to 99: Tech Leads usually schedule integration tests with this priority to verify pull requests against main.
 100 to 149: QE validation of point releases.
 150 to 199: Testing a particular feature/fix with less than 100 jobs and results will be available in a day or so.
 200 to 1000: Large test runs that can be done over the course of a week.
 Note: To force run, use --force-priority'''
         if priority < 50:
-            util.schedule_fail(msg)
+            util.schedule_fail(msg, dry_run=self.args.dry_run)
         elif priority < 75 and jobs_to_schedule > 25:
-            util.schedule_fail(msg)
+            util.schedule_fail(msg, dry_run=self.args.dry_run)
         elif priority < 150 and jobs_to_schedule > 100:
-            util.schedule_fail(msg)
+            util.schedule_fail(msg, dry_run=self.args.dry_run)
+
+    def check_num_jobs(self, jobs_to_schedule):
+        """
+        Fail schedule if number of jobs exceeds job threshold.
+        """
+        threshold = self.args.job_threshold
+        msg=f'''Unable to schedule {jobs_to_schedule} jobs, too many jobs, when maximum {threshold} jobs allowed.
+
+Note: If you still want to go ahead, use --job-threshold 0'''
+        if threshold and jobs_to_schedule > threshold:
+            util.schedule_fail(msg, dry_run=self.args.dry_run)
 
     def schedule_suite(self):
         """
@@ -543,11 +609,21 @@ Note: To force run, use --force-priority'''
             self.base_config.suite.replace(':', '/'),
         ))
         log.debug('Suite %s in %s' % (suite_name, suite_path))
+        log.debug(f"subset = {self.args.subset}")
+        log.debug(f"no_nested_subset = {self.args.no_nested_subset}")
         configs = build_matrix(suite_path,
                                subset=self.args.subset,
+                               no_nested_subset=self.args.no_nested_subset,
                                seed=self.args.seed)
-        log.info('Suite %s in %s generated %d jobs (not yet filtered)' % (
-            suite_name, suite_path, len(configs)))
+        generated = len(configs)
+        log.info(f'Suite {suite_name} in {suite_path} generated {generated} jobs (not yet filtered or merged)')
+        configs = list(config_merge(configs,
+            filter_in=self.args.filter_in,
+            filter_out=self.args.filter_out,
+            filter_all=self.args.filter_all,
+            filter_fragments=self.args.filter_fragments,
+            seed=self.args.seed,
+            suite_name=suite_name))
 
         if self.args.dry_run:
             log.debug("Base job config:\n%s" % self.base_config)
@@ -584,7 +660,7 @@ Note: To force run, use --force-priority'''
                     'this run for {that_long}? (y/N):'
                     .format(
                         that_long=format_timespan(sleep_before_teardown),
-                        total=len(configs),
+                        total=generated,
                         maximum=job_limit))
                 while True:
                     insane=(input(are_you_insane) or 'n').lower()
@@ -597,23 +673,18 @@ Note: To force run, use --force-priority'''
         # if not, do it once
         backtrack = 0
         limit = self.args.newest
+        sha1s = []
+        jobs_to_schedule = []
+        jobs_missing_packages = []
         while backtrack <= limit:
             jobs_missing_packages, jobs_to_schedule = \
-                self.collect_jobs(arch,
-                    util.filter_configs(configs,
-                        filter_in=self.args.filter_in,
-                        filter_out=self.args.filter_out,
-                        filter_all=self.args.filter_all,
-                        filter_fragments=self.args.filter_fragments,
-                        suite_name=suite_name),
-                                  self.args.newest, job_limit)
+                self.collect_jobs(arch, configs, self.args.newest, job_limit)
             if jobs_missing_packages and self.args.newest:
-                new_sha1 = \
-                    util.find_git_parent('ceph', self.base_config.sha1)
-                if new_sha1 is None:
-                    util.schedule_fail('Backtrack for --newest failed', name)
-                 # rebuild the base config to resubstitute sha1
-                self.config_input['ceph_hash'] = new_sha1
+                if not sha1s:
+                    sha1s = util.find_git_parents('ceph', str(self.base_config.sha1), self.args.newest)
+                if not sha1s:
+                    util.schedule_fail('Backtrack for --newest failed', name, dry_run=self.args.dry_run)
+                self.config_input['ceph_hash'] = sha1s.pop(0)
                 self.base_config = self.build_base_config()
                 backtrack += 1
                 continue
@@ -626,11 +697,9 @@ Note: To force run, use --force-priority'''
                 util.schedule_fail(
                     'Exceeded %d backtracks; raise --newest value' % limit,
                     name,
+                    dry_run=self.args.dry_run,
                 )
 
-        if self.args.dry_run:
-            log.debug("Base job config:\n%s" % self.base_config)
-
         with open(base_yaml_path, 'w+b') as base_yaml:
             base_yaml.write(str(self.base_config).encode())
 
@@ -641,20 +710,26 @@ Note: To force run, use --force-priority'''
         if self.args.priority and jobs_to_schedule and not self.args.force_priority:
             self.check_priority(len(jobs_to_schedule))
 
+        self.check_num_jobs(len(jobs_to_schedule))
+
         self.schedule_jobs(jobs_missing_packages, jobs_to_schedule, name)
 
         os.remove(base_yaml_path)
 
         count = len(jobs_to_schedule)
         missing_count = len(jobs_missing_packages)
+        total_count = count
+        if self.args.num:
+            total_count *= self.args.num
         log.info(
             'Suite %s in %s scheduled %d jobs.' %
             (suite_name, suite_path, count)
         )
         log.info('%d/%d jobs were filtered out.',
-                 (len(configs) - count),
-                 len(configs))
+                 (generated - count),
+                 generated)
         if missing_count:
-            log.warn('Scheduled %d/%d jobs that are missing packages!',
+            log.warning('Scheduled %d/%d jobs that are missing packages!',
                      missing_count, count)
+        log.info('Scheduled %d jobs in total.', total_count)
         return count