[gentoo-commits] proj/R_overlay:master commit in: roverlay/depres/

[André Erdmann]

commit:     f65931ef830da61d738dab1dcc9f5588cc260243
Author:     André Erdmann <dywi <AT> mailerd <DOT> de>
AuthorDate: Tue Jun  5 17:20:39 2012 +0000
Commit:     André Erdmann <dywi <AT> mailerd <DOT> de>
CommitDate: Tue Jun  5 17:20:39 2012 +0000
URL:        http://git.overlays.gentoo.org/gitweb/?p=proj/R_overlay.git;a=commit;h=f65931ef

dependency resolution

* added simple rule reader
* started with the dependency resolver

---
 roverlay/depres/depresolver.py |   78 +++++++++++++++++++++++++++---
 roverlay/depres/deprule.py     |  103 +++++++++++++++++++++++++++++++++-------
 roverlay/depres/rulereader.py  |   88 ++++++++++++++++++++++++++++++++++
 3 files changed, 245 insertions(+), 24 deletions(-)

diff --git a/roverlay/depres/__init__.py b/roverlay/depres/__init__.py
new file mode 100644
index 0000000..e69de29

diff --git a/roverlay/depres/depresolver.py b/roverlay/depres/depresolver.py
index 7d7c5e6..ebb88cd 100644
--- a/roverlay/depres/depresolver.py
+++ b/roverlay/depres/depresolver.py
@@ -2,22 +2,55 @@
 # Copyright 2006-2012 Gentoo Foundation
 # Distributed under the terms of the GNU General Public License v2
 
+
 class DependencyResolver:
 
 	def __init__ ( self ):
-		self.channels  = dict()
-		self.listeners = dict()
+		self.logger    = None
+		self.channels  = list ()
+		self.listeners = list ()
+
+
+	def _report_event ( self, event, pkg_env=None, **extra ):
+		"""Reports an event to the log, channels and listeners."""
+		pass
+
+
+	def set_logmask ( self, logmask ):
+		"""Sets the logmask for this DependencyResolver which can be used to
+		filter events that would normally go into the log file.
+		Useful if a listener module reports such events in an extra file.
+
+		arguments:
+		* logmask -- new logmask
+		"""
+		pass
 
 
-	def get_listener ():
+	def add_listener ( self ):
+		"""Adds a listener, which listens to events such as
+		"dependency is unresolvable". Possible use cases include redirecting
+		such events into a file for further parsing.
+
+		arguments:
+		* listener_type
+		"""
 		new_listener = DependencyResolverListener()
 		# register the new listener
 		self.listeners [new_listener.ident] = new_listener
 		return new_listener
 
-	def get_channel ( readonly=False ):
-		# ... TODO
-		pass
+	def get_channel ( self, readonly=False ):
+		"""Returns a communication channel to the DependencyResolver.
+		This channel can be used to _talk_, e.g. queue dependencies for resolution
+		and collect the results later.
+
+		arguments:
+		* readonly -- whether this channel has write access or not
+		"""
+		new channel = DependencyResolverChannel ( self )
+		self.channels [new_channel.ident] = new_channel
+		return new_channel
 
 
 
@@ -26,8 +59,39 @@ class DependencyResolverListener:
 	def __init__ ( self ):
 		self.ident = id ( self )
 
+	def notify ( event_type, pkg_env=None, **extra ):
+		"""Notify this listener about an event."""
+		pass
+
+
 class DependencyResolverChannel ( DependencyResolverListener ):
 
 	def __init__ ( self, main_resolver, *args ):
-		super ( DependencyResolverChannel, self ) . __init__ ( args )
+		super ( DependencyResolverChannel, self ) . __init__ ()
 		self._depres_master = main_resolver
+
+	def close ( self ):
+		"""Closes this channel."""
+		pass
+
+
+class EbuildJobChannel ( DependencyResolverChannel ):
+	def __init__ ( self, main_resolver, *args ):
+		super ( EbuildJobChannel, self ) . __init__ ( main_resolver )
+
+
+	def done ( self ):
+		pass
+
+	def add_dependency ( self, dep_str ):
+		pass
+
+	def add_dependencies ( self, dep_list ):
+		pass
+
+	def satisfy_request ( self ):
+		pass
+
+	def lookup ( self, dep_str ):
+		return None
+

diff --git a/roverlay/depres/deprule.py b/roverlay/depres/deprule.py
index 3a82cbe..b5d1116 100644
--- a/roverlay/depres/deprule.py
+++ b/roverlay/depres/deprule.py
@@ -4,20 +4,20 @@
 
 class DependencyRule:
 	def __init__ ( self ):
-		pass
+		self.max_score = 1000
 
-	def matches ( pkg_env ):
-		return False
+	def matches ( dep_str ):
+		return 0
 
 class SimpleDependencyRule ( DependencyRule ):
 
 	def __init__ ( self, resolving_package, dep_str=None, priority=100 ):
-		super ( SimpleDependencyRule, self ) . __init__ ( self )
+		super ( SimpleDependencyRule, self ) . __init__ ( )
 		self.dep_alias = set ()
 		if dep_str:
 			self.dep_alias.add ( dep_str )
 
-		self.package = resolving_package
+		self.resolving_package = resolving_package
 
 		self.priority = priority
 	# --- end of __init__ (...) ---
@@ -26,35 +26,104 @@ class SimpleDependencyRule ( DependencyRule ):
 		self.dep_alias.add ( dep_str )
 	# --- end of add_resolved (...) ---
 
-	def matches ( self, pkg_env, lowercase=True ):
+	def matches ( self, dep_str, lowercase=True ):
 		if lowercase:
-			lower_dep_str = pkg_env.dep_str
+			lower_dep_str = dep_str
 			for alias in self.dep_alias:
 				if alias.lower() == lower_dep_str:
-					return True
-		elif pkg_env.dep_str in self.dep_alias:
-			return True
+					return self.max_score
+		elif dep_str in self.dep_alias:
+			return self.max_score
 
-		return False
+		return 0
 	# --- end of matches (...) ---
 
+	def get_dep ( self ):
+		return self.resolving_package
+
+	def export_rule ( self ):
+		pass
+
 class DependencyRulePool:
 
-	def __init__ ( self ):
-		self.rules = list ()
-		self._priofunc = lambda x : x.priority
+	def __init__ ( self, name ):
+		self.rules    = list ()
+		self.name     = name
+		self.priority = 0
 	# --- end of __init__ (...) ---
 
-	def _sort_rules ( self ):
-		self.rules.sort ( key=self._priofunc )
+	def sort ( self ):
+		self.rules.sort ( key=lambda rule : rule.priority )
+
+		priority_sum = 0
+		for r in self.rules:
+			priority_sum += r.priority
+
+		self.priority = int ( priority_sum / len ( self.rules ) ) if len ( self.rules ) else 0
+
 		return None
 	# --- end of _sort_rules (...) ---
 
 	def add ( self, rule ):
 		if issubclass ( rule, DependencyRule ):
-			self.rules.add ( rule )
+			self.rules.append ( rule )
 		else:
 			raise Exception ( "bad usage (dependency rule expected)." )
 
 		return None
 	# --- end of add (...) ---
+
+	def matches ( self, dep_str, skip_matches=0 ):
+		"""Tries to find a match in this dependency rule pool.
+		The first match is immediatly returned unless skip_matches is != 0, in
+		which case the first (>0) / last (<0) skip_matches matches are skipped.
+
+		arguments:
+		* dep_str -- dependency to look up
+		* skip_matches --
+		"""
+
+		if abs ( skip_matches ) >= len ( self.rules ):
+			# all matches ignored; cannot expect a result in this case - abort now
+			pass
+
+		else:
+			skipped = 0
+			order = range ( len ( self.rules ) )
+
+			if skip_matches < 1:
+				skip_matches *= -1
+				order.reverse()
+
+			for index in order:
+				score = self.rules [index].matches ( dep_str )
+				if score:
+					if skipped < skip_matches:
+						skipped += 1
+					else:
+						return score, self.rules [index].get_dep ()
+
+
+		return 0, None
+
+
+class SimpleDependencyRulePool ( DependencyRulePool )
+
+	def __init__ ( self, name ):
+		super ( SimpleDependencyRulePool, self ) . __init__ ( name )
+	# --- end of __init__ (...) ---
+
+	def add ( self, rile ):
+		if isinstance ( rule, SimpleDependencyRule ):
+			self.rules.append ( rule )
+		else:
+			raise Exception ( "bad usage (simple dependency rule expected)." )
+	# --- end of add (...) ---
+
+	def export_rules ( self, fh ):
+		for rule in self.rules:
+			to_write = fh.export_rule()
+			if isinstance ( to_write, str ):
+				fh.write ( to_write )
+			else:
+				fh.writelines ( to_write )

diff --git a/roverlay/depres/rulereader.py b/roverlay/depres/rulereader.py
new file mode 100644
index 0000000..6998cb2
--- /dev/null
+++ b/roverlay/depres/rulereader.py
@@ -0,0 +1,88 @@
+
+import re
+import logging
+
+from roverlay.depres.deprule import SimpleDependencyRule
+
+class SimpleDependencyRuleReader:
+
+	one_line_separator = re.compile ( '\s+::\s+' )
+	multiline_start    = '{'
+	multiline_stop     = '}'
+	comment_chars      = list ( '#;' )
+
+
+	def __init__ ( self ):
+		pass
+	# --- end of __init__  (...) ---
+
+	def read_file ( self, filepath ):
+		"""Reads a file that contains SimpleDescriptionRules.
+
+		arguments:
+		* filepath -- file to read
+		"""
+
+		lineno = 0
+
+		try:
+			logging.debug ( "Reading simple dependency rule file " + filepath + "." )
+			fh = open ( filepath, 'r' )
+
+			next_rule = None
+			rules = list ()f
+
+			for line in fh.readlines():
+				lineno += 1
+				line = line.strip()
+
+				if not line:
+					pass
+
+				elif not next_rule is None:
+					# in a multiline rule
+					if line [0] == SimpleDependencyRuleReader.multiline_stop:
+						# end of a multiline rule
+						rules.append ( next_rule )
+						next_rule = None
+					else:
+						# new resolved str
+						next_rule.add_resolved ( line )
+
+				elif line [0] in SimpleDependencyRuleReader.comment_chars:
+					# comment
+					pass
+
+				elif line [-1] == SimpleDependencyRuleReader.multiline_start:
+					# start of multiline rule
+					next_rule = SimpleDependencyRule ( line [:-1].rstrip(), None, 100 )
+
+				else:
+					# one line rule?
+					rule_str = SimpleDependencyRuleReader.one_line_separator.split ( line, 1 )
+
+					if len ( rule_str ) == 2:
+						rules.append (
+							SimpleDependencyRule ( rule_str [0], rule_str [1], 90 )
+						)
+					else:
+						logging.error (
+							"In " + filepath + ", line " + str ( lineno ) + ": cannot use this line."
+						)
+				# ---
+
+			if fh: fh.close ()
+
+			logging.info ( filepath + ": read " + str ( len ( rules ) ) + " dependency rules." )
+
+			return rules
+
+		except IOError as ioerr:
+			if lineno:
+				logging.error ( "Failed to read file " + filepath + " after " + str ( lineno ) " lines."
+			else:
+				logging.error ( "Could not read file " + filepath + "." )
+			raise
+
+		# --- end of read_file (...) ---
+