← Back to branch summary

~xnox/ubuntu-archive-tools/sru-report-autopkgtest-vomit

« back to all changes in this revision

Viewing changes to lputils.py

  • Committer: Colin Watson
  • Date: 2018-01-05 12:24:50 UTC
  • Revision ID: cjwatson@canonical.com-20180105122450-uk2tkwpq0z68jfww
lputils.py: use argparse-style naming (no functional change)

Show diffs side-by-side

added added

removed removed

Lines of Context:
lputils.py
43
43
    '"ubuntu/partner" for a partner or copy archive.')
44
44
 
45
45
 
46
 
def setup_location(options, default_pocket="Release"):
 
46
def setup_location(args, default_pocket="Release"):
47
47
    archive = None
48
 
    if getattr(options, "archive", False):
 
48
    if getattr(args, "archive", False):
49
49
        # Try parsing an archive reference first.
50
 
        archive = options.launchpad.archives.getByReference(
51
 
            reference=options.archive)
 
50
        archive = args.launchpad.archives.getByReference(
 
51
            reference=args.archive)
52
52
        if archive is None:
53
 
            raise AssertionError("No such archive: %s" % options.archive)
 
53
            raise AssertionError("No such archive: %s" % args.archive)
54
54
    else:
55
55
        # Otherwise derive the archive from the deprecated
56
56
        # -d/--ppa/--ppa-name/--partner options.
57
 
        if isinstance(options.distribution, Entry):
58
 
            distro = options.distribution
 
57
        if isinstance(args.distribution, Entry):
 
58
            distro = args.distribution
59
59
        else:
60
 
            distro = options.launchpad.distributions[options.distribution]
61
 
        if getattr(options, "partner", False):
 
60
            distro = args.launchpad.distributions[args.distribution]
 
61
        if getattr(args, "partner", False):
62
62
            archive = [
63
63
                archive for archive in distro.archives
64
64
                if archive.name == "partner"][0]
65
 
        elif getattr(options, "ppa", None):
66
 
            archive = options.launchpad.people[options.ppa].getPPAByName(
67
 
                distribution=distro, name=options.ppa_name)
 
65
        elif getattr(args, "ppa", None):
 
66
            archive = args.launchpad.people[args.ppa].getPPAByName(
 
67
                distribution=distro, name=args.ppa_name)
68
68
        else:
69
69
            archive = distro.main_archive
70
70
 
71
 
    options.archive = archive
72
 
    options.distribution = archive.distribution
73
 
    if options.suite:
74
 
        if "-" in options.suite:
75
 
            options.series, options.pocket = options.suite.rsplit("-", 1)
76
 
            options.pocket = options.pocket.title()
77
 
            if options.pocket not in known_pockets:
78
 
                options.series = options.suite
79
 
                options.pocket = "Release"
 
71
    args.archive = archive
 
72
    args.distribution = archive.distribution
 
73
    if args.suite:
 
74
        if "-" in args.suite:
 
75
            args.series, args.pocket = args.suite.rsplit("-", 1)
 
76
            args.pocket = args.pocket.title()
 
77
            if args.pocket not in known_pockets:
 
78
                args.series = args.suite
 
79
                args.pocket = "Release"
80
80
        else:
81
 
            options.series = options.suite
82
 
            options.pocket = "Release"
83
 
        options.series = options.distribution.getSeries(
84
 
            name_or_version=options.series)
 
81
            args.series = args.suite
 
82
            args.pocket = "Release"
 
83
        args.series = args.distribution.getSeries(name_or_version=args.series)
85
84
    else:
86
 
        options.series = options.distribution.current_series
87
 
        options.pocket = default_pocket
88
 
        if options.pocket == "Release":
89
 
            options.suite = options.series.name
 
85
        args.series = args.distribution.current_series
 
86
        args.pocket = default_pocket
 
87
        if args.pocket == "Release":
 
88
            args.suite = args.series.name
90
89
        else:
91
 
            options.suite = "%s-%s" % (
92
 
                options.series.name, options.pocket.lower())
 
90
            args.suite = "%s-%s" % (args.series.name, args.pocket.lower())
93
91
 
94
 
    if getattr(options, "architecture", None) is not None:
95
 
        options.architectures = [options.series.getDistroArchSeries(
96
 
            archtag=options.architecture)]
97
 
    elif getattr(options, "architectures", None) is not None:
98
 
        options.architectures = sorted(
99
 
            [a for a in options.series.architectures
100
 
             if a.architecture_tag in options.architectures],
 
92
    if getattr(args, "architecture", None) is not None:
 
93
        args.architectures = [args.series.getDistroArchSeries(
 
94
            archtag=args.architecture)]
 
95
    elif getattr(args, "architectures", None) is not None:
 
96
        args.architectures = sorted(
 
97
            [a for a in args.series.architectures
 
98
             if a.architecture_tag in args.architectures],
101
99
            key=attrgetter("architecture_tag"))
102
100
    else:
103
 
        options.architectures = sorted(
104
 
            options.series.architectures, key=attrgetter("architecture_tag"))
 
101
        args.architectures = sorted(
 
102
            args.series.architectures, key=attrgetter("architecture_tag"))
105
103
 
106
104
 
107
105
def find_newest_publication(method, version_attr, **kwargs):
134
132
        return newest_pending
135
133
 
136
134
 
137
 
def find_latest_published_binaries(options, package):
 
135
def find_latest_published_binaries(args, package):
138
136
    target_binaries = []
139
 
    for architecture in options.architectures:
 
137
    for architecture in args.architectures:
140
138
        binary = find_newest_publication(
141
 
            options.archive.getPublishedBinaries, "binary_package_version",
142
 
            binary_name=package, version=options.version,
143
 
            distro_arch_series=architecture, pocket=options.pocket,
 
139
            args.archive.getPublishedBinaries, "binary_package_version",
 
140
            binary_name=package, version=args.version,
 
141
            distro_arch_series=architecture, pocket=args.pocket,
144
142
            exact_match=True)
145
143
        if binary is not None:
146
144
            target_binaries.append(binary)
147
145
    if not target_binaries:
148
146
        raise PackageMissing(
149
147
            "Could not find binaries for '%s/%s' in %s" %
150
 
            (package, options.version, options.suite))
 
148
            (package, args.version, args.suite))
151
149
    return target_binaries
152
150
 
153
151
 
154
 
def find_latest_published_source(options, package):
 
152
def find_latest_published_source(args, package):
155
153
    source = find_newest_publication(
156
 
        options.archive.getPublishedSources, "source_package_version",
157
 
        source_name=package, version=options.version,
158
 
        distro_series=options.series, pocket=options.pocket, exact_match=True)
 
154
        args.archive.getPublishedSources, "source_package_version",
 
155
        source_name=package, version=args.version,
 
156
        distro_series=args.series, pocket=args.pocket, exact_match=True)
159
157
    if source is None:
160
158
        raise PackageMissing(
161
159
            "Could not find source '%s/%s' in %s" %
162
 
            (package, options.version, options.suite))
 
160
            (package, args.version, args.suite))
163
161
    return source