def find_builds_from_tags()

in pylib/mozautomation/mozautomation/releasescraper.py [0:0]

• 68 lines of code
• 17 McCabe index (conditional complexity)

def find_builds_from_tags():
    session = get_session()

    with futures.ThreadPoolExecutor(requests.adapters.DEFAULT_POOLSIZE) as e:
        archive_fs = []
        seen_tags = set()

        # Need to process in order because we only process each tag once.
        for repo, channel in TAGS_REPOS:
            url = b"https://hg.mozilla.org/%s/json-tags" % repo

            r = session.get(url)
            if r.status_code != 200:
                raise Exception("unexpected non-200 from %s" % url)

            for entry in r.json()[b"tags"]:
                m = RE_TAG.match(entry[b"tag"])
                if not m:
                    continue

                if entry[b"tag"] in seen_tags:
                    continue
                seen_tags.add(entry[b"tag"])

                version = m.group("version")

                if b"a" in version:
                    sep = b"a"
                    major, sub = version.split(b"a")
                elif b"b" in version:
                    sep = b"b"
                    major, sub = version.split(b"b")
                else:
                    major = version
                    sub = None

                major = major.replace(b"_", b".")
                app_version = major
                if sub:
                    app_version += b"%s%s" % (sep, sub)

                # Some releases are tagged but were never released. Skip them.
                if app_version in MISSING_RELEASES:
                    continue

                # There are no build ids for release builds. Construct a
                # dummy one from the tag date.
                td = datetime.timedelta(seconds=entry[b"date"][0])
                dt = datetime.datetime(1970, 1, 1) + td
                day = dt.date()

                build_id = dt.strftime("%Y%m%d%H%M%S").encode("utf-8")

                for platform, archive_platform in RELEASES_PLATFORMS.items():
                    # win64 not produced until release 42.
                    if platform == b"win64":
                        v = distutils.version.StrictVersion
                        ours = v(major) if b"." in major else v(b"%s.0" % major)

                        if ours < v(b"42.0"):
                            continue

                    archive_url = b"%s/%s/%s/" % (
                        RELEASES_ARCHIVE_URL,
                        app_version,
                        archive_platform,
                    )

                    build = {
                        b"revision": entry[b"node"],
                        b"tag": entry[b"tag"],
                        b"channel": channel,
                        b"app_version": app_version,
                        b"platform": platform,
                        b"artifacts_url": archive_url,
                        b"build_id": build_id,
                        b"day": day,
                    }

                    archive_fs.append((build, e.submit(session.get, archive_url)))

        for build, f in archive_fs:
            r = f.result()
            if r.status_code != 200:
                # We shouldn't hit this.
                print(
                    b"could not find release %s %s from tag %s"
                    % (build[b"app_version"], build[b"platform"], build[b"tag"])
                )
                continue

            yield build