[gentoo-commits] proj/R_overlay:master commit in: roverlay/overlay/pkgdir/manifest/, roverlay/config/, roverlay/overlay/metadata/, ...

[André Erdmann]

commit:     af13e5117e1f4fe4a4980e9ec0988378771fc4b4
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Thu Dec 13 14:55:28 2012 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Mon Jan 28 23:33:10 2013 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=af13e511

Add support for multiple manifest implementations

Also added support for threaded Manifest file writing, though no available
implementation supports that at the moment.

---
 config/R-overlay.conf.reference                    |   14 +++
 doc/html/usage.html                                |   18 ++++
 doc/rst/usage.rst                                  |   20 ++++
 roverlay/config/entrymap.py                        |   16 +++-
 roverlay/overlay/category.py                       |   66 +++++++++++--
 roverlay/overlay/pkgdir/__init__.py                |   68 ++++++++++++++
 roverlay/overlay/{ => pkgdir}/manifest/__init__.py |    4 +-
 roverlay/overlay/{ => pkgdir}/manifest/env.py      |    0
 .../manifest/manifest_ebuild.py}                   |    2 +-
 roverlay/overlay/{ => pkgdir}/metadata/__init__.py |    2 +-
 .../overlay/{ => pkgdir}/metadata/abstractnodes.py |    0
 roverlay/overlay/{ => pkgdir}/metadata/nodes.py    |    2 +-
 .../{package.py => pkgdir/packagedir_base.py}      |   98 ++++++++++----------
 .../overlay/pkgdir/packagedir_ebuildmanifest.py    |   56 +++++++++++
 14 files changed, 299 insertions(+), 67 deletions(-)

diff --git a/config/R-overlay.conf.reference b/config/R-overlay.conf.reference
index a1ba48c..067e1a7 100644
--- a/config/R-overlay.conf.reference
+++ b/config/R-overlay.conf.reference
@@ -145,6 +145,20 @@
 # *** NOT IN USE ***
 #EBUILD_HEADER = "ebuild_header.txt"
 
+# OVERLAY_MANIFEST_IMPLEMENTATION
+#  Manifest implementation to be used
+#   Currently, there's only one implementation available, manifest
+#   writing using the ebuild(1) executable.
+#   * accepted values:
+#   -> 'default'         -- use the default implementation
+#   -> 'none'            -- do not use any implementation,
+#                           this leads to runtime errors
+#                           whenever write_manifest() is called
+#   -> 'external:ebuild' -- generate Manifest files using ebuild(1)
+#
+#  * defaults to 'default'
+#  * alias: MANIFEST_IMPLEMENTATION
+
 # == other config files ==
 
 # some config options are split from this file for various reasons:

diff --git a/doc/html/usage.html b/doc/html/usage.html
index 026d8b7..ff2a36f 100644
--- a/doc/html/usage.html
+++ b/doc/html/usage.html
@@ -1570,6 +1570,10 @@ This will pass '--bwlimit=&lt;value&gt;' to all rsync commands.</p>
 <dt>ECLASS</dt>
 <dd>Alias to <a class="reference internal" href="#overlay-eclass">OVERLAY_ECLASS</a>.</dd>
 </dl>
+<dl class="docutils" id="manifest-implementation">
+<dt>MANIFEST_IMPLEMENTATION</dt>
+<dd>Alias to <a class="reference internal" href="#overlay-manifest-implementation">OVERLAY_MANIFEST_IMPLEMENTATION</a>.</dd>
+</dl>
 <dl class="docutils" id="overlay-category">
 <dt>OVERLAY_CATEGORY</dt>
 <dd><p class="first">Sets the category of created ebuilds. There are no value type restrictions
@@ -1602,6 +1606,20 @@ per R package. All others will be removed.</p>
 <p class="last">Defaults to &lt;not set&gt;, which disables this feature and keeps all ebuilds.</p>
 </dd>
 </dl>
+<dl class="docutils" id="overlay-manifest-implementation">
+<dt>OVERLAY_MANIFEST_IMPLEMENTATION</dt>
+<dd><p class="first">Sets the implementation to use for Manifest file writing.
+Available choices are 'external:ebuild', 'default' and 'none'.
+Defaults to 'default'.</p>
+<div class="note last">
+<p class="first admonition-title">Note</p>
+<p class="last">Choosing 'none' is destructive - <em>roverlay</em> will fail to function
+whenever Manifest access is required.
+Use the '--no-manifest' command line option to disable manifest
+writing.</p>
+</div>
+</dd>
+</dl>
 <dl class="docutils" id="overlay-name">
 <dt>OVERLAY_NAME</dt>
 <dd><p class="first">Sets the name of the created overlay that will be written into

diff --git a/doc/rst/usage.rst b/doc/rst/usage.rst
index 31c81f0..46e5e00 100644
--- a/doc/rst/usage.rst
+++ b/doc/rst/usage.rst
@@ -1267,6 +1267,11 @@ RSYNC_BWLIMIT
 ECLASS
    Alias to OVERLAY_ECLASS_.
 
+.. _MANIFEST_IMPLEMENTATION:
+
+MANIFEST_IMPLEMENTATION
+   Alias to OVERLAY_MANIFEST_IMPLEMENTATION_.
+
 .. _OVERLAY_CATEGORY:
 
 OVERLAY_CATEGORY
@@ -1303,6 +1308,21 @@ OVERLAY_KEEP_NTH_LATEST
 
    Defaults to <not set>, which disables this feature and keeps all ebuilds.
 
+.. _OVERLAY_MANIFEST_IMPLEMENTATION:
+
+OVERLAY_MANIFEST_IMPLEMENTATION
+   Sets the implementation to use for Manifest file writing.
+   Available choices are 'external:ebuild', 'default' and 'none'.
+   Defaults to 'default'.
+
+   .. Note::
+
+      Choosing 'none' is destructive - *roverlay* will fail to function
+      whenever Manifest access is required.
+      Use the '--no-manifest' command line option to disable manifest
+      writing.
+
+
 .. _OVERLAY_NAME:
 
 OVERLAY_NAME

diff --git a/roverlay/config/entrymap.py b/roverlay/config/entrymap.py
index ef83540..0d679c2 100644
--- a/roverlay/config/entrymap.py
+++ b/roverlay/config/entrymap.py
@@ -213,6 +213,17 @@ CONFIG_ENTRY_MAP = dict (
 		desc = "overlay name, e.g. 'R-Overlay'.",
 	),
 
+	overlay_manifest_implementation = dict (
+		desc    = "manifest implementation to be used",
+		choices = frozenset ((
+			'none',
+			'default'
+			'external:ebuild',
+#			'external:portage',
+#			'internal',
+		)),
+	),
+
 	# ebuild is used to create Manifest files
 	ebuild_prog = dict (
 		path        = [ 'TOOLS', 'ebuild_prog' ],
@@ -229,8 +240,9 @@ CONFIG_ENTRY_MAP = dict (
 
 
 	# * alias
-	eclass          = 'overlay_eclass',
-	keep_nth_latest = 'overlay_keep_nth_latest',
+	eclass                  = 'overlay_eclass',
+	keep_nth_latest         = 'overlay_keep_nth_latest',
+	manifest_implementation = 'overlay_manifest_implementation',
 
 	# --- overlay
 

diff --git a/roverlay/overlay/category.py b/roverlay/overlay/category.py
index 5ddc9ad..9090bb7 100644
--- a/roverlay/overlay/category.py
+++ b/roverlay/overlay/category.py
@@ -22,7 +22,7 @@ try:
 except ImportError:
 	import Queue as queue
 
-from roverlay.overlay.package import PackageDir
+from roverlay.overlay import pkgdir
 
 class Category ( object ):
 
@@ -61,7 +61,7 @@ class Category ( object ):
 			self._lock.acquire()
 			try:
 				if not pkg_name in self._subdirs:
-					newpkg = PackageDir (
+					newpkg = pkgdir.get_class() (
 						name        = pkg_name,
 						logger      = self.logger,
 						directory   = self.physical_location + os.sep + pkg_name,
@@ -83,15 +83,17 @@ class Category ( object ):
 
 		returns: success
 		"""
-		subdir = self._get_package_dir ( package_info ['name'] )
-		return subdir.add ( package_info, **pkg_add_kw )
+		return self._get_package_dir ( package_info ['name'] ).add (
+			package_info, **pkg_add_kw
+		)
 	# --- end of add (...) ---
 
 	def empty ( self ):
 		"""Returns True if this category contains 0 ebuilds."""
-		return \
-			len ( self._subdirs ) == 0 or \
-			not False in ( d.empty() for d in self._subdirs.values() )
+		return (
+			len ( self._subdirs ) == 0 or
+			all ( d.empty() for d in self._subdirs.values() )
+		)
 	# --- end of empty (...) ---
 
 	def has ( self, subdir ):
@@ -121,6 +123,34 @@ class Category ( object ):
 					yield self.name + os.sep + name
 	# --- end of list_packages (...) ---
 
+	def supports_threadsafe_manifest_writing ( self, unsafe=True ):
+		"""Returns True if manifest writing is thread safe for this
+		category, else False. Also returns True for empty categories.
+
+		arguments:
+		* unsafe -- if False : verify that all packages of this category support
+		                       thread safe writing
+		            else     : assume that all packages of this category are
+		                       instances of the same class and check only the
+		                       first one (=> faster).
+		            Defaults to True.
+
+		"""
+		if unsafe:
+			try:
+				return bool (
+					next ( iter ( self._subdirs.value ) ).MANIFEST_THREADSAFE
+				)
+			except StopIteration:
+				return True
+		else:
+			for pkgdir in self._subdirs.values():
+				#if not pkgdir.__class__.MANIFEST_THREADSAFE:
+				if not pkgdir.MANIFEST_THREADSAFE:
+					return False
+			return True
+	# --- end of supports_threadsafe_manifest_writing (...) ---
+
 	def remove_empty ( self ):
 		"""This removes all empty PackageDirs."""
 		with self._lock:
@@ -133,7 +163,12 @@ class Category ( object ):
 		"""Scans this category for existing ebuilds."""
 		for subdir in os.listdir ( self.physical_location ):
 			if self.has_dir ( subdir ):
-				self._get_package_dir ( subdir ).scan ( **kw )
+				pkgdir = self._get_package_dir ( subdir )
+				try:
+					pkgdir.scan ( **kw )
+				finally:
+					if pkgdir.empty():
+						del self._subdirs [subdir]
 	# --- end of scan (...) ---
 
 	def show ( self, **show_kw ):
@@ -182,6 +217,7 @@ class Category ( object ):
 			overwrite_ebuilds = overwrite_ebuilds,
 			keep_n_ebuilds    = keep_n_ebuilds,
 			cautious          = cautious,
+			write_manifest    = write_manifest,
 		)
 
 		# start writing:
@@ -198,9 +234,19 @@ class Category ( object ):
 			# don't create more workers than write jobs available
 			max_jobs = min ( max_jobs, len ( self._subdirs ) )
 
+			manifest_threadsafe = self.supports_threadsafe_manifest_writing (
+				unsafe=True
+			)
+#			manifest_threadsafe = True
 			write_queue = queue.Queue()
 			for package in self._subdirs.values():
 				write_queue.put_nowait ( package )
+#				if not package.MANIFEST_THREADSAFE:
+#					manifest_threadsafe = False
+
+			write_kwargs ['write_manifest'] = (
+				write_manifest and manifest_threadsafe
+			)
 
 			workers = frozenset (
 				threading.Thread (
@@ -219,7 +265,7 @@ class Category ( object ):
 
 			# write manifest files
 			# fixme: debug print
-			if write_manifest:
+			if write_manifest and ( not manifest_threadsafe ):
 				#self.logger.info ( "Writing Manifest files for {}".format ( name ) )
 				print ( "Writing Manifest files ..." )
 				for package in self._subdirs.values():
@@ -227,7 +273,7 @@ class Category ( object ):
 
 		else:
 			for package in self._subdirs.values():
-				package.write ( write_manifest=write_manifest, **write_kwargs )
+				package.write ( **write_kwargs )
 
 			self.remove_empty()
 	# --- end of write (...) ---

diff --git a/roverlay/overlay/pkgdir/__init__.py b/roverlay/overlay/pkgdir/__init__.py
new file mode 100644
index 0000000..e4ebffa
--- /dev/null
+++ b/roverlay/overlay/pkgdir/__init__.py
@@ -0,0 +1,68 @@
+# R overlay -- overlay package, package directory (<??>)
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+__all__ = [ 'create', 'get_class', ]
+
+# the actual PackageDir implementation will be loaded after initialization
+# of the config module (using importlib.import_module)
+import importlib
+
+import logging
+
+import roverlay.config
+
+
+# _package_dir_module is an imported module or None
+_package_dir_module = None
+_package_dir_class  = None
+
+_PACKAGE_DIR_IMPLEMENTATIONS = {
+   'none'             : 'packagedir_base',
+   'default'          : 'packagedir_ebuildmanifest',
+   'external:ebuild'  : 'packagedir_ebuildmanifest',
+#   'external:portage' : 'packagedir_portagemanifest',
+#   'internal'         : NotImplemented,
+}
+
+def _configure():
+   mf_impl = roverlay.config.get (
+      'OVERLAY.manifest_implementation',
+      _PACKAGE_DIR_IMPLEMENTATIONS ['default']
+   )
+
+   pkgdir_impl = _PACKAGE_DIR_IMPLEMENTATIONS.get ( mf_impl, None )
+
+   if pkgdir_impl is not None:
+      global _package_dir_module
+      _package_dir_module = importlib.import_module (
+         'roverlay.overlay.pkgdir.' + pkgdir_impl
+      )
+
+      global _package_dir_class
+      if hasattr ( _package_dir_module, 'PackageDir' ):
+         _package_dir_class = _package_dir_module.PackageDir
+      else:
+         _package_dir_class = _package_dir_module.PackageDirBase
+
+      logging.getLogger ('pkgdir').debug (
+         'Using {!r} as manifest implementation.'.format ( mf_impl )
+      )
+   else:
+      # NameError, NotImplementedError, ...?
+      raise Exception (
+         "PackageDir/Manifest implementation {} is unknown".format ( mf_impl )
+      )
+# --- end of configure (...) ---
+
+def get_class():
+   if _package_dir_class is None:
+      _configure()
+   return _package_dir_class
+# --- end of get_class (...) ---
+
+def create ( *args, **kwargs ):
+   return get_class() ( *args, **kwargs )
+# --- end of create (...) ---

diff --git a/roverlay/overlay/manifest/__init__.py b/roverlay/overlay/pkgdir/manifest/__init__.py
similarity index 89%
rename from roverlay/overlay/manifest/__init__.py
rename to roverlay/overlay/pkgdir/manifest/__init__.py
index 3e8bcbf..f68c1b7 100644
--- a/roverlay/overlay/manifest/__init__.py
+++ b/roverlay/overlay/pkgdir/manifest/__init__.py
@@ -15,9 +15,9 @@ __all__ = [ 'create_manifest', ]
 import logging
 import threading
 
-from roverlay.overlay.manifest import helpers
+from roverlay.overlay.pkgdir.manifest import manifest_ebuild
 
-_manifest_creation = helpers.ExternalManifestCreation ( lazy_init=True )
+_manifest_creation = manifest_ebuild.ExternalManifestCreation ( lazy_init=True )
 # ExternalManifestCreation does not support threads (-> multiprocesses)
 # for one directory/overlay
 _manifest_lock = threading.Lock()

diff --git a/roverlay/overlay/manifest/env.py b/roverlay/overlay/pkgdir/manifest/env.py
similarity index 100%
rename from roverlay/overlay/manifest/env.py
rename to roverlay/overlay/pkgdir/manifest/env.py

diff --git a/roverlay/overlay/manifest/helpers.py b/roverlay/overlay/pkgdir/manifest/manifest_ebuild.py
similarity index 98%
rename from roverlay/overlay/manifest/helpers.py
rename to roverlay/overlay/pkgdir/manifest/manifest_ebuild.py
index e30a5d4..b6e3fc0 100644
--- a/roverlay/overlay/manifest/helpers.py
+++ b/roverlay/overlay/pkgdir/manifest/manifest_ebuild.py
@@ -22,7 +22,7 @@ import subprocess
 
 from roverlay import config, strutil
 
-from roverlay.overlay.manifest.env import ManifestEnv
+from roverlay.overlay.pkgdir.manifest.env import ManifestEnv
 
 class ExternalManifestCreation ( object ):
 	"""This class implements Manifest creation using the low level ebuild

diff --git a/roverlay/overlay/metadata/__init__.py b/roverlay/overlay/pkgdir/metadata/__init__.py
similarity index 98%
rename from roverlay/overlay/metadata/__init__.py
rename to roverlay/overlay/pkgdir/metadata/__init__.py
index 49af593..fb6f374 100644
--- a/roverlay/overlay/metadata/__init__.py
+++ b/roverlay/overlay/pkgdir/metadata/__init__.py
@@ -15,7 +15,7 @@ __all__ = [ 'MetadataJob', ]
 
 import roverlay.config
 
-from roverlay.overlay.metadata import nodes
+from roverlay.overlay.pkgdir.metadata import nodes
 
 USE_FULL_DESCRIPTION = True
 

diff --git a/roverlay/overlay/metadata/abstractnodes.py b/roverlay/overlay/pkgdir/metadata/abstractnodes.py
similarity index 100%
rename from roverlay/overlay/metadata/abstractnodes.py
rename to roverlay/overlay/pkgdir/metadata/abstractnodes.py

diff --git a/roverlay/overlay/metadata/nodes.py b/roverlay/overlay/pkgdir/metadata/nodes.py
similarity index 98%
rename from roverlay/overlay/metadata/nodes.py
rename to roverlay/overlay/pkgdir/metadata/nodes.py
index b3ea8d0..cdf29a8 100644
--- a/roverlay/overlay/metadata/nodes.py
+++ b/roverlay/overlay/pkgdir/metadata/nodes.py
@@ -12,7 +12,7 @@ and the MetadataRoot (<pkgmetadata>...</pkgmetadata>).
 """
 
 # import abstract nodes
-from roverlay.overlay.metadata.abstractnodes import \
+from roverlay.overlay.pkgdir.metadata.abstractnodes import \
 	MetadataNode, MetadataNodeNamedAccess, MetadataLeaf
 
 

diff --git a/roverlay/overlay/package.py b/roverlay/overlay/pkgdir/packagedir_base.py
similarity index 91%
rename from roverlay/overlay/package.py
rename to roverlay/overlay/pkgdir/packagedir_base.py
index 297acf6..34b7ef5 100644
--- a/roverlay/overlay/package.py
+++ b/roverlay/overlay/pkgdir/packagedir_base.py
@@ -13,22 +13,28 @@ the existing package directory.
 Each PackageDir represents one package name (e.g. "seewave").
 """
 
-__all__ = [ 'PackageDir', ]
+__all__ = [ 'PackageDirBase', ]
 
 import os
 import sys
 import threading
 import shutil
 
-from roverlay                  import util
-from roverlay.overlay          import manifest
-from roverlay.packageinfo      import PackageInfo
-from roverlay.overlay.metadata import MetadataJob
+from roverlay                         import util
+from roverlay.packageinfo             import PackageInfo
+from roverlay.overlay.pkgdir.metadata import MetadataJob
 
-SUPPRESS_EXCEPTIONS = True
+class PackageDirBase ( object ):
 
-class PackageDir ( object ):
-	EBUILD_SUFFIX = '.ebuild'
+	EBUILD_SUFFIX       = '.ebuild'
+	SUPPRESS_EXCEPTIONS = True
+
+	# MANIFEST_THREADSAFE (tri-state)
+	# * None  -- unknown (e.g. write_manifest() not implemented)
+	# * False -- write_manifest() is not thread safe
+	# * True  -- ^ is thread safe
+	#
+	MANIFEST_THREADSAFE = None
 
 	def __init__ ( self,
 		name, logger, directory, get_header, runtime_incremental
@@ -71,7 +77,6 @@ class PackageDir ( object ):
 
 		# used to track changes for this package dir
 		self.modified          = False
-		self._manifest_package = None
 		self._need_manifest    = False
 		self._need_metadata    = False
 	# --- end of __init__ (...) ---
@@ -92,6 +97,13 @@ class PackageDir ( object ):
 			return False
 	# --- end of remove_ebuild_file (...) ---
 
+	def _scan_add_package ( self, efile, pvr ):
+		p = PackageInfo (
+			physical_only=True, pvr=pvr, ebuild_file=efile
+		)
+		self._packages [ p ['ebuild_verstr'] ] = p
+	# --- end of _scan_add_package (...) ---
+
 	def add ( self, package_info, add_if_physical=False ):
 		"""Adds a package to this PackageDir.
 
@@ -123,8 +135,10 @@ class PackageDir ( object ):
 							)
 						)
 				else:
-					# package has been added to this overlay before
-					self.logger.info (
+					# package has been added to this packagedir before,
+					# this most likely happens if it is available via several
+					# remotes
+					self.logger.debug (
 						"'{PN}-{PVR}.ebuild' already exists, cannot add it!".format (
 						PN=self.name, PVR=shortver
 						)
@@ -355,8 +369,8 @@ class PackageDir ( object ):
 					else:
 						# $PN does not match directory name, warn about that
 						self.logger.warning (
-							"$PN does not match directory name, ignoring {!r}.".\
-							format ( f )
+							"$PN {!r} does not match directory name, ignoring {!r}.".\
+							format ( pn, f )
 						)
 				except:
 					self.logger.warning (
@@ -368,10 +382,15 @@ class PackageDir ( object ):
 		if os.path.isfile ( self.physical_location + os.sep + 'Manifest' ):
 			for pvr, efile in scan_ebuilds():
 				if pvr not in self._packages:
-					p = PackageInfo (
-						physical_only=True, pvr=pvr, ebuild_file=efile
-					)
-					self._packages [ p ['ebuild_verstr'] ] = p
+					try:
+						self._scan_add_package ( efile, pvr )
+					except ValueError as ve:
+						self.logger.error (
+							"Failed to add ebuild {!r} due to {!r}.".format (
+								efile, ve
+							)
+						)
+						raise
 	# --- end of scan (...) ---
 
 	def show ( self, stream=sys.stderr ):
@@ -414,7 +433,7 @@ class PackageDir ( object ):
 		* write_manifest    -- if set and False: don't write the Manifest file
 		* write_metadata    -- if set and False: don't write the metadata file
 		* overwrite_ebuilds -- whether to overwrite ebuilds,
-		                        None means autodetect, enable overwriting
+		                        None means autodetect: enable overwriting
 		                        if not modified since last write
 		                        Defaults to False
 		* cleanup           -- clean up after writing
@@ -449,10 +468,14 @@ class PackageDir ( object ):
 				# write ebuilds
 				if self.modified and write_ebuilds:
 					success = self.write_ebuilds (
-						# None ~ not modified
-						overwrite = overwrite_ebuilds \
-							if overwrite_ebuilds is not None \
-							else not self.modified
+						# ( overwrite == None ) <= not modified, which is not
+						# possible in this if-branch
+
+						overwrite = bool ( overwrite_ebuilds )
+
+#						overwrite = overwrite_ebuilds \
+#							if overwrite_ebuilds is not None \
+#							else not self.modified
 					)
 
 				# cautious: remove ebuilds after writing them
@@ -485,8 +508,7 @@ class PackageDir ( object ):
 		arguments:
 		* shared_fh      -- if set and not None: don't use own file handles
 		                     (i.e. write files), write everything into shared_fh
-		* overwrite      -- write ebuilds that have been written before,
-		                     defaults to True
+		* overwrite      -- write ebuilds that have been written before
 		"""
 		ebuild_header = self.get_header()
 
@@ -574,33 +596,9 @@ class PackageDir ( object ):
 		raises:
 		* Exception if no ebuild exists
 		"""
-
-		# it should be sufficient to call create_manifest for one ebuild,
-		#  choosing the latest one that exists in self.physical_location and
-		#  has enough data (DISTDIR, EBUILD_FILE) for this task.
-		#  Additionally, all DISTDIRs (multiple repos, sub directories) have
-		#  to be collected and passed to Manifest creation.
-		#  => collect suitable PackageInfo objects from self._packages
-		#
-		pkgs_for_manifest = tuple (
-			p for p in self._packages.values() \
-				if p.has ( 'distdir', 'ebuild_file' )
+		raise NotImplementedError (
+			"write_manifest() needs to be implemented by derived classes."
 		)
-
-		if pkgs_for_manifest:
-			if manifest.create_manifest ( pkgs_for_manifest, nofail=False ):
-				self._need_manifest = False
-				return True
-		elif ignore_empty:
-			return True
-		else:
-			raise Exception (
-				'In {mydir}: No ebuild written so far! '
-				'I really don\'t know what do to!'.format (
-					mydir=self.physical_location
-			) )
-
-		return False
 	# --- end of write_manifest (...) ---
 
 	def write_metadata ( self, shared_fh=None ):

diff --git a/roverlay/overlay/pkgdir/packagedir_ebuildmanifest.py b/roverlay/overlay/pkgdir/packagedir_ebuildmanifest.py
new file mode 100644
index 0000000..e1961dd
--- /dev/null
+++ b/roverlay/overlay/pkgdir/packagedir_ebuildmanifest.py
@@ -0,0 +1,56 @@
+# R overlay -- overlay package, package directory
+# -*- coding: utf-8 -*-
+# Copyright (C) 2012 André Erdmann <dywi@×××××××.de>
+# Distributed under the terms of the GNU General Public License;
+# either version 2 of the License, or (at your option) any later version.
+
+__all__ = [ 'PackageDir', ]
+
+from roverlay.overlay.pkgdir import manifest
+from roverlay.overlay.pkgdir import packagedir_base
+
+class PackageDir ( packagedir_base.PackageDirBase ):
+	"""
+	PackageDir class that uses the ebuild executable for Manifest writing.
+	"""
+
+	MANIFEST_THREADSAFE = False
+
+	def write_manifest ( self, ignore_empty=False ):
+		"""Generates and writes the Manifest file for this package.
+
+		expects: called after writing metadata/ebuilds
+
+		returns: success (True/False)
+
+		raises:
+		* Exception if no ebuild exists
+		"""
+
+		# it should be sufficient to call create_manifest for one ebuild,
+		#  choosing the latest one that exists in self.physical_location and
+		#  has enough data (DISTDIR, EBUILD_FILE) for this task.
+		#  Additionally, all DISTDIRs (multiple repos, sub directories) have
+		#  to be collected and passed to Manifest creation.
+		#  => collect suitable PackageInfo objects from self._packages
+		#
+		pkgs_for_manifest = tuple (
+			p for p in self._packages.values() \
+			if p.has ( 'distdir', 'ebuild_file' )
+		)
+
+		if pkgs_for_manifest:
+			if manifest.create_manifest ( pkgs_for_manifest, nofail=False ):
+				self._need_manifest = False
+				return True
+		elif ignore_empty:
+			return True
+		else:
+			raise Exception (
+				'In {mydir}: No ebuild written so far! '
+				'I really don\'t know what do to!'.format (
+					mydir=self.physical_location
+			) )
+
+		return False
+	# --- end of write_manifest (...) ---