← Back to branch summary

~launchpad-pqm/launchpad/devel

« back to all changes in this revision

Viewing changes to scripts/gina.py

  • Committer: Jeroen Vermeulen
  • Date: 2011-08-23 07:50:07 UTC
  • mto: This revision was merged to the branch mainline in revision 13803.
  • Revision ID: jeroen.vermeulen@canonical.com-20110823075007-vkmp4u3vwv7xz782
Cosmetic.

Show diffs side-by-side

added added

removed removed

Lines of Context:
scripts/gina.py
1
1
#!/usr/bin/python -S
2
2
#
3
 
# Copyright 2009-2010 Canonical Ltd.  This software is licensed under the
 
3
# Copyright 2009-2011 Canonical Ltd.  This software is licensed under the
4
4
# GNU Affero General Public License version 3 (see the file LICENSE).
5
5
 
6
6
# This module uses relative imports.
19
19
 
20
20
__metaclass__ = type
21
21
 
22
 
import _pythonpath
23
 
 
24
22
import os
25
 
import psycopg2
26
23
import sys
27
24
import time
28
25
 
 
26
import _pythonpath
 
27
import psycopg2
29
28
from zope.component import getUtility
30
29
 
31
30
from canonical import lp
32
31
from canonical.config import config
33
32
from canonical.launchpad.scripts import log
34
 
 
35
33
from lp.services.scripts.base import LaunchpadCronScript
36
34
from lp.soyuz.interfaces.component import IComponentSet
37
35
from lp.soyuz.scripts.gina import ExecutionError
38
 
from lp.soyuz.scripts.gina.katie import Katie
39
36
from lp.soyuz.scripts.gina.archive import (
40
37
    ArchiveComponentItems,
41
38
    MangledArchiveError,
47
44
    MultiplePackageReleaseError,
48
45
    NoSourcePackageError,
49
46
    )
 
47
from lp.soyuz.scripts.gina.katie import Katie
50
48
from lp.soyuz.scripts.gina.packages import (
51
49
    BinaryPackageData,
52
50
    DisplayNameDecodingError,
56
54
    SourcePackageData,
57
55
    )
58
56
 
59
 
 
60
57
# Set to non-zero if you'd like to be warned every so often
61
58
COUNTDOWN = 0
62
59
 
101
98
    LIBRPORT = config.librarian.upload_port
102
99
 
103
100
    log.info("")
104
 
    log.info("=== Processing %s/%s/%s ===" % (distro, distroseries, pocket))
105
 
    log.debug("Packages read from: %s" % package_root)
106
 
    log.debug("Keyrings read from: %s" % keyrings_root)
107
 
    log.info("Components to import: %s" % ", ".join(components))
 
101
    log.info("=== Processing %s/%s/%s ===", distro, distroseries, pocket)
 
102
    log.debug("Packages read from: %s", package_root)
 
103
    log.debug("Keyrings read from: %s", keyrings_root)
 
104
    log.info("Components to import: %s", ", ".join(components))
108
105
    if component_override is not None:
109
 
        log.info("Override components to: %s" % component_override)
110
 
    log.info("Architectures to import: %s" % ", ".join(archs))
111
 
    log.debug("Launchpad database: %s" % LPDB)
112
 
    log.debug("Launchpad database host: %s" % LPDB_HOST)
113
 
    log.debug("Launchpad database user: %s" % LPDB_USER)
114
 
    log.info("Katie database: %s" % KTDB)
115
 
    log.info("SourcePackage Only: %s" % source_only)
116
 
    log.info("SourcePackageName Only: %s" % spnames_only)
117
 
    log.debug("Librarian: %s:%s" % (LIBRHOST, LIBRPORT))
118
 
    log.info("Dry run: %s" % (dry_run))
 
106
        log.info("Override components to: %s", component_override)
 
107
    log.info("Architectures to import: %s", ", ".join(archs))
 
108
    log.debug("Launchpad database: %s", LPDB)
 
109
    log.debug("Launchpad database host: %s", LPDB_HOST)
 
110
    log.debug("Launchpad database user: %s", LPDB_USER)
 
111
    log.info("Katie database: %s", KTDB)
 
112
    log.info("SourcePackage Only: %s", source_only)
 
113
    log.info("SourcePackageName Only: %s", spnames_only)
 
114
    log.debug("Librarian: %s:%s", LIBRHOST, LIBRPORT)
 
115
    log.info("Dry run: %s", dry_run)
119
116
    log.info("")
120
117
 
121
118
    if hasattr(PackagePublishingPocket, pocket.upper()):
122
119
        pocket = getattr(PackagePublishingPocket, pocket.upper())
123
120
    else:
124
 
        log.error("Could not find a pocket schema for %s" % pocket)
 
121
        log.error("Could not find a pocket schema for %s", pocket)
125
122
        sys.exit(1)
126
123
 
127
124
    if component_override:
128
125
        valid_components = [
129
126
            component.name for component in getUtility(IComponentSet)]
130
127
        if component_override not in valid_components:
131
 
            log.error("Could not find component %s" % component_override)
 
128
            log.error("Could not find component %s", component_override)
132
129
            sys.exit(1)
133
130
 
134
131
    kdb = None
143
140
            source_only)
144
141
    except MangledArchiveError:
145
142
        log.exception(
146
 
            "Failed to analyze archive for %s" % pocket_distroseries)
 
143
            "Failed to analyze archive for %s", pocket_distroseries)
147
144
        sys.exit(1)
148
145
 
149
146
    packages_map = PackagesMap(arch_component_items)
163
160
        try:
164
161
            importer_handler.ensure_archinfo(archtag)
165
162
        except DataSetupError:
166
 
            log.exception("Database setup required for run on %s" % archtag)
 
163
            log.exception("Database setup required for run on %s", archtag)
167
164
            sys.exit(1)
168
165
 
169
166
    import_binarypackages(packages_map, kdb, package_root, keyrings,
176
173
    # Goes over src_map importing the sourcepackages packages.
177
174
    count = 0
178
175
    npacks = len(packages_map.src_map)
179
 
    log.info('%i Source Packages to be imported' % npacks)
 
176
    log.info('%i Source Packages to be imported', npacks)
180
177
 
181
178
    for list_source in sorted(
182
179
        packages_map.src_map.values(), key=lambda x: x[0].get("Package")):
190
187
                except psycopg2.Error:
191
188
                    log.exception(
192
189
                        "Database error: unable to create SourcePackage "
193
 
                        "for %s. Retrying once.." % package_name)
 
190
                        "for %s. Retrying once..", package_name)
194
191
                    importer_handler.abort()
195
192
                    time.sleep(15)
196
193
                    do_one_sourcepackage(
199
196
                InvalidVersionError, MissingRequiredArguments,
200
197
                DisplayNameDecodingError):
201
198
                log.exception(
202
 
                    "Unable to create SourcePackageData for %s" %
 
199
                    "Unable to create SourcePackageData for %s",
203
200
                    package_name)
204
201
                continue
205
202
            except (PoolFileNotFound, ExecutionError):
206
203
                # Problems with katie db stuff of opening files
207
204
                log.exception(
208
 
                    "Error processing package files for %s" % package_name)
 
205
                    "Error processing package files for %s", package_name)
209
206
                continue
210
207
            except psycopg2.Error:
211
208
                log.exception(
212
209
                    "Database errors made me give up: unable to create "
213
 
                    "SourcePackage for %s" % package_name)
 
210
                    "SourcePackage for %s", package_name)
214
211
                importer_handler.abort()
215
212
                continue
216
213
            except MultiplePackageReleaseError:
217
214
                log.exception(
218
 
                    "Database duplication processing %s" % package_name)
 
215
                    "Database duplication processing %s", package_name)
219
216
                continue
220
217
 
221
218
            if COUNTDOWN and count % COUNTDOWN == 0:
222
 
                log.warn('%i/%i sourcepackages processed' % (count, npacks))
 
219
                log.warn('%i/%i sourcepackages processed', count, npacks)
223
220
 
224
221
 
225
222
def do_one_sourcepackage(source, kdb, package_root, keyrings,
228
225
    if importer_handler.preimport_sourcecheck(source_data):
229
226
        # Don't bother reading package information if the source package
230
227
        # already exists in the database
231
 
        log.info('%s already exists in the archive' % source_data.package)
 
228
        log.info('%s already exists in the archive', source_data.package)
232
229
        return
233
230
    source_data.process_package(kdb, package_root, keyrings)
234
231
    source_data.ensure_complete(kdb)
244
241
    for archtag in packages_map.bin_map.keys():
245
242
        count = 0
246
243
        npacks = len(packages_map.bin_map[archtag])
247
 
        log.info('%i Binary Packages to be imported for %s' %
248
 
                 (npacks, archtag))
 
244
        log.info(
 
245
            '%i Binary Packages to be imported for %s', npacks, archtag)
249
246
        # Go over binarypackages importing them for this architecture
250
247
        for binary in sorted(packages_map.bin_map[archtag].values(),
251
248
                             key=lambda x: x.get("Package")):
256
253
                    do_one_binarypackage(binary, archtag, kdb, package_root,
257
254
                                         keyrings, importer_handler)
258
255
                except psycopg2.Error:
259
 
                    log.exception("Database errors when importing a "
260
 
                                  "BinaryPackage for %s. Retrying once.."
261
 
                                  % package_name)
 
256
                    log.exception(
 
257
                        "Database errors when importing a BinaryPackage "
 
258
                        "for %s. Retrying once..", package_name)
262
259
                    importer_handler.abort()
263
260
                    time.sleep(15)
264
261
                    do_one_binarypackage(binary, archtag, kdb, package_root,
265
262
                                         keyrings, importer_handler)
266
263
            except (InvalidVersionError, MissingRequiredArguments):
267
 
                log.exception("Unable to create BinaryPackageData for %s" %
268
 
                              package_name)
 
264
                log.exception(
 
265
                    "Unable to create BinaryPackageData for %s", package_name)
269
266
                continue
270
267
            except (PoolFileNotFound, ExecutionError):
271
268
                # Problems with katie db stuff of opening files
272
 
                log.exception("Error processing package files for %s" %
273
 
                              package_name)
 
269
                log.exception(
 
270
                    "Error processing package files for %s", package_name)
274
271
                continue
275
272
            except MultiplePackageReleaseError:
276
 
                log.exception("Database duplication processing %s" %
277
 
                              package_name)
 
273
                log.exception(
 
274
                    "Database duplication processing %s", package_name)
278
275
                continue
279
276
            except psycopg2.Error:
280
 
                log.exception("Database errors made me give up: unable to "
281
 
                              "create BinaryPackage for %s" % package_name)
 
277
                log.exception(
 
278
                    "Database errors made me give up: unable to create "
 
279
                    "BinaryPackage for %s", package_name)
282
280
                importer_handler.abort()
283
281
                continue
284
282
            except NoSourcePackageError:
285
 
                log.exception("Failed to create Binary Package for %s" %
286
 
                              package_name)
 
283
                log.exception(
 
284
                    "Failed to create Binary Package for %s", package_name)
287
285
                nosource.append(binary)
288
286
                continue
289
287
 
290
288
            if COUNTDOWN and count % COUNTDOWN == 0:
291
289
                # XXX kiko 2005-10-23: untested
292
 
                log.warn('%i/%i binary packages processed' % (count, npacks))
 
290
                log.warn('%i/%i binary packages processed', count, npacks)
293
291
 
294
292
        if nosource:
295
293
            # XXX kiko 2005-10-23: untested
296
 
            log.warn('%i source packages not found' % len(nosource))
 
294
            log.warn('%i source packages not found', len(nosource))
297
295
            for pkg in nosource:
298
296
                log.warn(pkg)
299
297
 
302
300
                         importer_handler):
303
301
    binary_data = BinaryPackageData(**binary)
304
302
    if importer_handler.preimport_binarycheck(archtag, binary_data):
305
 
        log.info('%s already exists in the archive' % binary_data.package)
 
303
        log.info('%s already exists in the archive', binary_data.package)
306
304
        return
307
305
    binary_data.process_package(kdb, package_root, keyrings)
308
306
    importer_handler.import_binarypackage(archtag, binary_data)