summaryrefslogtreecommitdiff
path: root/geneticone/backend/package.py
blob: 20e65fd7a1d9311a7e7fc34b77c5b1713a1e98d3 (plain)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
#
# File: geneticone/backend/package.py
# This file is part of the Genetic/One-Project, a graphical portage-frontend.
#
# Copyright (C) 2006 Necoro d.M.
# This is free software.  You may redistribute copies of it under the terms of
# the GNU General Public License version 2.
# There is NO WARRANTY, to the extent permitted by law.
#
# Written by Necoro d.M. <necoro@necoro.net>

from geneticone.backend import *
from geneticone.helper import *
from portage_helper import *
import flags

import gentoolkit
import portage
from portage_util import unique_array

class Package (gentoolkit.Package):
	"""This is a subclass of the gentoolkit.Package-class which a lot of additional functionality we need in Genetic/One."""

	def __init__ (self, cpv):
		"""Constructor.

		@param cpv: The cpv or gentoolkit.Package which describes the package to create.
		@type cpv: string (cat/pkg-ver) or gentoolkit.Package-object."""

		if isinstance(cpv, gentoolkit.Package):
			cpv = cpv.get_cpv()
		gentoolkit.Package.__init__(self, cpv)
	
	def get_mask_status(self):
		"""Gets the numeric mask status of a package. The return value can be translated as a string when taking the following list of modes: [ "  ", " ~", " -", "M ", "M~", "M-" ]

		This method adapted from equery 0.1.4 
		Original author: Karl Trygve Kalleberg <karltk@gentoo.org>

		@returns: mask status
		@rtype: int"""
		
		pkgmask = 0
		if self.is_masked():
			pkgmask = pkgmask + 3
		keywords = self.get_env_var("KEYWORDS").split()
		if "~" + gentoolkit.settings["ARCH"] in keywords:
			pkgmask = pkgmask + 1
		elif "-*" in keywords or "-" + gentoolkit.settings["ARCH"] in keywords:
			pkgmask = pkgmask + 2
		return pkgmask

	def get_all_use_flags (self):
		"""Returns a list of _all_ useflags for this package, i.e. all useflags you can set for this package.
		
		@returns: list of use-flags
		@rtype: list"""

		return unique_array(self.get_env_var("IUSE").split())

	def get_installed_use_flags (self):
		"""Returns a list of the useflags enabled at installation time. If package is not installed, it returns an empty list.
		
		@returns: list of useflags enabled at installation time or an empty list
		@rtype: list"""
		if self.is_installed():
			uses = self.get_use_flags().split()
			iuses = self.get_all_use_flags()
			set = []
			for u in iuses:
				if u in uses:
					set.append(u)
			return set
		else:
			return []
	
	def get_new_use_flags (self):
		"""Returns a list of the new useflags, i.e. these flags which are not written to the portage-system yet.

		@returns: list of flags or []
		@rtype: list"""
		return flags.get_new_use_flags(self)

	def get_actual_use_flags (self):
		"""This returns the result of installed_use_flags + new_use_flags. If the package is not installed, it returns only the new flags.

		@return: list of flags
		@rtype: list"""

		if self.is_installed():
			i_flags = self.get_installed_use_flags()
			for f in self.get_new_use_flags():
				if flags.invert_flag(f) in i_flags:
					i_flags.remove(flags.invert_flag(f))
				elif f not in i_flags:
					i_flags.append(f)
			return i_flags
		else:
			return self.get_new_flags()

	def set_use_flag (self, flag):
		"""Set a use-flag.

		@param flag: the flag to set
		@type flag: string"""
		flags.set_use_flag(self, flag)

	def remove_new_use_flags (self):
		"""Remove all the new use-flags."""
		flags.remove_new_use_flags(self)

	def get_dep_packages (self):
		"""Returns a cpv-list of packages on which this package depends and which have not been installed yet. This does not check the dependencies in a recursive manner.

		@returns: list of cpvs on which the package depend
		@rtype: list
		@raises geneticone.BlockedException: when a package in the dependency-list is blocked by an installed one
		@raises geneticone.PackageNotFoundException: when a package in the dependency list could not be found in the system
		@raises geneticone.DependencyCalcError: when an error occured during executing portage.dep_check()"""

		dep_pkgs = [] # the package list
		
		# check whether we got use-flags which are not visible for portage yet
		newUseFlags = self.get_new_use_flags()
		actual = self.get_settings("USE").split()
		if newUseFlags:
			depUses = []
			for u in newUseFlags:
				if u[0] == "-" and flags.invert_use_flag(u) in actual:
					actual.remove(flags.invert_use_flag(u))
				elif u not in actual:
					actual.append(u)

		# let portage do the main stuff ;)
		# pay attention to any changes here
		deps = portage.dep_check (self.get_env_var("RDEPEND")+" "+self.get_env_var("DEPEND")+" "+self.get_env_var("PDEPEND"), vartree.dbapi, self._settings, myuse = actual)
		
		if not deps: # what is the difference to [1, []] ?
			return [] 

		if deps[0] == 0: # error
			raise DependencyCalcError, deps[1]
		
		deps = deps[1]

		for dep in deps:
			if dep[0] == '!': # blocking sth
				blocked = find_installed_packages(dep[1:])
				if blocked != []:
					raise BlockedException, blocked[0].get_cpv()
				else: # next flag
					continue

			pkg = find_best_match(dep)
			if not dep:
				raise PackageNotFoundException, dep
			else:
				dep_pkgs.append(pkg.get_cpv())

		return dep_pkgs

	def get_cp (self):
		"""Returns the cp-string.
		@returns: category/package.
		@rtype: string"""
		return self.get_category()+"/"+self.get_name()

	def is_masked (self):
		"""Returns True if either masked by package.mask or by profile.
		@returns: mask-status
		@rtype: boolean"""
		# XXX: Better solution than string comparison?
		status = portage.getmaskingstatus(self._cpv)
		if "profile" in status or "package.mask" in status:
			return True
		return False

	def matches (self, criterion):
		"""This checks, whether this package matches a specific verisioning criterion - e.g.: "<=net-im/foobar-1.2".
		@param criterion: the criterion to match against
		@type criterion: string"""
		if portage.match_from_list(criterion, [self.get_cpv()]) == []:
			return False
		else:
			return True
#
# OBSOLETE DEPENDENCY-CALCULATION-METHODS - kept in the case the above ones do not work
#

	#def own_get_dep_packages (self, old_cpv_dict = {}):
	#	# XXX: after having finished this, i realized, that there is already a portage function -.- ;
	#	"""Returns a list of all packages (i.e. package-cpvs) which this package depends on and which not have been installed yet.
	#	Param old_cpv_dict is a {cp: version}-dictionary holding already found deps.
	#	Raises a BlockedException if the package is being blocked by another installed package."""
	#	# XXX: This won't find blocking dependencies
	#	# XXX: Has some problems with modular X (this has a very strange ebuild) ... we should enhance _parse_deps
	#	print "Actual: "+self._cpv # debug output
	#	
	#	uses = [] # list of actual useflags / useflags the package has been installed with
	#	dep_packages = [] # list of packages returned
	#	dep_cpv_dict = {} # all dependencies are inserted here
	#	
	#	# get useflags
	#	if self.is_installed():
	#		uses = self.get_installed_use_flags()
	#	else:
	#		uses = self.get_settings("USE")
	#	
	#	# cycle through dependencies
	#	for (comp, flags, dep_cpv) in self.get_all_deps():

	#		# find blocking packages
	#		if comp and comp[0] == '!':
	#			blocked = find_installed_packages(comp[1:]+dep_cpv)
	#			if blocked != []:
	#				raise BlockedException, blocked[0].get_cpv()
	#			else: # next flag
	#				continue
	#		
	#		# look whether this package is really required
	#		needDep = True
	#		for flag in flags:
	#			if (flag[0] == '!' and flag[1:] in uses) or (flag[0] != '!' and flag not in uses):
	#				needDep = False
	#				break

	#		if needDep: # it is ...
	#			if find_installed_packages(comp+dep_cpv) == []: # ... and not installed yet
	#				d = find_best_match(comp+dep_cpv)
	#				if not d: # no package found
	#					raise PackageNotFoundException, dep_cpv
	#				if d.get_cp() not in old_cpv_dict: # ... and not found already by an other package
	#					dep_cpv_dict[d.get_cp()] = d.get_version()
	#					print "Dep: "+d.get_cpv() # debug
	#					dep_packages.append(d.get_cpv())
	#	
	#	for dep in dep_packages: # find dependencies for each package
	#		old_cpv_dict.update(dep_cpv_dict)
	#		old_cpv_dict.update({self.get_cp() : self.get_version()})
	#		dep_packages += find_packages("="+dep)[0].own_get_dep_packages(old_cpv_dict)

	#	return unique_array(dep_packages)

	#def get_all_deps (self):
	#	"""Returns a linearised list of all first-level dependencies for this package, on
	#	the form [(comparator, [use flags], cpv), ...]"""
	#	return unique_array(self.get_compiletime_deps()+self.get_runtime_deps()+self.get_postmerge_deps())

	#def _parse_deps(self,deps,curuse=[],level=0):
	#	"""Modified method "_parse_deps" of gentoolkit.Package.
	#	Do NOT ignore blocks."""
	#	# store (comparator, [use predicates], cpv)
	#	r = []
	#	comparators = ["~","<",">","=","<=",">="]
	#	end = len(deps)
	#	i = 0
	#	while i < end:
	#		blocked = False
	#		tok = deps[i]
	#		if tok == ')':
	#			return r,i
	#		if tok[-1] == "?":
	#			tok = tok.replace("?","")
	#			sr,l = self._parse_deps(deps[i+2:],curuse=curuse+[tok],level=level+1)
	#			r += sr
	#			i += l + 3
	#			continue
	#		if tok == "||":
	#			sr,l = self._parse_deps(deps[i+2:],curuse,level=level+1)
	#			r += sr
	#			i += l + 3
	#			continue
	#		# conjonction, like in "|| ( ( foo bar ) baz )" => recurse
	#		if tok == "(":
	#			sr,l = self._parse_deps(deps[i+1:],curuse,level=level+1)
	#			r += sr
	#			i += l + 2
	#			continue
	#		# pkg block "!foo/bar" => ignore it
	#		if tok[0] == "!":
	#			#i += 1
	#			#continue
	#			blocked = True # added
	#			tok = tok[1:] # added
	#		# pick out comparator, if any
	#		cmp = ""
	#		for c in comparators:
	#			if tok.find(c) == 0:
	#				cmp = c
	#				if blocked: cmp = "!"+cmp # added
	#		tok = tok[len(cmp):]
	#		r.append((cmp,curuse,tok))
	#		i += 1
	#	return r,i