treepkg/treepkg: treepkg/packager.py comparison

comparison treepkg/packager.py @ 4:fee641fec94e

Separate the kolab specific parts.

author	Bernhard Herzog <bh@intevation.de>
date	Fri, 09 Mar 2007 12:26:01 +0100
parents	e6a9f4037f68
children	96f4f58c62b5

comparison

equal deleted inserted replaced

-:7e9db903ba16
+:fee641fec94e
 return property(get)
 class SourcePackager(object):
+# Derived classes must supply the package basename
+pkg_basename = None
 def __init__(self, plant, status, work_dir, src_dir, revision):
 self.plant = plant
 self.status = status
 self.work_dir = work_dir
 self.src_dir = src_dir
 self.revision = revision
-self.enterprise_version = (time.strftime("%Y%m%d", time.localtime()) \
+assert(self.pkg_basename)
-+ "." + str(self.revision))
-def kdepim_version(self, directory):
-"""Determine the kdepim version.
-The version is taken from the kdepim.lsm file in the plants
-checkout dir.
-"""
-return util.extract_lsm_version(os.path.join(directory, "kdepim.lsm"))
 def determine_package_version(self, directory):
-enterprise_version = self.enterprise_version
+"""Returns the version number of the new package as a string
-kdepimversion = self.kdepim_version(directory)
-version_template = "%(kdepimversion)s.enterprise.0.%(enterprise_version)s"
+The directory parameter is the name of the directory containing
-return version_template % locals()
+the newly exported sources.  The sources were exported with the
+export_sources method.
+The default implementation simply returns the revision converted
+to a string.
+"""
+return str(self.revision)
 def export_sources(self):
+"""Export the sources from the subversion working directory
+This method first exports the sources to a temporary directory
+and then renames the directory.  The new name is of the form
+<pkg_basename>-<version>
+Where pkg_basename is the value of self.pkg_basename and version
+is the return value of the determine_package_version() method.
+"""
 temp_dir = os.path.join(self.work_dir, "temp")
 self.plant.export_sources(temp_dir)
 pkgbaseversion = self.determine_package_version(temp_dir)
-pkgbasedir = os.path.join(self.work_dir, "kdepim-" + pkgbaseversion)
+pkgbasedir = os.path.join(self.work_dir,
+self.pkg_basename + "-" + pkgbaseversion)
 os.rename(temp_dir, pkgbasedir)
 return pkgbaseversion, pkgbasedir
 def update_version_numbers(self, pkgbasedir):
-versionstring = "(enterprise %s)" % self.enterprise_version
+"""Updates the version numbers in the code in pkgbasedir.
-for versionfile in ["kmail/kmversion.h", "kontact/src/main.cpp",
-"korganizer/version.h"]:
+The default implementation does nothing.  Derived classes should
-filename = os.path.join(pkgbasedir, versionfile)
+override this method if necessary.
-patched = re.sub("\(enterprise ([^)]*)\)", versionstring,
+"""
-open(filename).read())
-f = open(filename, "w")
-f.write(patched)
-f.close()
 def create_tarball(self, tarballname, workdir, basedir):
+"""Creates a new tarball.
+Parameters:
+tarballname -- the filename of the new tarball
+workdir -- The directory into which to change before running tar.
+(actually this is done with GNUI tar's -C option)
+basedir -- The basedirectory of the files that are packaged
+into the tarfile.  This should be a relative
+filename directly in workdir.
+"""
 logging.info("Creating tarball %r", tarballname)
 run.call(["tar", "czf", tarballname, "-C", workdir, basedir])
 def copy_debian_directory(self, pkgbasedir, pkgbaseversion, changemsg):
+"""Copies the debian directory and updates the copy's changelog
+Parameter:
+pkgbasedir -- The directory holding the unpacked source package
+pkgbaseversion -- The version to update the changelog to
+changemsg -- The message for the changelog
+When determining the actual version for the new package, this
+function looks at the previous version in the changelog.  If it
+has a prefix separated from the version number by a colon this
+prefix is prepended to the pkgbaseversion parameter.  Debian
+uses such prefixes for the kde packages.
+"""
 debian_dir = os.path.join(pkgbasedir, "debian")
 changelog = os.path.join(debian_dir, "changelog")
 self.plant.copy_debian_directory(debian_dir)
 changemsg],
 env=self.plant.debian_environment())
 def create_source_package(self, pkgbasedir, origtargz):
+"""Creates a new source package from pkgbasedir and origtargz"""
 logging.info("Creating new source package")
 run.call(["dpkg-source", "-b", os.path.basename(pkgbasedir),
 os.path.basename(origtargz)],
 cwd=os.path.dirname(pkgbasedir),
 suppress_output=True,
 env=self.plant.debian_environment())
+def move_source_package(self, pkgbasename):
+"""Moves the new source package from the work_dir to the src_dir"""
+logging.info("Moving source package to %r", self.src_dir)
+util.ensure_directory(self.src_dir)
+for filename in [filename for filename in os.listdir(self.work_dir)
+if filename.startswith(pkgbasename)]:
+os.rename(os.path.join(self.work_dir, filename),
+os.path.join(self.src_dir, filename))
 def package(self):
+"""Creates a source package from a subversion checkout.
+After setting up the working directory, this method calls the
+do_package method to do the actual packaging.  Afterwards the
+work directory is removed.
+"""
 util.ensure_directory(self.work_dir)
 try:
 self.status.set("creating_source_package")
-pkgbaseversion, pkgbasedir = self.export_sources()
+self.do_package()
-self.update_version_numbers(pkgbasedir)
-pkgbasename = "kdepim_" + pkgbaseversion
-origtargz = os.path.join(self.work_dir,
-pkgbasename + ".orig.tar.gz")
-self.create_tarball(origtargz, self.work_dir,
-os.path.basename(pkgbasedir))
-changemsg = ("Update to SVN enterprise branch rev. %d"
-% (self.revision,))
-self.copy_debian_directory(pkgbasedir, pkgbaseversion,
-changemsg)
-self.create_source_package(pkgbasedir, origtargz)
-logging.info("Moving source package to %r", self.src_dir)
-util.ensure_directory(self.src_dir)
-for filename in [filename for filename in os.listdir(self.work_dir)
-if filename.startswith(pkgbasename)]:
-os.rename(os.path.join(self.work_dir, filename),
-os.path.join(self.src_dir, filename))
 self.status.set("source_package_created")
 finally:
 logging.info("Removing workdir %r", self.work_dir)
 shutil.rmtree(self.work_dir)
+def do_package(self):
+"""Does the work of creating a source package
+This method must be overriden by derived classes.
+The method should do the work in self.work_dir.  When the
+package is done, the source package files should be in
+self.src_dir.
+"""
+raise NotImplementedError
 class BinaryPackager(object):
 def __init__(self, plant, status, binary_dir, dsc_file, logfile):
 self.status.set("binary_package_created")
 class RevisionPackager(object):
+source_packager_cls = SourcePackager
+binary_packager_cls = BinaryPackager
 def __init__(self, plant, revision):
 self.plant = plant
 self.revision = revision
 self.base_dir = self.plant.pkg_dir_for_revision(self.revision, 1)
 self.status = util.StatusFile(os.path.join(self.base_dir, "status"))
 return os.path.join(self.src_dir, filename)
 return None
 def package(self):
 try:
-src_packager = SourcePackager(self.plant, self.status,
+src_packager = self.source_packager_cls(self.plant, self.status,
 self.work_dir, self.src_dir,
 self.revision)
 src_packager.package()
 dsc_file = self.find_dsc_file()
 if dsc_file is None:
 raise RuntimeError("Cannot find dsc File in %r" % self.src_dir)
-bin_packager = BinaryPackager(self.plant, self.status,
+bin_packager = self.binary_packager_cls(self.plant, self.status,
 self.binary_dir, dsc_file,
 os.path.join(self.base_dir,
 "build.log"))
 bin_packager.package()
 except:
 self.status.set("failed", traceback.format_exc())
 raise
 shutil.rmtree(self.base_dir)
 class AssemblyLine(object):
+revision_packager_cls = RevisionPackager
+svn_external_subdirs = []
+extra_config_desc = []
 def __init__(self, name, base_dir, svn_url, root_cmd, deb_email,
-deb_fullname):
+deb_fullname, packager_class="treepkg.packager"):
 self.name = name
 self.base_dir = base_dir
 self.svn_url = svn_url
 self.root_cmd = root_cmd
 self.deb_email = deb_email
 def pkg_dir_for_revision(self, revision, increment):
 return os.path.join(self.pkg_dir,
 self.pkg_dir_template % locals())
 def last_changed_revision(self):
-rev1 = subversion.last_changed_revision(self.checkout_dir)
+revisions = []
-rev2 = subversion.last_changed_revision(os.path.join(self.checkout_dir,
+for directory in [self.checkout_dir] + self.svn_external_subdirs:
-"admin"))
+directory = os.path.join(self.checkout_dir, directory)
-return max(rev1, rev2)
+revisions.append(subversion.last_changed_revision(directory))
+return max(revisions)
 def last_packaged_revision(self):
 """Returns the revision number of the highest packaged revision.
 If the revision cannot be determined because no already packaged
 logging.info("Exporting sources for tarball to %r", to_dir)
 subversion.export(self.checkout_dir, to_dir)
 # some versions of svn (notably version 1.4.2 shipped with etch)
 # do export externals such as the admin subdirectory.  We may
 # have to do that in an extra step.
-admindir = os.path.join(to_dir, "admin")
+for subdir in self.svn_external_subdirs:
-if not os.path.isdir(admindir):
+absdir = os.path.join(to_dir, subdir)
-subversion.export(os.path.join(self.checkout_dir, "admin"),
+if not os.path.isdir(absdir):
-admindir)
+subversion.export(os.path.join(self.checkout_dir, subdir),
+absdir)
 def copy_debian_directory(self, to_dir):
 logging.info("Copying debian directory to %r", to_dir)
 shutil.copytree(self.debian_dir, to_dir)
 logging.info("New revision is %d", current_revision)
 previous_revision = self.last_packaged_revision()
 logging.info("Previously packaged revision was %d", previous_revision)
 if current_revision > previous_revision:
 logging.info("New revision is not packaged yet")
-return RevisionPackager(self, current_revision)
+return self.revision_packager_cls(self, current_revision)
 else:
 logging.info("New revision already packaged.")
+def create_packager(packager_class, **kw):
+module = util.import_dotted_name(packager_class)
+return module.AssemblyLine(**kw)
 class Packager(object):
 def __init__(self, assembly_lines, check_interval):

Mercurial > treepkg > treepkg

comparison treepkg/packager.py @ 4:fee641fec94e