~mrooney/+junk/ezpkg

#!/usr/bin/env python

import launchpadlib, datetime, os, sys

from launchpadlib.launchpad import Launchpad

import config

cachedir = config.LP_CACHE_DIR

server = {

    "staging": launchpadlib.launchpad.STAGING_SERVICE_ROOT,

    "production": launchpadlib.launchpad.EDGE_SERVICE_ROOT,

}[config.LP_SERVER]

class Releaser:

    def __init__(self, lp, projectName, version):

        self.LP = lp

        self.ProjectName = projectName

        self.Version = version

        self._Initialize()

    def _Initialize(self):

        # Grab the project object.

        self.Project = self.LP.projects[projectName.lower()]

        # Grab the specified milestone.

        self.Milestone = self.Project.getMilestone(name=version)

        self.ReleaseNotes = self.Milestone.summary

        self.ReleaseDate = datetime.date.today().strftime('%Y-%m-%d')

    def _LocateArtifacts(self):

        """Find the location of the tarball and installer and return them."""

        artifactDir = config.PKGROOT

        artifacts = os.listdir(artifactDir)

        tarballs = [f for f in artifacts if f.endswith("tar.gz")]

        if len(tarballs) != 1:

            raise Exception("Expected one tarball in %s, found: %s" % (artifactDir, tarballs))

        debs = [f for f in artifacts if f.endswith(".deb")]

        if len(debs) != 1:

            raise Exception("Expected one deb in %s, found: %s" % (artfactDir, debs))

        fullpaths = [os.path.join(artifactDir, filename) for filename in (tarballs[0], debs[0])]

        return fullpaths

    def _UploadArtifact(self, release, filepath, changelog_content=None):

        """Push new tarball to Launchpad with signature if provided."""

        filename = os.path.split(filepath)[1]

        content_type, file_type, post_descr = {

                ".gz": ("application/x-gzip", "Code Release Tarball", "source tarball"),

                ".deb":    ("application/x-deb", "Installer file", "installer for Ubuntu"),

            }[os.path.splitext(filename)[1]]

        description = "%s %s %s" % (self.ProjectName, self.Version, post_descr)

        # Get the file contents.

        file_content = open(filepath).read()

        # Get the signature, if available.

        signature = filepath + '.asc'

        if os.path.exists(signature):

            signature_content = open(signature, 'r').read()

        else:

            #signature_content = None

            raise Exception("No signature found for artifact: %s" % filepath)

        # Create a new product release file.

        release.add_file(filename=filename, description=description,

                file_content=file_content, content_type=content_type,

                file_type=file_type, signature_filename=signature,

                signature_content=signature_content)

        if not changelog_content:

            changelog_content = 'New release available: %s' % self.Version

        else:

            changelog_content = "\n".join(changelog_content)

        release.changelog = changelog_content

        try:

            release.lp_save()

        except HTTPError, e:

            raise Exception('An error happened while uploading %s: %s' % (filepath, e.content))

    def Perform(self, assertReady=True):

        if assertReady:

            self.AssertReady()

        numFixed = self.MarkCommittedAsReleased()

        print "Marked %s bugs Fix Committed -> Fix Released." % numFixed

        release = self.MakeReleaseFromMilestone()

        self.UploadArtifacts(release)

    def AssertReady(self):

        """Raise an exception if there are any open bugs for this milestone."""

        unfixed = [task for task in self.Milestone.searchTasks() if task.status not in ["Fix Committed", "Fix Released"]]

        if unfixed:

            raise Exception("There are still %s unfixed tasks for %s, cannot release! Please mark them as Fix Committed or move them to another Milestone." % (len(unfixed), self.Milestone.name))

    def MarkCommittedAsReleased(self):

        """Mark "Fix Committed" bugs as "Fix Released"."""

        committedBugs = [task for task in self.Milestone.searchTasks(status="Fix Committed")]

        for committed in committedBugs:

            committed.status = "Fix Released"

            committed.lp_save()

        return len(committedBugs)

    def MakeReleaseFromMilestone(self):

        return self.Milestone.createProductRelease(date_released=self.ReleaseDate, release_notes=self.ReleaseNotes)

    def UploadArtifacts(self, release):

        for filepath in self._LocateArtifacts():

            self._UploadArtifact(release, filepath)

def copy_package(name="fabric", version="0.9.2-1"):

    ppa = lp.people["mrooney"].getPPAByName(name="ppa")

    ubuntu = lp.distributions['ubuntu'].main_archive

    ppa.syncSource(from_archive=ubuntu, include_binaries=True, source_name=name, to_pocket="Release", to_series="maverick", version=version)

def main(server, lpuser, projectName, version):

    # Log in.

    lp = Launchpad.login_with(lpuser, server, cachedir)

    releaser = Releaser(lp, projectName, version)

    releaser.Perform(assertReady=True)

if __name__ == "__main__":

    projectName, version = sys.argv[1:]

    main(server, config.LP_USER, projectName, version)