~launchpad-pqm/launchpad/devel

# Copyright 2010-2011 Canonical Ltd.  This software is licensed under the

# GNU Affero General Public License version 3 (see the file LICENSE).

"""Enumerations used in the lp/soyuz modules."""

__metaclass__ = type

__all__ = [

    'ArchiveJobType',

    'ArchivePermissionType',

    'ArchivePurpose',

    'ArchiveStatus',

    'ArchiveSubscriberStatus',

    'archive_suffixes',

    'BinaryPackageFileType',

    'BinaryPackageFormat',

    'PackageCopyPolicy',

    'PackageCopyStatus',

    'PackageDiffStatus',

    'PackagePublishingPriority',

    'PackagePublishingStatus',

    'PackageUploadCustomFormat',

    'PackageUploadStatus',

    're_bug_numbers',

    're_closes',

    're_lp_closes',

    'SourcePackageFormat',

    ]

import re

from lazr.enum import (

    DBEnumeratedType,

    DBItem,

    )

# Regexes that match bug numbers for closing in change logs.

re_closes = re.compile(

    r"closes:\s*(?:bug)?\#?\s?\d+(?:,\s*(?:bug)?\#?\s?\d+)*", re.I)

re_lp_closes = re.compile(r"lp:\s+\#\d+(?:,\s*\#\d+)*", re.I)

re_bug_numbers = re.compile(r"\#?\s?(\d+)")

class ArchiveJobType(DBEnumeratedType):

    """Values that IArchiveJob.job_type can take."""

    COPY_ARCHIVE = DBItem(0, """

        Create a copy archive.

        This job creates a copy archive from the current state of

        the archive.

        """)

class ArchivePermissionType(DBEnumeratedType):

    """Archive Permission Type.

    The permission being granted, such as upload rights, or queue

    manipulation rights.

    """

    UPLOAD = DBItem(1, """

        Archive Upload Rights

        This permission allows a user to upload.

        """)

    QUEUE_ADMIN = DBItem(2, """

        Queue Administration Rights

        This permission allows a user to administer the distroseries

        upload queue.

        """)

class ArchivePurpose(DBEnumeratedType):

    """The purpose, or type, of an archive.

    A distribution can be associated with different archives and this

    schema item enumerates the different archive types and their purpose.

    For example, Partner/ISV software in ubuntu is stored in a separate

    archive. PPAs are separate archives and contain packages that 'overlay'

    the ubuntu PRIMARY archive.

    """

    PRIMARY = DBItem(1, """

        Primary Archive

        This is the primary Ubuntu archive.

        """)

    PPA = DBItem(2, """

        PPA Archive

        This is a Personal Package Archive.

        """)

    PARTNER = DBItem(4, """

        Partner Archive

        This is the archive for partner packages.

        """)

    COPY = DBItem(6, """

        Generalized copy archive

        This kind of archive will be used for rebuilds, snapshots etc.

        """)

    DEBUG = DBItem(7, """

        Debug Archive

        This kind of archive will be user for publishing package with

        debug-symbols.

        """)

archive_suffixes = {

    ArchivePurpose.PRIMARY: '',

    ArchivePurpose.PARTNER: '-partner',

    ArchivePurpose.DEBUG: '-debug',

}

class ArchiveStatus(DBEnumeratedType):

    """The status of an archive, e.g. active, disabled. """

    ACTIVE = DBItem(0, """

        Active

        This archive accepts uploads, copying and publishes packages.

        """)

    DELETING = DBItem(1, """

        Deleting

        This archive is in the process of being deleted.  This is a user-

        requested and short-lived status.

        """)

    DELETED = DBItem(2, """

        Deleted

        This archive has been deleted and removed from disk.

        """)

class ArchiveSubscriberStatus(DBEnumeratedType):

    """The status of an `ArchiveSubscriber`."""

    CURRENT = DBItem(1, """

        Active

        The subscription is current.

        """)

    EXPIRED = DBItem(2, """

        Expired

        The subscription has expired.

        """)

    CANCELLED = DBItem(3, """

        Cancelled

        The subscription was cancelled.

        """)

class BinaryPackageFileType(DBEnumeratedType):

    """Binary Package File Type

    Launchpad handles a variety of packaging systems and binary package

    formats. This schema documents the known binary package file types.

    """

    DEB = DBItem(1, """

        DEB Format

        This format is the standard package format used on Ubuntu and other

        similar operating systems.

        """)

    RPM = DBItem(2, """

        RPM Format

        This format is used on mandrake, Red Hat, Suse and other similar

        distributions.

        """)

    UDEB = DBItem(3, """

        UDEB Format

        This format is the standard package format used on Ubuntu and other

        similar operating systems for the installation system.

        """)

    DDEB = DBItem(4, """

        DDEB Format

        This format is the standard package format used on Ubuntu and other

        similar operating systems for distributing debug symbols.

        """)

class BinaryPackageFormat(DBEnumeratedType):

    """Binary Package Format

    Launchpad tracks a variety of binary package formats. This schema

    documents the list of binary package formats that are supported

    in Launchpad.

    """

    DEB = DBItem(1, """

        Ubuntu Package

        This is the binary package format used by Ubuntu and all similar

        distributions. It includes dependency information to allow the

        system to ensure it always has all the software installed to make

        any new package work correctly.  """)

    UDEB = DBItem(2, """

        Ubuntu Installer Package

        This is the binary package format used by the installer in Ubuntu and

        similar distributions.  """)

    EBUILD = DBItem(3, """

        Gentoo Ebuild Package

        This is the Gentoo binary package format. While Gentoo is primarily

        known for being a build-it-from-source-yourself kind of

        distribution, it is possible to exchange binary packages between

        Gentoo systems.  """)

    RPM = DBItem(4, """

        RPM Package

        This is the format used by Mandrake and other similar distributions.

        It does not include dependency tracking information.  """)

    DDEB = DBItem(5, """

        Ubuntu Debug Package

        This is the binary package format used for shipping debug symbols

        in Ubuntu and similar distributions.""")

class PackageCopyPolicy(DBEnumeratedType):

    """Package copying policy.

    Each of these is associated with one `ICopyPolicy`.

    """

    INSECURE = DBItem(1, """

        Copy from insecure source.

        This is the default.

        """)

    MASS_SYNC = DBItem(2, """

        Mass package sync.

        This policy applies when synchronizing packages en masse.

        """)

class PackageCopyStatus(DBEnumeratedType):

    """Package copy status type.

    The status may be one of the following: new, in progress, complete,

    failed, canceling, cancelled.

    """

    NEW = DBItem(0, """

        New

        A new package copy operation was requested.

        """)

    INPROGRESS = DBItem(1, """

        In progress

        The package copy operation is in progress.

        """)

    COMPLETE = DBItem(2, """

        Complete

        The package copy operation has completed successfully.

        """)

    FAILED = DBItem(3, """

        Failed

        The package copy operation has failed.

        """)

    CANCELING = DBItem(4, """

        Canceling

        The package copy operation was cancelled by the user and the

        cancellation is in progress.

        """)

    CANCELLED = DBItem(5, """

        Cancelled

        The package copy operation was cancelled by the user.

        """)

class PackageDiffStatus(DBEnumeratedType):

    """The status of a PackageDiff request."""

    PENDING = DBItem(0, """

        Pending

        This diff request is pending processing.

        """)

    COMPLETED = DBItem(1, """

        Completed

        This diff request was successfully completed.

        """)

    FAILED = DBItem(2, """

        Failed

        This diff request has failed.

        """)

class PackagePublishingPriority(DBEnumeratedType):

    """Package Publishing Priority

    Binary packages have a priority which is related to how important

    it is to have that package installed in a system. Common priorities

    range from required to optional and various others are available.

    """

    REQUIRED = DBItem(50, """

        Required

        This priority indicates that the package is required. This priority

        is likely to be hard-coded into various package tools. Without all

        the packages at this priority it may become impossible to use dpkg.

        """)

    IMPORTANT = DBItem(40, """

        Important

        If foo is in a package; and "What is going on?! Where on earth is

        foo?!?!" would be the reaction of an experienced UNIX hacker were

        the package not installed, then the package is important.

        """)

    STANDARD = DBItem(30, """

        Standard

        Packages at this priority are standard ones you can rely on to be in

        a distribution. They will be installed by default and provide a

        basic character-interface userland.

        """)

    OPTIONAL = DBItem(20, """

        Optional

        This is the software you might reasonably want to install if you did

        not know what it was or what your requiredments were. Systems such

        as X or TeX will live here.

        """)

    EXTRA = DBItem(10, """

        Extra

        This contains all the packages which conflict with those at the

        other priority levels; or packages which are only useful to people

        who have very specialised needs.

        """)

class PackagePublishingStatus(DBEnumeratedType):

    """Package Publishing Status

     A package has various levels of being published within a DistroSeries.

     This is important because of how new source uploads dominate binary

     uploads bit-by-bit. Packages (source or binary) enter the publishing

     tables as 'Pending', progress through to 'Published' eventually become

     'Superseded' and then become 'PendingRemoval'. Once removed from the

     DistroSeries the publishing record is also removed.

     """

    PENDING = DBItem(1, """

        Pending

        This [source] package has been accepted into the DistroSeries and

        is now pending the addition of the files to the published disk area.

        In due course, this source package will be published.

        """)

    PUBLISHED = DBItem(2, """

        Published

        This package is currently published as part of the archive for that

        distroseries. In general there will only ever be one version of any

        source/binary package published at any one time. Once a newer

        version becomes published the older version is marked as superseded.

        """)

    SUPERSEDED = DBItem(3, """

        Superseded

        When a newer version of a [source] package is published the existing

        one is marked as "superseded".  """)

    DELETED = DBItem(4, """

        Deleted

        When a publication was "deleted" from the archive by user request.

        Records in this state contain a reference to the Launchpad user

        responsible for the deletion and a text comment with the removal

        reason.

        """)

    OBSOLETE = DBItem(5, """

        Obsolete

        When a distroseries becomes obsolete, its published packages

        are no longer required in the archive.  The publications for

        those packages are marked as "obsolete" and are subsequently

        removed during domination and death row processing.

        """)

# If you change this (add items, change the meaning, whatever) search for

# the token ##CUSTOMFORMAT## e.g. database/queue.py or nascentupload.py and

# update the stuff marked with it.

class PackageUploadCustomFormat(DBEnumeratedType):

    """Custom formats valid for the upload queue

    An upload has various files potentially associated with it, from source

    package releases, through binary builds, to specialist upload forms such

    as a debian-installer tarball or a set of translations.

    """

    DEBIAN_INSTALLER = DBItem(0, """

        raw-installer

        A raw-installer file is a tarball. This is processed as a version

        of the debian-installer to be unpacked into the archive root.

        """)

    ROSETTA_TRANSLATIONS = DBItem(1, """

        raw-translations

        A raw-translations file is a tarball. This is passed to the rosetta

        import queue to be incorporated into that package's translations.

        """)

    DIST_UPGRADER = DBItem(2, """

        raw-dist-upgrader

        A raw-dist-upgrader file is a tarball. It is simply published into

        the archive.

        """)

    DDTP_TARBALL = DBItem(3, """

        raw-ddtp-tarball

        A raw-ddtp-tarball contains all the translated package description

        indexes for a component.

        """)

    STATIC_TRANSLATIONS = DBItem(4, """

        raw-translations-static

        A tarball containing raw (Gnome) help file translations.

        """)

    META_DATA = DBItem(5, """

        meta-data

        A file containing meta-data about the package, mainly for use in

        the Software Center.

        """)

class PackageUploadStatus(DBEnumeratedType):

    """Distro Release Queue Status

    An upload has various stages it must pass through before becoming part

    of a DistroSeries. These are managed via the Upload table

    and related tables and eventually (assuming a successful upload into the

    DistroSeries) the effects are published via the PackagePublishing and

    SourcePackagePublishing tables.

    """

    NEW = DBItem(0, """

        New

        This upload is either a brand-new source package or contains a

        binary package with brand new debs or similar. The package must sit

        here until someone with the right role in the DistroSeries checks

        and either accepts or rejects the upload. If the upload is accepted

        then entries will be made in the overrides tables and further

        uploads will bypass this state. """)

    UNAPPROVED = DBItem(1, """

        Unapproved

        If a DistroSeries is frozen or locked out of ordinary updates then

        this state is used to mean that while the package is correct from a

        technical point of view; it has yet to be approved for inclusion in

        this DistroSeries. One use of this state may be for security

        releases where you want the security team of a DistroSeries to

        approve uploads.""")

    ACCEPTED = DBItem(2, """

        Accepted

        An upload in this state has passed all the checks required of it and

        is ready to have its publishing records created.""")

    DONE = DBItem(3, """

        Done

        An upload in this state has had its publishing records created if it

        needs them and is fully processed into the DistroSeries. This state

        exists so that a logging and/or auditing tool can pick up accepted

        uploads and create entries in a journal or similar before removing

        the queue item.""")

    REJECTED = DBItem(4, """

        Rejected

        An upload which reaches this state has, for some reason or another

        not passed the requirements (technical or human) for entry into the

        DistroSeries it was targetting. As for the 'done' state, this state

        is present to allow logging tools to record the rejection and then

        clean up any subsequently unnecessary records.""")

class SourcePackageFormat(DBEnumeratedType):

    """Source package format

    There are currently three formats of Debian source packages. The Format

    field in the .dsc file must specify one of these formats.

    """

    FORMAT_1_0 = DBItem(0, """

        1.0

        Specifies either a native (having a single tar.gz) or non-native

        (having an orig.tar.gz and a diff.gz) package. Supports only gzip

        compression.

        """)

    FORMAT_3_0_QUILT = DBItem(1, """

        3.0 (quilt)

        Specifies a non-native package, with an orig.tar.* and a debian.tar.*.

        Supports gzip, bzip2, and xz compression.

        """)

    FORMAT_3_0_NATIVE = DBItem(2, """

        3.0 (native)

        Specifies a native package, with a single tar.*. Supports gzip,

        bzip2, and xz compression.

        """)