tuxedo-add.py

#!/usr/bin/env python

import optparse
from optparse import Option, OptionParser, OptionError
import urllib2
from urllib import urlencode, quote
import base64
import sys
import os
import traceback
from release.platforms import buildbot2bouncer, buildbot2ftp, \
    getAllLocales, getPlatforms
from release.versions import getPrettyVersion


class TuxedoOption(Option):
    ATTRS = Option.ATTRS + ['required']

    def _check_required(self):
        if self.required and not self.takes_value():
            raise OptionError(
                "required flag set for option that doesn't take a value",
                self)

    # Make sure _check_required() is called from the constructor!
    CHECK_METHODS = Option.CHECK_METHODS + [_check_required]

    def process(self, opt, value, values, parser):
        Option.process(self, opt, value, values, parser)
        parser.option_seen[self] = 1


class TuxedoOptionParser(OptionParser):

    def _init_parsing_state(self):
        OptionParser._init_parsing_state(self)
        self.option_seen = {}

    def check_values(self, values, args):
        for option in self.option_list:
            if (isinstance(option, Option) and
                option.required and
                    option not in self.option_seen):
                self.print_help()
                self.set_usage(optparse.SUPPRESS_USAGE)
                self.error("%s not supplied" % option)
        return (values, args)


class TuxedoEntrySubmitter(object):

    full_product_template = {}
    complete_mar_template = {}
    partial_mar_template = {}

    def __init__(self, config, productName, version, tuxedoServerUrl,
                 brandName=None, bouncerProductName=None, shippedLocales=None,
                 partialVersions=None, username=None, password=None,
                 verbose=True, dryRun=False, platforms=None, milestone=None,
                 bouncerProductSuffix=None):
        self.config = config
        self.productName = productName
        self.version = version
        self.milestone = milestone
        self.tuxedoServerUrl = tuxedoServerUrl
        self.brandName = brandName or productName.capitalize()
        self.bouncerProductName = bouncerProductName or productName.capitalize(
        )
        self.shippedLocales = shippedLocales
        self.partialVersions = partialVersions
        self.username = username
        self.password = password
        self.verbose = verbose
        self.dryRun = dryRun
        self.platforms = platforms
        self.addMARs = False

        if not self.platforms:
            self.platforms = getPlatforms()

        if self.shippedLocales:
            self.locales = getAllLocales(self.shippedLocales)
        else:
            self.locales = None

        self.bouncer_product_name = '%s-%s' % (self.bouncerProductName,
                                               self.version)
        if bouncerProductSuffix:
            self.bouncer_product_name = '%s-%s' % (self.bouncer_product_name,
                                                   bouncerProductSuffix)
        self.complete_mar_bouncer_product_name = '%s-%s-Complete' % \
            (self.bouncerProductName, self.version)
        self.partial_mar_bouncer_product_names = {}
        for previousVersion in self.partialVersions:
            self.addMARs = True
            self.partial_mar_bouncer_product_names[previousVersion] = '%s-%s-Partial-%s' % \
                (self.bouncerProductName, self.version, previousVersion)
        self.read_config()

    def read_config(self):
        """Example config file


[DEFAULT]
complete_mar_template = /%(product)s/releases/%(version)s/update/%(ftp_platform)s/%(locale)s/%(product)s-%(version)s.complete.mar
partial_mar_template = /%(product)s/releases/%(version)s/update/%(ftp_platform)s/%(locale)s/%(product)s-%(previous_version)s-%(version)s.partial.mar

[win32]
full_product_template = /%(product)s/releases/%(version)s/%(ftp_platform)s/%(locale)s/%(brandName)s Setup %(prettyVersion)s.exe

[linux]
full_product_template = /%(product)s/releases/%(version)s/%(ftp_platform)s/%(locale)s/%(product)s-%(version)s.tar.bz2

[macosx]
full_product_template = /%(product)s/releases/%(version)s/%(ftp_platform)s/%(locale)s/%(brandName)s %(prettyVersion)s.dmg

"""
        try:
            import ConfigParser
        except ImportError:
            import configparser as ConfigParser

        cfg = ConfigParser.RawConfigParser()
        if not cfg.read(self.config):
            print >> sys.stderr, "Cannot read %s" % self.config
            sys.exit(2)

        for platform in self.platforms:
            self.full_product_template[platform] = cfg.get(platform,
                                                           'full_product_template')
            self.complete_mar_template[platform] = cfg.get(platform,
                                                           'complete_mar_template')
            self.partial_mar_template[platform] = cfg.get(platform,
                                                          'partial_mar_template')

    def tuxedoRequest(self, url, postdata=None):
        full_url = self.tuxedoServerUrl + url
        request = urllib2.Request(full_url)
        if self.username and self.password:
            basicAuth = base64.encodestring(
                '%s:%s' % (self.username, self.password))
            request.add_header("Authorization", "Basic %s" % basicAuth.strip())
        if postdata:
            if isinstance(postdata, dict):
                postdata = urlencode(postdata)
            request.add_data(postdata)
        if self.dryRun:
            print >> sys.stderr, "Tuxedo API URL: %s" % full_url
            if postdata:
                print >> sys.stderr, "POST data: %s" % postdata
            return
        try:
            return urllib2.urlopen(request).read()
        except urllib2.URLError:
            print >> sys.stderr, "FAILED: Tuxedo API error. URL: %s" % full_url
            if postdata:
                print >> sys.stderr, "POST data: %s" % postdata
            traceback.print_exc(file=sys.stdout)
            sys.exit(1)

    def product_add(self, product):
        if self.verbose:
            print "Adding product: %s" % product
            if self.locales:
                print "Locales: %s" % ", ".join(self.locales)
        post_data = "product=" + quote(product)
        if self.locales:
            locales_post_data = ["languages=%s" % l for l in self.locales]
            locales_post_data = "&".join(locales_post_data)
            post_data += "&" + locales_post_data
        response = self.tuxedoRequest("product_add/", post_data)
        if self.verbose:
            print "Server response:"
            print response

    def location_add(self, product, platform, path):
        path = path.replace(' ', '%20')
        if self.verbose:
            print "Adding location for %s, %s: %s" % \
                (product, buildbot2bouncer(platform), path)
        self.tuxedoRequest("location_add/",
                           {'product': product,
                            'os': buildbot2bouncer(platform),
                            'path': path})

    def add_products(self):
        self.product_add(self.bouncer_product_name)
        if self.addMARs:
            self.product_add(self.complete_mar_bouncer_product_name)
            if self.partialVersions:
                for name in self.partial_mar_bouncer_product_names.values():
                    self.product_add(name)

    def add_locations(self):
        for platform in self.platforms:
            template_dict = {'product': self.productName,
                             'brandName': self.brandName,
                             'bouncer_product': self.bouncerProductName,
                             'version': self.version,
                             'milestone': self.milestone,
                             'prettyVersion': getPrettyVersion(self.version),
                             'ftp_platform': buildbot2ftp(platform),
                             'locale': ':lang'}
            # Full product
            path = self.full_product_template[platform] % template_dict
            self.location_add(self.bouncer_product_name, platform, path)

            # Complete MAR product
            if self.addMARs:
                path = self.complete_mar_template[platform] % template_dict
                self.location_add(self.complete_mar_bouncer_product_name,
                                  platform, path)

                # Partial MAR product
                for previousVersion in self.partialVersions:
                    template_dict['previous_version'] = previousVersion
                    path = self.partial_mar_template[platform] % template_dict
                    name = self.partial_mar_bouncer_product_names[
                        previousVersion]
                    self.location_add(name, platform, path)

    def submit(self):
        self.add_products()
        self.add_locations()


def getOptions():
    parser = TuxedoOptionParser(option_class=TuxedoOption)
    parser.add_option("--config", dest="config",
                      required=True,
                      help="Configuration file")
    parser.add_option("-p", "--product-name", dest="productName",
                      required=True,
                      help="Product name")
    parser.add_option("-v", "--version", dest="version",
                      required=True,
                      help="Product version")
    parser.add_option("--milestone", dest="milestone",
                      help="Product milestone")
    parser.add_option("-t", "--tuxedo-server-url", dest="tuxedoServerUrl",
                      required=True,
                      help="Bouncer/Tuxedo API URL")
    parser.add_option("-r", "--brand-name", dest="brandName",
                      help="Brand name")
    parser.add_option(
        "-b", "--bouncer-product-name", dest="bouncerProductName",
        help="Bouncer product name")
    parser.add_option("--bouncer-product-suffix", dest="bouncerProductSuffix",
                      help="Bouncer product suffix")
    parser.add_option("-l", "--shipped-locales", dest="shippedLocales",
                      help="shipped-locales file location")
    parser.add_option(
        "--partial-version", dest="partialVersions", action="append",
        default=[], help="Old product version")
    parser.add_option("--platform", action="append",
                      dest="platforms",
                      help="Platform(s) to be processed")
    parser.add_option("--dry-run", action="store_true", dest="dryRun",
                      default=False,
                      help="Print debug information and exit")
    parser.add_option("--username", dest="username",
                      help="Tuxedo user name")
    parser.add_option("--password", dest="password",
                      help="Tuxedo password")
    parser.add_option("--credentials-file", dest="credentials",
                      help="Get Tuxedo username/password from file")
    parser.add_option("-q", "--quiet", action="store_false", dest="verbose",
                      default=True,
                      help="Don't print status messages to stdout")
    return parser.parse_args()


def credentials_from_file(credentials_file):
    try:
        module, _ = os.path.splitext(credentials_file)
        credentials = __import__(module)
        username = credentials.tuxedoUsername
        password = credentials.tuxedoPassword
        return (username, password)
    except ImportError:
        print >> sys.stderr, \
            "Cannot open credentials file: %s" % credentials_file
        sys.exit(3)
    except AttributeError:
        print >> sys.stderr, \
            "Cannot retrieve credentials file: %s" % credentials_file
        sys.exit(4)


def main():
    (options, args) = getOptions()

    username = options.username
    password = options.password
    if options.credentials:
        (username, password) = credentials_from_file(options.credentials)

    tuxedo = TuxedoEntrySubmitter(config=options.config,
                                  productName=options.productName,
                                  version=options.version,
                                  milestone=options.milestone,
                                  tuxedoServerUrl=options.tuxedoServerUrl,
                                  brandName=options.brandName,
                                  bouncerProductName=options.bouncerProductName,
                                  shippedLocales=options.shippedLocales,
                                  partialVersions=options.partialVersions,
                                  username=username,
                                  password=password,
                                  verbose=options.verbose,
                                  dryRun=options.dryRun,
                                  platforms=options.platforms,
                                  bouncerProductSuffix=options.bouncerProductSuffix,
                                  )
    tuxedo.submit()


if __name__ == '__main__':
    main()