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
|
# -*- coding: utf-8 -*-
#
# File: portato/backend/portage/package.py
# This file is part of the Portato-Project, a graphical portage-frontend.
#
# Copyright (C) 2006-2007 René 'Necoro' Neumann
# 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 René 'Necoro' Neumann <necoro@necoro.net>
from __future__ import absolute_import, with_statement
from ..package import Package
from .. import flags
from .. import system
from ..exceptions import BlockedException, PackageNotFoundException
from ...helper import debug, unique_array
import portage, portage_dep
import os.path
from gettext import lgettext as _
class PortagePackage (Package):
"""This is a class abstracting a normal package which can be installed for the portage-system."""
def __init__ (self, cpv):
"""Constructor.
@param cpv: The cpv which describes the package to create.
@type cpv: string (cat/pkg-ver)"""
Package.__init__(self, cpv)
self._settings = system.settings
self._settingslock = system.settings.settingslock
self._trees = system.settings.trees
self.forced_flags = set()
with self._settingslock:
self._settings.settings.setcpv(self._cpv)
self.forced_flags.update(self._settings.settings.usemask)
self.forced_flags.update(self._settings.settings.useforce)
try:
self._status = portage.getmaskingstatus(self.get_cpv(), settings = self._settings.settings)
except KeyError: # package is not located in the system
self._status = None
if self._status and len(self._status) == 1 and self._status[0] == "corrupted":
self._status = None
def is_installed(self):
return self._settings.vartree.dbapi.cpv_exists(self._cpv)
def is_overlay(self):
dir,ovl = self._settings.porttree.dbapi.findname2(self._cpv)
return ovl != self._settings.settings["PORTDIR"] and str(ovl) != "0"
def get_overlay_path (self):
dir,ovl = self._settings.porttree.dbapi.findname2(self._cpv)
return ovl
def is_in_system (self):
return (self._status != None)
def is_missing_keyword(self):
if self._status and "missing keyword" in self._status:
return True
return False
def is_testing(self, use_keywords = False):
testArch = "~" + self.get_global_settings("ARCH")
if not use_keywords: # keywords are NOT taken into account
if testArch in self.get_package_settings("KEYWORDS").split():
return True
return False
else: # keywords are taken into account
status = flags.new_testing_status(self.get_cpv())
if status is None: # we haven't changed it in any way
if self._status and testArch+" keyword" in self._status:
return True
return False
else:
return status
def is_masked (self, use_changed = True):
if use_changed:
status = flags.new_masking_status(self.get_cpv())
if status != None: # we have locally changed it
if status == "masked": return True
elif status == "unmasked": return False
else:
error(_("BUG in flags.new_masking_status. It returns \'%s\'"), status)
else: # we have not touched the status
if self._status and ("profile" in self._status or "package.mask" in self._status):
return True
return False
else: # we want the original portage value XXX: bug if masked by user AND by system
# get the normal masked ones
if self._status and ("profile" in self._status or "package.mask" in self._status):
if not flags.is_locally_masked(self, changes = False): # assume that if it is locally masked, it is not masked by the system
return True
else: # more difficult: get the ones we unmasked, but are masked by the system
try:
masked = self._settings.settings.pmaskdict[self.get_cp()]
except KeyError: # key error: not masked
return False
for cpv in masked:
if self.matches(cpv):
if not flags.is_locally_masked(self, changes = False): # assume that if it is locally masked, it is not masked by the system
return True
else:
return False
return False
def get_masking_reason(self):
reason = portage.getmaskingreason(self.get_cpv(), settings = self._settings.settings)
if reason:
return reason[:-1] # strip of last \n
else:
return reason
def get_iuse_flags (self, installed = False):
if installed or not self.is_in_system():
tree = self._settings.vartree
else:
tree = self._settings.porttree
return list(set(self.get_package_settings("IUSE", tree = tree).split()).difference(self.forced_flags))
def get_matched_dep_packages (self, depvar):
# change the useflags, because we have internally changed some, but not made them visible for portage
actual = self.get_actual_use_flags()
depstring = ""
try:
for d in depvar:
depstring += self.get_package_settings(d, tree = self._settings.porttree)+" "
except KeyError: # not found in porttree - use vartree
depstring = ""
for d in depvar:
depstring += self.get_package_settings(d, tree = self._settings.vartree)+" "
deps = portage.dep_check(depstring, None, self._settings.settings, myuse = actual, trees = self._trees)
if not deps: # FIXME: what is the difference to [1, []] ?
return []
if deps[0] == 0: # error
raise DependencyCalcError, deps[1]
deps = deps[1]
retlist = []
for d in deps:
if not d[0] == "!":
retlist.append(d)
return retlist
def get_dep_packages (self, depvar = ["RDEPEND", "PDEPEND", "DEPEND"], with_criterions = False):
dep_pkgs = [] # the package list
# change the useflags, because we have internally changed some, but not made them visible for portage
actual = self.get_actual_use_flags()
depstring = ""
for d in depvar:
depstring += self.get_package_settings(d, tree=self._settings.porttree)+" "
# let portage do the main stuff ;)
# pay attention to any changes here
deps = portage.dep_check (depstring, self._settings.vartree.dbapi, self._settings.settings, myuse = actual, trees = self._trees)
if not deps: # FIXME: what is the difference to [1, []] ?
return []
if deps[0] == 0: # error
raise DependencyCalcError, deps[1]
deps = deps[1]
def create_dep_pkgs_data (dep, pkg):
"""Returns the data to enter into the dep_pkgs list, which is either the package cpv or a tuple
consisting of the cpv and the criterion."""
if with_criterions:
return (pkg.get_cpv(), dep)
else:
return pkg.get_cpv()
for dep in deps:
if dep[0] == '!': # blocking sth
dep = dep[1:]
if dep != self.get_cp(): # not cpv, because a version might explicitly block another one
blocked = system.find_installed_packages(dep)
if blocked != []:
raise BlockedException, (self.get_cpv(), blocked[0].get_cpv())
continue # finished with the blocking one -> next
pkg = system.find_best_match(dep)
if not pkg: # try to find masked ones
list = system.find_packages(dep, masked = True)
if not list:
raise PackageNotFoundException, dep
list = system.sort_package_list(list)
list.reverse()
done = False
for i in range(len(list)):
p = list[i]
if not p.is_masked():
dep_pkgs.append(create_dep_pkgs_data(dep, p))
done = True
break
if not done:
dep_pkgs.append(create_dep_pkgs_data(dep, list[0]))
else:
dep_pkgs.append(create_dep_pkgs_data(dep, pkg))
return dep_pkgs
def get_global_settings(self, key):
with self._settingslock:
self._settings.settings.setcpv(self._cpv)
v = self._settings.settings[key]
return v
def get_ebuild_path(self):
return self._settings.porttree.dbapi.findname(self._cpv)
def get_package_settings(self, var, tree = None):
if not tree:
mytree = self._settings.vartree
if not self.is_installed():
mytree = self._settings.porttree
else:
mytree = tree
r = mytree.dbapi.aux_get(self._cpv,[var])
return r[0]
def get_use_flags(self):
if self.is_installed():
return self.get_package_settings("USE", tree = self._settings.vartree)
else: return ""
def compare_version(self,other):
v1 = self._scpv
v2 = portage.catpkgsplit(other.get_cpv())
# if category is different
if v1[0] != v2[0]:
return cmp(v1[0],v2[0])
# if name is different
elif v1[1] != v2[1]:
return cmp(v1[1],v2[1])
# Compare versions
else:
return portage.pkgcmp(v1[1:],v2[1:])
def matches (self, criterion):
return system.cpv_matches(self.get_cpv(), criterion)
|