1
2 '''
3 # DESCRIPTION:
4 # Entropy Object Oriented Interface
5
6 Copyright (C) 2007-2009 Fabio Erculiani
7
8 This program is free software; you can redistribute it and/or modify
9 it under the terms of the GNU General Public License as published by
10 the Free Software Foundation; either version 2 of the License, or
11 (at your option) any later version.
12
13 This program is distributed in the hope that it will be useful,
14 but WITHOUT ANY WARRANTY; without even the implied warranty of
15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 GNU General Public License for more details.
17
18 You should have received a copy of the GNU General Public License
19 along with this program; if not, write to the Free Software
20 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
21 '''
22
23 import os
24 import sys
25 import subprocess
26 import tempfile
27
28 from entropy.const import etpConst, etpSys
29 from entropy.output import blue, darkgreen, red, darkred, bold, purple, brown
30 from entropy.exceptions import IncorrectParameter, PermissionDenied, \
31 SystemDatabaseError
32 from entropy.i18n import _
33 from entropy.core import SystemSettings
34
36
37 import entropy.tools as entropyTools
38 from entropy.misc import Lifo
40
41 self.Output = OutputInterface
42 self.SystemSettings = SystemSettings()
43
44 if not hasattr(self.Output, 'updateProgress'):
45 mytxt = _("Output interface has no updateProgress method")
46 raise IncorrectParameter("IncorrectParameter: %s" % (mytxt,))
47 elif not callable(self.Output.updateProgress):
48 mytxt = _("Output interface has no updateProgress method")
49 raise IncorrectParameter("IncorrectParameter: %s" % (mytxt,))
50
52
53 repo = self.SystemSettings['repositories']['default_repository']
54
55 scan_msg = blue(_("Now searching for broken depends"))
56 self.Output.updateProgress(
57 "[repo:%s] %s..." % (
58 darkgreen(repo),
59 scan_msg,
60 ),
61 importance = 1,
62 type = "info",
63 header = red(" @@ ")
64 )
65
66 broken = False
67
68 count = 0
69 maxcount = len(idpackages)
70 for idpackage in idpackages:
71 count += 1
72 atom = dbconn.retrieveAtom(idpackage)
73 scan_msg = "%s, %s:" % (
74 blue(_("scanning for broken depends")),
75 darkgreen(atom),
76 )
77 self.Output.updateProgress(
78 "[repo:%s] %s" % (
79 darkgreen(repo),
80 scan_msg,
81 ),
82 importance = 1,
83 type = "info",
84 header = blue(" @@ "),
85 back = True,
86 count = (count, maxcount,)
87 )
88 mydepends = dbconn.retrieveDepends(idpackage)
89 if not mydepends:
90 continue
91 for mydepend in mydepends:
92 myatom = dbconn.retrieveAtom(mydepend)
93 self.Output.updateProgress(
94 "[repo:%s] %s => %s" % (
95 darkgreen(repo),
96 darkgreen(atom),
97 darkred(myatom),
98 ),
99 importance = 0,
100 type = "info",
101 header = blue(" @@ "),
102 back = True,
103 count = (count, maxcount,)
104 )
105 mycontent = dbconn.retrieveContent(mydepend)
106 mybreakages = self.content_test(mycontent)
107 if not mybreakages:
108 continue
109 broken = True
110 self.Output.updateProgress(
111 "[repo:%s] %s %s => %s" % (
112 darkgreen(repo),
113 darkgreen(atom),
114 darkred(myatom),
115 bold(_("broken libraries detected")),
116 ),
117 importance = 1,
118 type = "warning",
119 header = purple(" @@ "),
120 count = (count, maxcount,)
121 )
122 for mylib in mybreakages:
123 self.Output.updateProgress(
124 "%s %s:" % (
125 darkgreen(mylib),
126 red(_("needs")),
127 ),
128 importance = 1,
129 type = "warning",
130 header = brown(" ## ")
131 )
132 for needed in mybreakages[mylib]:
133 self.Output.updateProgress(
134 "%s" % (
135 red(needed),
136 ),
137 importance = 1,
138 type = "warning",
139 header = purple(" # ")
140 )
141 return broken
142
143 - def scan_missing_dependencies(self, idpackages, dbconn, ask = True,
144 self_check = False, repo = None, black_list = None,
145 black_list_adder = None):
146
147 if repo == None:
148 repo = self.SystemSettings['repositories']['default_repository']
149
150 if not isinstance(black_list, set):
151 black_list = set()
152
153 taint = False
154 scan_msg = blue(_("Now searching for missing RDEPENDs"))
155 self.Output.updateProgress(
156 "[repo:%s] %s..." % (
157 darkgreen(repo),
158 scan_msg,
159 ),
160 importance = 1,
161 type = "info",
162 header = red(" @@ ")
163 )
164 scan_msg = blue(_("scanning for missing RDEPENDs"))
165 count = 0
166 maxcount = len(idpackages)
167 for idpackage in idpackages:
168 count += 1
169 atom = dbconn.retrieveAtom(idpackage)
170 if not atom:
171 continue
172 self.Output.updateProgress(
173 "[repo:%s] %s: %s" % (
174 darkgreen(repo),
175 scan_msg,
176 darkgreen(atom),
177 ),
178 importance = 1,
179 type = "info",
180 header = blue(" @@ "),
181 back = True,
182 count = (count, maxcount,)
183 )
184 missing_extended, missing = self.get_missing_rdepends(dbconn,
185 idpackage, self_check = self_check)
186 missing -= black_list
187 for item in missing_extended.keys():
188 missing_extended[item] -= black_list
189 if not missing_extended[item]:
190 del missing_extended[item]
191 if (not missing) or (not missing_extended):
192 continue
193 self.Output.updateProgress(
194 "[repo:%s] %s: %s %s:" % (
195 darkgreen(repo),
196 blue("package"),
197 darkgreen(atom),
198 blue(_("is missing the following dependencies")),
199 ),
200 importance = 1,
201 type = "info",
202 header = red(" @@ "),
203 count = (count, maxcount,)
204 )
205 for missing_data in missing_extended:
206 self.Output.updateProgress(
207 "%s:" % (brown(unicode(missing_data)),),
208 importance = 0,
209 type = "info",
210 header = purple(" ## ")
211 )
212 for dependency in missing_extended[missing_data]:
213 self.Output.updateProgress(
214 "%s" % (darkred(dependency),),
215 importance = 0,
216 type = "info",
217 header = blue(" # ")
218 )
219 if ask:
220 rc_ask = self.Output.askQuestion(_("Do you want to add them?"))
221 if rc_ask == "No":
222 continue
223 rc_ask = self.Output.askQuestion(_("Selectively?"))
224 if rc_ask == "Yes":
225 newmissing = set()
226 new_blacklist = set()
227 for dependency in missing:
228 self.Output.updateProgress(
229 "[repo:%s|%s] %s" % (
230 darkgreen(repo),
231 brown(atom),
232 blue(dependency),
233 ),
234 importance = 0,
235 type = "info",
236 header = blue(" @@ ")
237 )
238 rc_ask = self.Output.askQuestion(_("Want to add?"))
239 if rc_ask == "Yes":
240 newmissing.add(dependency)
241 else:
242 rc_ask = self.Output.askQuestion(
243 _("Want to blacklist?"))
244 if rc_ask == "Yes":
245 new_blacklist.add(dependency)
246 if new_blacklist and (black_list_adder != None):
247 black_list_adder(new_blacklist, repo = repo)
248 missing = newmissing
249 if missing:
250 taint = True
251 dbconn.insertDependencies(idpackage, missing)
252 dbconn.commitChanges()
253 self.Output.updateProgress(
254 "[repo:%s] %s: %s" % (
255 darkgreen(repo),
256 darkgreen(atom),
257 blue(_("missing dependencies added")),
258 ),
259 importance = 1,
260 type = "info",
261 header = red(" @@ "),
262 count = (count, maxcount,)
263 )
264
265 return taint
266
267 - def libraries_test(self, dbconn, broken_symbols = False,
268 task_bombing_func = None):
269
270 self.Output.updateProgress(
271 blue(_("Libraries test")),
272 importance = 2,
273 type = "info",
274 header = red(" @@ ")
275 )
276
277 myroot = etpConst['systemroot'] + "/"
278 if not etpConst['systemroot']:
279 myroot = "/"
280
281
282 subprocess.call("ldconfig -r %s &> /dev/null" % (myroot,), shell = True)
283
284 ld_conf = etpConst['systemroot'] + "/etc/ld.so.conf"
285
286 if not os.path.isfile(ld_conf):
287 self.Output.updateProgress(
288 blue(_("Cannot find "))+red(ld_conf),
289 importance = 1,
290 type = "error",
291 header = red(" @@ ")
292 )
293 return {}, set(), -1
294
295 reverse_symlink_map = self.SystemSettings['system_rev_symlinks']
296 broken_syms_list = self.SystemSettings['broken_syms']
297 broken_libs_mask = self.SystemSettings['broken_libs_mask']
298
299 import re
300
301 broken_syms_list_regexp = []
302 for broken_sym in broken_syms_list:
303 reg_sym = re.compile(broken_sym)
304 broken_syms_list_regexp.append(reg_sym)
305
306 broken_libs_mask_regexp = []
307 for broken_lib in broken_libs_mask:
308 reg_lib = re.compile(broken_lib)
309 broken_libs_mask_regexp.append(reg_lib)
310
311 ldpaths = set(self.entropyTools.collect_linker_paths())
312 ldpaths |= self.entropyTools.collect_paths()
313
314
315 ldpaths.add("/usr/share")
316
317 ldpaths.add("/usr/libexec")
318
319
320 for real_dir in reverse_symlink_map.keys():
321 syms = reverse_symlink_map[real_dir]
322 for sym in syms:
323 if sym in ldpaths:
324 ldpaths.discard(real_dir)
325 self.Output.updateProgress(
326 "%s: %s, %s: %s" % (
327 brown(_("discarding directory")),
328 purple(real_dir),
329 brown(_("because it's symlinked on")),
330 purple(sym),
331 ),
332 importance = 0,
333 type = "info",
334 header = darkgreen(" @@ ")
335 )
336 break
337
338 executables = set()
339 total = len(ldpaths)
340 count = 0
341 sys_root_len = len(etpConst['systemroot'])
342 for ldpath in ldpaths:
343
344 if callable(task_bombing_func):
345 task_bombing_func()
346 count += 1
347 self.Output.updateProgress(
348 blue("Tree: ")+red(etpConst['systemroot'] + ldpath),
349 importance = 0,
350 type = "info",
351 count = (count,total),
352 back = True,
353 percent = True,
354 header = " "
355 )
356 ldpath = ldpath.encode(sys.getfilesystemencoding())
357 mywalk_iter = os.walk(etpConst['systemroot'] + ldpath)
358
359 def mywimf(dt):
360
361 currentdir, subdirs, files = dt
362
363 def mymf(item):
364 filepath = os.path.join(currentdir,item)
365 if not os.access(filepath, os.R_OK):
366 return 0
367 if not os.path.isfile(filepath):
368 return 0
369 if not self.entropyTools.is_elf_file(filepath):
370 return 0
371 return filepath[sys_root_len:]
372
373 return set([x for x in map(mymf, files) if type(x) != int])
374
375 for x in map(mywimf,mywalk_iter):
376 executables |= x
377
378 self.Output.updateProgress(
379 blue(_("Collecting broken executables")),
380 importance = 2,
381 type = "info",
382 header = red(" @@ ")
383 )
384 t = red(_("Attention")) + ": " + \
385 blue(_("don't worry about libraries that are shown here but not later."))
386 self.Output.updateProgress(
387 t,
388 importance = 1,
389 type = "info",
390 header = red(" @@ ")
391 )
392
393 plain_brokenexecs = set()
394 total = len(executables)
395 count = 0
396 scan_txt = blue("%s ..." % (_("Scanning libraries"),))
397 for executable in executables:
398
399
400 if callable(task_bombing_func):
401 task_bombing_func()
402
403 count += 1
404 if (count % 10 == 0) or (count == total) or (count == 1):
405 self.Output.updateProgress(
406 scan_txt,
407 importance = 0,
408 type = "info",
409 count = (count,total),
410 back = True,
411 percent = True,
412 header = " "
413 )
414
415 myelfs = self.entropyTools.read_elf_dynamic_libraries(
416 etpConst['systemroot'] + executable)
417
418 def mymf2(mylib):
419 return not self.resolve_dynamic_library(mylib, executable)
420
421 mylibs = set(filter(mymf2, myelfs))
422
423
424 if mylibs:
425
426 mylib_filter = set()
427 for mylib in mylibs:
428 mylib_matched = False
429 for reg_lib in broken_libs_mask_regexp:
430 if reg_lib.match(mylib):
431 mylib_matched = True
432 break
433 if mylib_matched:
434 mylib_filter.add(mylib)
435 mylibs -= mylib_filter
436
437
438 broken_sym_found = set()
439 if broken_symbols and not mylibs:
440
441 read_broken_syms = self.entropyTools.read_elf_broken_symbols(
442 etpConst['systemroot'] + executable)
443 my_broken_syms = set()
444 for read_broken_sym in read_broken_syms:
445 for reg_sym in broken_syms_list_regexp:
446 if reg_sym.match(read_broken_sym):
447 my_broken_syms.add(read_broken_sym)
448 break
449 broken_sym_found.update(my_broken_syms)
450
451 if not (mylibs or broken_sym_found):
452 continue
453
454 if mylibs:
455 alllibs = blue(' :: ').join(sorted(mylibs))
456 self.Output.updateProgress(
457 red(etpConst['systemroot']+executable)+" [ "+alllibs+" ]",
458 importance = 1,
459 type = "info",
460 percent = True,
461 count = (count,total),
462 header = " "
463 )
464 elif broken_sym_found:
465
466 allsyms = darkred(' :: ').join(
467 [brown(x) for x in list(broken_sym_found)])
468 if len(allsyms) > 50:
469 allsyms = brown(_('various broken symbols'))
470
471 self.Output.updateProgress(
472 red(etpConst['systemroot']+executable)+" { "+allsyms+" }",
473 importance = 1,
474 type = "info",
475 percent = True,
476 count = (count,total),
477 header = " "
478 )
479
480 plain_brokenexecs.add(executable)
481
482 del executables
483 packagesMatched = {}
484
485 if not etpSys['serverside']:
486
487
488
489
490
491
492 from entropy.client.interfaces import Client
493 client = Client()
494
495 self.Output.updateProgress(
496 blue(_("Matching broken libraries/executables")),
497 importance = 1,
498 type = "info",
499 header = red(" @@ ")
500 )
501 matched = set()
502 for brokenlib in plain_brokenexecs:
503 idpackages = dbconn.searchBelongs(brokenlib)
504
505 for idpackage in idpackages:
506
507 key, slot = dbconn.retrieveKeySlot(idpackage)
508 mymatch = client.atom_match(key, matchSlot = slot)
509 if mymatch[0] == -1:
510 matched.add(brokenlib)
511 continue
512
513 cmpstat = client.get_package_action(mymatch)
514 if cmpstat == 0:
515 continue
516 if not packagesMatched.has_key(brokenlib):
517 packagesMatched[brokenlib] = set()
518
519 packagesMatched[brokenlib].add(mymatch)
520 matched.add(brokenlib)
521
522 plain_brokenexecs -= matched
523
524 return packagesMatched, plain_brokenexecs, 0
525
526 - def content_test(self, mycontent):
527
528 def is_contained(needed, content):
529 for item in content:
530 if os.path.basename(item) == needed:
531 return True
532 return False
533
534 mylibs = {}
535 for myfile in mycontent:
536 myfile = myfile.encode('raw_unicode_escape')
537 if not os.access(myfile, os.R_OK):
538 continue
539 if not os.path.isfile(myfile):
540 continue
541 if not self.entropyTools.is_elf_file(myfile):
542 continue
543 mylibs[myfile] = self.entropyTools.read_elf_dynamic_libraries(
544 myfile)
545
546 broken_libs = {}
547 for mylib in mylibs:
548 for myneeded in mylibs[mylib]:
549
550 if is_contained(myneeded, mycontent):
551 continue
552 found = self.resolve_dynamic_library(myneeded, mylib)
553 if found:
554 continue
555 if not broken_libs.has_key(mylib):
556 broken_libs[mylib] = set()
557 broken_libs[mylib].add(myneeded)
558
559 return broken_libs
560
562
563 def do_resolve(mypaths):
564 found_path = None
565 for mypath in mypaths:
566 mypath = os.path.join(etpConst['systemroot']+mypath, library)
567 if not os.access(mypath, os.R_OK):
568 continue
569 if os.path.isdir(mypath):
570 continue
571 if not self.entropyTools.is_elf_file(mypath):
572 continue
573 found_path = mypath
574 break
575 return found_path
576
577 mypaths = self.entropyTools.collect_linker_paths()
578 found_path = do_resolve(mypaths)
579
580 if not found_path:
581 mypaths = self.entropyTools.read_elf_linker_paths(
582 requiring_executable)
583 found_path = do_resolve(mypaths)
584
585 return found_path
586
588
589 rdepends = {}
590 rdepends_plain = set()
591 neededs = dbconn.retrieveNeeded(idpackage, extended = True)
592 ldpaths = set(self.entropyTools.collect_linker_paths())
593 deps_content = set()
594 dependencies = self.get_deep_dependency_list(dbconn, idpackage,
595 atoms = True)
596 scope_cache = set()
597
598 def update_depscontent(mycontent, dbconn, ldpaths):
599 return set( \
600 [x for x in mycontent if os.path.dirname(x) in ldpaths \
601 and (dbconn.isNeededAvailable(os.path.basename(x)) > 0) ])
602
603 def is_in_content(myneeded, content):
604 for item in content:
605 item = os.path.basename(item)
606 if myneeded == item:
607 return True
608 return False
609
610 for dependency in dependencies:
611 match = dbconn.atomMatch(dependency)
612 if match[0] != -1:
613 mycontent = dbconn.retrieveContent(match[0])
614 deps_content |= update_depscontent(mycontent, dbconn, ldpaths)
615 key, slot = dbconn.retrieveKeySlot(match[0])
616 scope_cache.add((key, slot))
617
618 key, slot = dbconn.retrieveKeySlot(idpackage)
619 mycontent = dbconn.retrieveContent(idpackage)
620 deps_content |= update_depscontent(mycontent, dbconn, ldpaths)
621 scope_cache.add((key, slot))
622
623 idpackages_cache = set()
624 idpackage_map = {}
625 idpackage_map_reverse = {}
626 for needed, elfclass in neededs:
627 data_solved = dbconn.resolveNeeded(needed, elfclass = elfclass,
628 extended = True)
629 data_size = len(data_solved)
630 data_solved = set([x for x in data_solved if x[0] \
631 not in idpackages_cache])
632 if not data_solved or (data_size != len(data_solved)):
633 continue
634
635 if self_check:
636 if is_in_content(needed, mycontent):
637 continue
638
639 found = False
640 for data in data_solved:
641 if data[1] in deps_content:
642 found = True
643 break
644 if not found:
645 for data in data_solved:
646 r_idpackage = data[0]
647 key, slot = dbconn.retrieveKeySlot(r_idpackage)
648 if (key, slot) not in scope_cache:
649 if not dbconn.isSystemPackage(r_idpackage):
650 if not rdepends.has_key((needed, elfclass)):
651 rdepends[(needed, elfclass)] = set()
652 if not idpackage_map.has_key((needed, elfclass)):
653 idpackage_map[(needed, elfclass)] = set()
654 keyslot = "%s:%s" % (key, slot,)
655 obj = idpackage_map_reverse.setdefault(
656 keyslot, set())
657 obj.add((needed, elfclass,))
658 rdepends[(needed, elfclass)].add(keyslot)
659 idpackage_map[(needed, elfclass)].add(r_idpackage)
660 rdepends_plain.add(keyslot)
661 idpackages_cache.add(r_idpackage)
662
663
664
665 r_deplist = set()
666 for key in idpackage_map:
667 r_idpackages = idpackage_map.get(key)
668 for r_idpackage in r_idpackages:
669 r_deplist |= dbconn.retrieveDependencies(r_idpackage)
670
671 r_keyslots = set()
672 for r_dep in r_deplist:
673 m_idpackage, m_rc = dbconn.atomMatch(r_dep)
674 if m_rc != 0:
675 continue
676 keyslot = dbconn.retrieveKeySlotAggregated(m_idpackage)
677 if keyslot in rdepends_plain:
678 r_keyslots.add(keyslot)
679
680 rdepends_plain -= r_keyslots
681 for r_keyslot in r_keyslots:
682 keys = [x for x in idpackage_map_reverse.get(keyslot, set()) if \
683 x in rdepends]
684 for key in keys:
685 rdepends[key].discard(r_keyslot)
686 if not rdepends[key]:
687 del rdepends[key]
688
689 return rdepends, rdepends_plain
690
692
693 mybuffer = self.Lifo()
694 matchcache = set()
695 depcache = set()
696 mydeps = dbconn.retrieveDependencies(idpackage)
697 for mydep in mydeps:
698 mybuffer.push(mydep)
699 try:
700 mydep = mybuffer.pop()
701 except ValueError:
702 mydep = None
703
704 while mydep:
705
706 if mydep in depcache:
707 try:
708 mydep = mybuffer.pop()
709 except ValueError:
710 break
711 continue
712
713 my_idpackage, my_rc = dbconn.atomMatch(mydep)
714 if atoms:
715 matchcache.add(mydep)
716 else:
717 matchcache.add(my_idpackage)
718
719 if my_idpackage != -1:
720 owndeps = dbconn.retrieveDependencies(my_idpackage)
721 for owndep in owndeps:
722 mybuffer.push(owndep)
723
724 depcache.add(mydep)
725 try:
726 mydep = mybuffer.pop()
727 except ValueError:
728 break
729
730
731 matchcache.discard(-1)
732 return matchcache
733
735
736 from entropy.db import LocalRepository, dbapi2
737 fd, tmp_path = tempfile.mkstemp()
738 extract_path = self.entropyTools.extract_edb(pkg_path, tmp_path)
739 if extract_path is None:
740 os.remove(tmp_path)
741 os.close(fd)
742 return False
743 try:
744 dbc = LocalRepository(
745 readOnly = False,
746 dbFile = tmp_path,
747 clientDatabase = True,
748 dbname = 'qa_testing',
749 xcache = False,
750 indexing = False,
751 OutputInterface = self.Output,
752 skipChecks = False
753 )
754 except dbapi2.Error:
755 os.remove(tmp_path)
756 os.close(fd)
757 return False
758
759 valid = True
760 try:
761 dbc.validateDatabase()
762 except SystemDatabaseError:
763 valid = False
764
765 if valid:
766 try:
767 for idpackage in dbc.listAllIdpackages():
768 dbc.retrieveContent(idpackage, extended = True,
769 formatted = True, insert_formatted = True)
770 except dbapi2.Error:
771 valid = False
772
773 dbc.closeDB()
774 os.remove(tmp_path)
775 os.close(fd)
776
777 return valid
778
780 qa_methods = [self.__analyze_package_edb]
781 for method in qa_methods:
782 qa_rc = method(package_path)
783 if not qa_rc:
784 return False
785 return True
786
787
789
790 import entropy.tools as entropyTools
792 from entropy.misc import MultipartPostHandler
793 import urllib2
794 self.url = post_url
795 self.opener = urllib2.build_opener(MultipartPostHandler)
796 self.generated = False
797 self.params = {}
798
799 sys_settings = SystemSettings()
800 proxy_settings = sys_settings['system']['proxy']
801 mydict = {}
802 if proxy_settings['ftp']:
803 mydict['ftp'] = proxy_settings['ftp']
804 if proxy_settings['http']:
805 mydict['http'] = proxy_settings['http']
806 if mydict:
807 mydict['username'] = proxy_settings['username']
808 mydict['password'] = proxy_settings['password']
809 self.entropyTools.add_proxy_opener(urllib2, mydict)
810 else:
811
812 urllib2._opener = None
813
814 - def prepare(self, tb_text, name, email, report_data = "", description = ""):
815
816 import sys
817 from entropy.tools import getstatusoutput
818 self.params['arch'] = etpConst['currentarch']
819 self.params['stacktrace'] = tb_text
820 self.params['name'] = name
821 self.params['email'] = email
822 self.params['version'] = etpConst['entropyversion']
823 self.params['errordata'] = report_data
824 self.params['description'] = description
825 self.params['arguments'] = ' '.join(sys.argv)
826 self.params['uid'] = etpConst['uid']
827 self.params['system_version'] = "N/A"
828 if os.access(etpConst['systemreleasefile'], os.R_OK):
829 f_rel = open(etpConst['systemreleasefile'], "r")
830 self.params['system_version'] = f_rel.readline().strip()
831 f_rel.close()
832
833 self.params['processes'] = getstatusoutput('ps auxf')[1]
834 self.params['lspci'] = getstatusoutput('/usr/sbin/lspci')[1]
835 self.params['dmesg'] = getstatusoutput('dmesg')[1]
836 self.params['locale'] = getstatusoutput('locale -v')[1]
837
838 self.generated = True
839
840
842 if self.generated:
843 result = self.opener.open(self.url, self.params).read()
844 if result.strip() == "1":
845 return True
846 return False
847 else:
848 mytxt = _("Not prepared yet")
849 raise PermissionDenied("PermissionDenied: %s" % (mytxt,))
850