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 from __future__ import with_statement
23 import os
24 import sys
25 import subprocess
26 from entropy.const import etpConst
27 from entropy.output import blue, red
28 from entropy.i18n import _
29
31
32 import entropy.tools as entropyTools
33 - def __init__(self, SystemManagerExecutorInstance, *args, **kwargs):
34
35 try:
36 import cPickle as pickle
37 except ImportError:
38 import pickle
39 self.pickle = pickle
40
41 self.SystemManagerExecutor = SystemManagerExecutorInstance
42 self.args = args
43 self.kwargs = kwargs
44 self.available_commands = {
45 'sync_spm': {
46 'func': self.sync_portage,
47 'args': 1,
48 },
49 'compile_atoms': {
50 'func': self.compile_atoms,
51 'args': 2,
52 },
53 'spm_remove_atoms': {
54 'func': self.spm_remove_atoms,
55 'args': 2,
56 },
57 'get_spm_categories_updates': {
58 'func': self.get_spm_categories_updates,
59 'args': 2,
60 },
61 'get_spm_categories_installed': {
62 'func': self.get_spm_categories_installed,
63 'args': 2,
64 },
65 'enable_uses_for_atoms': {
66 'func': self.enable_uses_for_atoms,
67 'args': 3,
68 },
69 'disable_uses_for_atoms': {
70 'func': self.disable_uses_for_atoms,
71 'args': 3,
72 },
73 'get_spm_atoms_info': {
74 'func': self.get_spm_atoms_info,
75 'args': 2,
76 },
77 'run_spm_info': {
78 'func': self.run_spm_info,
79 'args': 1,
80 },
81 'run_custom_shell_command': {
82 'func': self.run_custom_shell_command,
83 'args': 1,
84 },
85 'get_spm_glsa_data': {
86 'func': self.get_spm_glsa_data,
87 'args': 1,
88 },
89 'move_entropy_packages_to_repository': {
90 'func': self.move_entropy_packages_to_repository,
91 'args': 5,
92 },
93 'scan_entropy_packages_database_changes': {
94 'func': self.scan_entropy_packages_database_changes,
95 'args': 1,
96 },
97 'run_entropy_database_updates': {
98 'func': self.run_entropy_database_updates,
99 'args': 4,
100 },
101 'run_entropy_dependency_test': {
102 'func': self.run_entropy_dependency_test,
103 'args': 1,
104 },
105 'run_entropy_library_test': {
106 'func': self.run_entropy_library_test,
107 'args': 1,
108 },
109 'run_entropy_treeupdates': {
110 'func': self.run_entropy_treeupdates,
111 'args': 2,
112 },
113 'scan_entropy_mirror_updates': {
114 'func': self.scan_entropy_mirror_updates,
115 'args': 2,
116 },
117 'run_entropy_mirror_updates': {
118 'func': self.run_entropy_mirror_updates,
119 'args': 2,
120 },
121 'run_entropy_checksum_test': {
122 'func': self.run_entropy_checksum_test,
123 'args': 3,
124 },
125 'get_notice_board': {
126 'func': self.get_notice_board,
127 'args': 2,
128 },
129 'remove_notice_board_entries': {
130 'func': self.remove_notice_board_entries,
131 'args': 3,
132 },
133 'add_notice_board_entry': {
134 'func': self.add_notice_board_entry,
135 'args': 5,
136 },
137 }
138
140 with self.SystemManagerExecutor.SystemInterface.QueueLock:
141 self.SystemManagerExecutor.SystemInterface.load_queue()
142 live_item, key = self.SystemManagerExecutor.SystemInterface._get_item_by_queue_id(queue_id)
143 if isinstance(live_item,dict):
144 live_item['processing_pid'] = process_pid
145
146 self.SystemManagerExecutor.SystemInterface.store_queue()
147
149
150 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
151 if queue_data == None:
152 return False,'no item in queue'
153
154 stdout_err = open(queue_data['stdout'],"a+")
155
156 cmd = ["emerge", "--sync"]
157 try:
158 p = subprocess.Popen(cmd, stdout = stdout_err, stderr = stdout_err, stdin = self._get_stdin(queue_id))
159 self._set_processing_pid(queue_id, p.pid)
160 rc = p.wait()
161 finally:
162 stdout_err.write("\n### Done ###\n")
163 stdout_err.flush()
164 stdout_err.close()
165 return True,rc
166
167 - def compile_atoms( self,
168 queue_id, atoms,
169 pretend = False, oneshot = False,
170 verbose = True, nocolor = True,
171 fetchonly = False, buildonly = False,
172 nodeps = False, custom_use = '', ldflags = '', cflags = ''
173 ):
174
175 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
176 if queue_data == None:
177 return False,'no item in queue'
178
179 stdout_err = open(queue_data['stdout'],"a+")
180
181 cmd = [etpConst['spm']['env_update_cmd'],"&&"]
182 cmd += etpConst['spm']['source_profile']+["&&"]
183 if custom_use:
184 cmd += ['export USE="']+custom_use.strip().split()+['"','&&']
185 if ldflags:
186 cmd += ['export LDFLAGS="']+custom_use.strip().split()+['"','&&']
187 if cflags:
188 cmd += ['export CFLAGS="']+custom_use.strip().split()+['"','&&']
189 cmd += [etpConst['spm']['exec']]+atoms
190 if pretend:
191 cmd.append(etpConst['spm']['pretend_cmd'])
192 if verbose:
193 cmd.append(etpConst['spm']['verbose_cmd'])
194 if oneshot:
195 cmd.append(etpConst['spm']['oneshot_cmd'])
196 if nocolor:
197 cmd.append(etpConst['spm']['nocolor_cmd'])
198 if fetchonly:
199 cmd.append(etpConst['spm']['fetchonly_cmd'])
200 if buildonly:
201 cmd.append(etpConst['spm']['buildonly_cmd'])
202 if nodeps:
203 cmd.append(etpConst['spm']['nodeps_cmd'])
204
205 stdout_err.write("Preparing to spawn parameter: '%s'. Good luck mate!\n" % (' '.join(cmd),))
206 stdout_err.flush()
207
208 try:
209 p = subprocess.Popen(' '.join(cmd), stdout = stdout_err, stderr = stdout_err, stdin = self._get_stdin(queue_id), shell = True)
210 self._set_processing_pid(queue_id, p.pid)
211 rc = p.wait()
212 finally:
213 stdout_err.write("\n### Done ###\n")
214 stdout_err.flush()
215 stdout_err.close()
216 return True,rc
217
218 - def spm_remove_atoms(self, queue_id, atoms, pretend = True, verbose = True, nocolor = True):
219
220 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
221 if queue_data == None:
222 return False,'no item in queue'
223
224 stdout_err = open(queue_data['stdout'],"a+")
225
226 cmd = [etpConst['spm']['env_update_cmd'],"&&"]
227 cmd += etpConst['spm']['source_profile']+["&&"]
228 cmd += [etpConst['spm']['exec'],etpConst['spm']['remove_cmd']]+atoms
229 if pretend:
230 cmd.append(etpConst['spm']['pretend_cmd'])
231 if verbose:
232 cmd.append(etpConst['spm']['verbose_cmd'])
233 if nocolor:
234 cmd.append(etpConst['spm']['nocolor_cmd'])
235
236 stdout_err.write("Preparing to spawn parameter: '%s'. Good luck mate!\n" % (' '.join(cmd),))
237 stdout_err.flush()
238
239 try:
240 p = subprocess.Popen(' '.join(cmd), stdout = stdout_err, stderr = stdout_err, stdin = self._get_stdin(queue_id), shell = True)
241 self._set_processing_pid(queue_id, p.pid)
242 rc = p.wait()
243 finally:
244 stdout_err.write("\n### Done ###\n")
245 stdout_err.flush()
246 stdout_err.close()
247 return True,rc
248
250
251 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
252 if queue_data == None:
253 return False,'no item in queue'
254
255 use_data = {}
256 for atom in atoms:
257 try:
258 status = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.enable_package_useflags(atom, useflags)
259 except:
260 continue
261 if status:
262 use_data[atom] = {}
263 matched_atom = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_best_atom(atom)
264 use_data[atom] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_package_useflags(matched_atom)
265
266 return True, use_data
267
269
270 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
271 if queue_data == None:
272 return False,'no item in queue'
273
274 use_data = {}
275 for atom in atoms:
276 try:
277 status = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.disable_package_useflags(atom, useflags)
278 except:
279 continue
280 if status:
281 use_data[atom] = {}
282 matched_atom = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_best_atom(atom)
283 use_data[atom] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_package_useflags(matched_atom)
284
285 return True, use_data
286
288
289 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
290 if queue_data == None:
291 return False,'no item in queue'
292
293 atoms_data = {}
294 for atom in atoms:
295
296 try:
297 key = self.entropyTools.dep_getkey(atom)
298 category = key.split("/")[0]
299 except:
300 continue
301 matched_atom = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_best_atom(atom)
302 if not matched_atom: continue
303
304 if not atoms_data.has_key(category):
305 atoms_data[category] = {}
306
307 atoms_data[category][matched_atom] = self._get_spm_pkginfo(matched_atom)
308
309 return True, atoms_data
310
312
313 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
314 if queue_data == None:
315 return False,'no item in queue'
316
317 packages = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_available_packages(categories)
318 package_data = {}
319 for package in packages:
320 try:
321 key = self.entropyTools.dep_getkey(package)
322 category = key.split("/")[0]
323 except:
324 continue
325 if not package_data.has_key(category):
326 package_data[category] = {}
327 package_data[category][package] = self._get_spm_pkginfo(package)
328
329 return True, package_data
330
332
333 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
334 if queue_data == None:
335 return False,'no item in queue'
336
337 packages, pkg_len = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_installed_packages(categories = categories)
338 package_data = {}
339 for package in packages:
340 try:
341 key = self.entropyTools.dep_getkey(package)
342 category = key.split("/")[0]
343 except:
344 continue
345 if not package_data.has_key(category):
346 package_data[category] = {}
347 package_data[category][package] = self._get_spm_pkginfo(package, from_installed = True)
348
349 return True, package_data
350
352
353 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
354 if queue_data == None:
355 return False,'no item in queue'
356
357 stdout_err = open(queue_data['stdout'],"a+")
358
359 cmd = [etpConst['spm']['exec'],etpConst['spm']['info_cmd']]
360
361 stdout_err.write("Preparing to spawn parameter: '%s'. Good luck mate!\n" % (' '.join(cmd),))
362 stdout_err.flush()
363
364 try:
365 p = subprocess.Popen(cmd, stdout = stdout_err, stderr = stdout_err, stdin = self._get_stdin(queue_id))
366 self._set_processing_pid(queue_id, p.pid)
367 rc = p.wait()
368 finally:
369 stdout_err.write("\n### Done ###\n")
370 stdout_err.flush()
371 stdout_err.close()
372 return True,rc
373
375
376 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
377 if queue_data == None:
378 return False,'no item in queue'
379
380 stdout_err = open(queue_data['stdout'],"a+")
381
382 cmd = [etpConst['spm']['env_update_cmd'],"&&"]
383 cmd += etpConst['spm']['source_profile']+[";"]
384 cmd += command.split()
385
386 cmd = ' '.join(cmd)
387 stdout_err.write("Preparing to spawn parameter: '%s'. Good luck mate!\n" % (cmd,))
388 stdout_err.flush()
389
390 try:
391 p = subprocess.Popen(cmd, stdout = stdout_err, stderr = stdout_err, stdin = self._get_stdin(queue_id), shell = True)
392 self._set_processing_pid(queue_id, p.pid)
393 rc = p.wait()
394 finally:
395 stdout_err.write("\n### Done ###\n")
396 stdout_err.flush()
397 stdout_err.close()
398 return True,rc
399
401
402 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
403 if queue_data == None:
404 return False,'no item in queue'
405
406
407 matches = []
408 for idpackage in idpackages:
409 matches.append((idpackage,from_repo,))
410
411 stdout_err = open(queue_data['stdout'],"a+")
412
413 def myfunc():
414 sys.stdout = stdout_err
415 sys.stderr = stdout_err
416 mystdin = self._get_stdin(queue_id)
417 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
418 try:
419 switched = self.SystemManagerExecutor.SystemInterface.Entropy.move_packages(
420 matches, to_repo,
421 from_repo = from_repo,
422 ask = False,
423 do_copy = do_copy
424 )
425 return switched
426 finally:
427 sys.stdout.write("\n### Done ###\n")
428 sys.stdout.flush()
429 sys.stdout = sys.__stdout__
430 sys.stderr = sys.__stderr__
431 sys.stdin = sys.__stdin__
432
433 def write_pid(pid):
434 self._set_processing_pid(queue_id, pid)
435
436 switched = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
437 stdout_err.flush()
438 stdout_err.close()
439
440 rc = 1
441 if len(switched) == len(idpackages):
442 rc = 0
443 return True,rc
444
446
447 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
448 if queue_data == None:
449 return False,'no item in queue'
450
451 stdout_err = open(queue_data['stdout'],"a+")
452 Entropy = self.SystemManagerExecutor.SystemInterface.Entropy
453
454 def myfunc():
455 sys.stdout = stdout_err
456 sys.stderr = stdout_err
457 mystdin = self._get_stdin(queue_id)
458 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
459 try:
460
461 for repoid in Entropy.get_available_repositories():
462 self.run_entropy_treeupdates(queue_id, repoid)
463
464 stdout_err.write("\n"+_("Calculating updates...").encode('utf-8')+"\n")
465 stdout_err.flush()
466
467 to_add, to_remove, to_inject = Entropy.scan_package_changes()
468 mydict = { 'add': to_add, 'remove': to_remove, 'inject': to_inject }
469
470
471 mydict['add_data'] = {}
472 for portage_atom, portage_counter in to_add:
473 mydict['add_data'][(portage_atom, portage_counter,)] = self._get_spm_pkginfo(portage_atom,from_installed = True)
474
475 mydict['remove_data'] = {}
476 for idpackage, repoid in to_remove:
477 dbconn = Entropy.open_server_repository(repo = repoid, just_reading = True, warnings = False, do_cache = False)
478 mydict['remove_data'][(idpackage, repoid,)] = self._get_entropy_pkginfo(dbconn, idpackage, repoid)
479 dbconn.closeDB()
480
481 mydict['inject_data'] = {}
482 for idpackage, repoid in to_inject:
483 dbconn = Entropy.open_server_repository(repo = repoid, just_reading = True, warnings = False, do_cache = False)
484 mydict['inject_data'][(idpackage, repoid,)] = self._get_entropy_pkginfo(dbconn, idpackage, repoid)
485 dbconn.closeDB()
486
487 return True,mydict
488
489 finally:
490 sys.stdout.write("\n### Done ###\n")
491 sys.stdout.flush()
492 sys.stdout = sys.__stdout__
493 sys.stderr = sys.__stderr__
494 sys.stdin = sys.__stdin__
495
496 def write_pid(pid):
497 self._set_processing_pid(queue_id, pid)
498
499 data = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
500 stdout_err.flush()
501 stdout_err.close()
502 return data
503
505
506 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
507 if queue_data == None:
508 return False,'no item in queue'
509
510 stdout_err = open(queue_data['stdout'],"a+")
511 Entropy = self.SystemManagerExecutor.SystemInterface.Entropy
512
513 def myfunc():
514 sys.stdout = stdout_err
515 sys.stderr = stdout_err
516 mystdin = self._get_stdin(queue_id)
517 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
518 try:
519
520 atoms_removed = []
521 matches_injected = set()
522
523 if to_inject: Entropy.updateProgress(_("Running package injection"))
524
525
526 for idpackage, repoid in to_inject:
527 matches_injected.add((idpackage,repoid,))
528 Entropy.transform_package_into_injected(idpackage, repo = repoid)
529
530 if to_remove: Entropy.updateProgress(_("Running package removal"))
531
532
533 remdata = {}
534 for idpackage,repoid in to_remove:
535 dbconn = Entropy.open_server_repository(repo = repoid, just_reading = True, warnings = False, do_cache = False)
536 atoms_removed.append(dbconn.retrieveAtom(idpackage))
537 dbconn.closeDB()
538 if not remdata.has_key(repoid):
539 remdata[repoid] = set()
540 remdata[repoid].add(idpackage)
541 for repoid in remdata:
542 Entropy.remove_packages(remdata[repoid], repo = repoid)
543
544 mydict = {
545 'added_data': {},
546 'remove_data': atoms_removed,
547 'inject_data': {}
548 }
549
550 if to_add:
551 problems = Entropy.check_config_file_updates()
552 if problems:
553 return False,mydict
554 Entropy.updateProgress(_("Running package quickpkg"))
555
556
557 for repoid in to_add:
558 store_dir = Entropy.get_local_store_directory(repo = repoid)
559 for atom in to_add[repoid]:
560 Entropy.quickpkg(atom,store_dir)
561
562
563 avail_repos = Entropy.get_available_repositories()
564 if etpConst['clientserverrepoid'] in avail_repos:
565 avail_repos.pop(etpConst['clientserverrepoid'])
566 matches_added = set()
567 for repoid in avail_repos:
568 store_dir = Entropy.get_local_store_directory(repo = repoid)
569 package_files = os.listdir(store_dir)
570 if not package_files: continue
571 package_files = [(os.path.join(store_dir,x),False) for x in package_files]
572
573 Entropy.updateProgress( "[%s|%s] %s" % (
574 repoid,
575 Entropy.SystemSettings['repositories']['branch'],
576 _("Adding packages"),
577 )
578 )
579 for package_file, inject in package_files:
580 Entropy.updateProgress(" %s" % (package_file,))
581
582 idpackages = Entropy.add_packages_to_repository(package_files, ask = False, repo = repoid)
583 matches_added |= set([(x,repoid,) for x in idpackages])
584
585
586 Entropy.dependencies_test()
587
588 for idpackage, repoid in matches_added:
589 dbconn = Entropy.open_server_repository(repo = repoid, just_reading = True, warnings = False, do_cache = False)
590 mydict['added_data'][(idpackage, repoid,)] = self._get_entropy_pkginfo(dbconn, idpackage, repoid)
591 dbconn.closeDB()
592 for idpackage, repoid in matches_injected:
593 dbconn = Entropy.open_server_repository(repo = repoid, just_reading = True, warnings = False, do_cache = False)
594 mydict['inject_data'][(idpackage, repoid,)] = self._get_entropy_pkginfo(dbconn, idpackage, repoid)
595 dbconn.closeDB()
596 return True, mydict
597
598 finally:
599 sys.stdout.write("\n### Done ###\n")
600 sys.stdout.flush()
601 sys.stdout = sys.__stdout__
602 sys.stderr = sys.__stderr__
603 sys.stdin = sys.__stdin__
604
605 def write_pid(pid):
606 self._set_processing_pid(queue_id, pid)
607
608 data = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
609 stdout_err.flush()
610 stdout_err.close()
611 return data
612
614
615 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
616 if queue_data == None:
617 return False,'no item in queue'
618
619 stdout_err = open(queue_data['stdout'],"a+")
620
621 def myfunc():
622 sys.stdout = stdout_err
623 sys.stderr = stdout_err
624 mystdin = self._get_stdin(queue_id)
625 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
626 try:
627 deps_not_matched = self.SystemManagerExecutor.SystemInterface.Entropy.dependencies_test()
628 return True,deps_not_matched
629 except Exception, e:
630 self.entropyTools.print_traceback()
631 return False,unicode(e)
632 finally:
633 sys.stdout.write("\n### Done ###\n")
634 sys.stdout.flush()
635 sys.stdout = sys.__stdout__
636 sys.stderr = sys.__stderr__
637 sys.stdin = sys.__stdin__
638
639 def write_pid(pid):
640 self._set_processing_pid(queue_id, pid)
641
642 data = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
643 stdout_err.flush()
644 stdout_err.close()
645 return data
646
648
649 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
650 if queue_data == None:
651 return False,'no item in queue'
652
653 stdout_err = open(queue_data['stdout'],"a+")
654
655 def myfunc():
656 sys.stdout = stdout_err
657 sys.stderr = stdout_err
658 mystdin = self._get_stdin(queue_id)
659 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
660 try:
661 return self.SystemManagerExecutor.SystemInterface.Entropy.test_shared_objects()
662 except Exception, e:
663 self.entropyTools.print_traceback()
664 return False,unicode(e)
665 finally:
666 sys.stdout.write("\n### Done ###\n")
667 sys.stdout.flush()
668 sys.stdout = sys.__stdout__
669 sys.stderr = sys.__stderr__
670 sys.stdin = sys.__stdin__
671
672 def write_pid(pid):
673 self._set_processing_pid(queue_id, pid)
674
675 status, result = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
676 stdout_err.flush()
677 stdout_err.close()
678
679 mystatus = False
680 if status == 0: mystatus = True
681 if not result: result = set()
682 return mystatus,result
683
685
686 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
687 if queue_data == None:
688 return False,'no item in queue'
689
690 stdout_err = open(queue_data['stdout'],"a+")
691
692 def myfunc():
693 sys.stdout = stdout_err
694 sys.stderr = stdout_err
695 mystdin = self._get_stdin(queue_id)
696 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
697 try:
698 if mode == "local":
699 data = self.SystemManagerExecutor.SystemInterface.Entropy.verify_local_packages([], ask = False, repo = repoid)
700 else:
701 data = self.SystemManagerExecutor.SystemInterface.Entropy.verify_remote_packages([], ask = False, repo = repoid)
702 return True, data
703 except Exception, e:
704 self.entropyTools.print_traceback()
705 return False,unicode(e)
706 finally:
707 sys.stdout.write("\n### Done ###\n")
708 sys.stdout.flush()
709 sys.stdout = sys.__stdout__
710 sys.stderr = sys.__stderr__
711 sys.stdin = sys.__stdin__
712
713 def write_pid(pid):
714 self._set_processing_pid(queue_id, pid)
715
716 mydata = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
717 stdout_err.flush()
718 stdout_err.close()
719 return mydata
720
722
723 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
724 if queue_data == None:
725 return False,'no item in queue'
726
727 stdout_err = open(queue_data['stdout'],"a+")
728
729 def myfunc():
730 sys.stdout = stdout_err
731 sys.stderr = stdout_err
732 mystdin = self._get_stdin(queue_id)
733 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
734 try:
735 sys.stdout.write(_("Opening database to let it run treeupdates. If you won't see anything below, it's just fine.").encode('utf-8')+"\n")
736 dbconn = self.SystemManagerExecutor.SystemInterface.Entropy.open_server_repository(
737 repo = repoid, do_cache = False,
738 read_only = True
739 )
740 dbconn.closeDB()
741 except Exception, e:
742 self.entropyTools.print_traceback()
743 return False,unicode(e)
744 finally:
745 sys.stdout.write("\n### Done ###\n")
746 sys.stdout.flush()
747 sys.stdout = sys.__stdout__
748 sys.stderr = sys.__stderr__
749 sys.stdin = sys.__stdin__
750
751 def write_pid(pid):
752 self._set_processing_pid(queue_id, pid)
753
754 self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
755 stdout_err.flush()
756 stdout_err.close()
757 return True, 0
758
760
761 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
762 if queue_data == None:
763 return False,'no item in queue'
764
765 stdout_err = open(queue_data['stdout'],"a+")
766 import socket
767 Entropy = self.SystemManagerExecutor.SystemInterface.Entropy
768
769 def myfunc():
770 sys.stdout = stdout_err
771 sys.stderr = stdout_err
772 mystdin = self._get_stdin(queue_id)
773 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
774 try:
775
776 sys.stdout.write(_("Scanning").encode('utf-8')+"\n")
777 repo_data = {}
778 for repoid in repositories:
779
780 repo_data[repoid] = {}
781
782 for uri in Entropy.get_remote_mirrors(repoid):
783
784 crippled_uri = self.entropyTools.extract_ftp_host_from_uri(uri)
785
786 repo_data[repoid][crippled_uri] = {}
787 repo_data[repoid][crippled_uri]['packages'] = {}
788
789 try:
790 upload_queue, download_queue, removal_queue, \
791 fine_queue, remote_packages_data = Entropy.MirrorsService.calculate_packages_to_sync(
792 uri, Entropy.SystemSettings['repositories']['branch'],
793 repoid)
794 except socket.error:
795 self.entropyTools.print_traceback(f = stdout_err)
796 stdout_err.write("\n"+_("Socket error, continuing...").encode('utf-8')+"\n")
797 continue
798
799 if (upload_queue or download_queue or removal_queue):
800 upload, download, removal, copy, metainfo = Entropy.MirrorsService.expand_queues(
801 upload_queue,
802 download_queue,
803 removal_queue,
804 remote_packages_data,
805 Entropy.SystemSettings['repositories']['branch'],
806 repoid
807 )
808 if len(upload)+len(download)+len(removal)+len(copy):
809 repo_data[repoid][crippled_uri]['packages'] = {
810 'upload': upload,
811 'download': download,
812 'removal': removal,
813 'copy': copy,
814 }
815
816
817 current_revision = Entropy.get_local_database_revision(repoid)
818 remote_revision = Entropy.get_remote_database_revision(repoid)
819 download_latest, upload_queue = Entropy.MirrorsService.calculate_database_sync_queues(repoid)
820
821 repo_data[repoid][crippled_uri]['database'] = {
822 'current_revision': current_revision,
823 'remote_revision': remote_revision,
824 'download_latest': download_latest,
825 'upload_queue': [(self.entropyTools.extract_ftp_host_from_uri(x[0]),x[1],) for x in upload_queue]
826 }
827
828 return True, repo_data
829
830 except Exception, e:
831 self.entropyTools.print_traceback()
832 return False,unicode(e)
833 finally:
834 sys.stdout.write("\n### Done ###\n")
835 sys.stdout.flush()
836 sys.stdout = sys.__stdout__
837 sys.stderr = sys.__stderr__
838 sys.stdin = sys.__stdin__
839
840 def write_pid(pid):
841 self._set_processing_pid(queue_id, pid)
842
843 data = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
844 stdout_err.flush()
845 stdout_err.close()
846 return data
847
849
850 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
851 if queue_data == None:
852 return False,'no item in queue'
853
854 stdout_err = open(queue_data['stdout'],"a+")
855 Entropy = self.SystemManagerExecutor.SystemInterface.Entropy
856
857 def sync_remote_databases(repoid, pretend):
858
859 rdb_status = Entropy.MirrorsService.get_remote_databases_status()
860 Entropy.updateProgress(
861 "%s:" % (_("Remote Entropy Database Repository Status"),),
862 header = " * "
863 )
864 for myuri, myrev in rdb_status:
865 Entropy.updateProgress("\t %s:\t %s" % (_("Host"),self.entropyTools.extract_ftp_host_from_uri(myuri),))
866 Entropy.updateProgress("\t * %s: %s" % (_("Database revision"),myrev,))
867 local_revision = Entropy.get_local_database_revision(repoid)
868 Entropy.updateProgress("\t * %s: %s" % (_("Database local revision currently at"),local_revision,))
869 if pretend:
870 return 0,set(),set()
871
872 errors, fine_uris, broken_uris = Entropy.MirrorsService.sync_databases(no_upload = False)
873 remote_status = Entropy.MirrorsService.get_remote_databases_status(repoid)
874 Entropy.updateProgress(" * %s: " % (_("Remote Entropy Database Repository Status"),))
875 for myuri, myrev in remote_status:
876 Entropy.updateProgress("\t %s:\t%s" % (_("Host"),Entropy.entropyTools.extract_ftp_host_from_uri(myuri),))
877 Entropy.updateProgress("\t * %s: %s" % (_("Database revision"),myrev,) )
878
879 return errors, fine_uris, broken_uris
880
881
882 def myfunc():
883 sys.stdout = stdout_err
884 sys.stderr = stdout_err
885 mystdin = self._get_stdin(queue_id)
886 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
887 try:
888
889 repo_data = {}
890 sys_settings_srv_plugin_id = \
891 etpConst['system_settings_plugins_ids']['server_plugin']
892 for repoid in repository_data:
893
894
895 if repoid == etpConst['clientserverrepoid']: continue
896
897 successfull_mirrors = set()
898 mirrors_errors = False
899 mirrors_tainted = False
900 broken_mirrors = set()
901 check_data = []
902
903 repo_data[repoid] = {
904 'mirrors_tainted': mirrors_tainted,
905 'mirrors_errors': mirrors_errors,
906 'successfull_mirrors': successfull_mirrors.copy(),
907 'broken_mirrors': broken_mirrors.copy(),
908 'check_data': check_data,
909 'db_errors': 0,
910 'db_fine': set(),
911 'db_broken': set(),
912 }
913
914 if repository_data[repoid]['pkg']:
915
916 mirrors_tainted, mirrors_errors, \
917 successfull_mirrors, broken_mirrors, \
918 check_data = Entropy.MirrorsService.sync_packages(
919 ask = False, pretend = repository_data[repoid]['pretend'],
920 packages_check = repository_data[repoid]['pkg_check'], repo = repoid)
921
922 repo_data[repoid]['mirrors_tainted'] = mirrors_tainted
923 repo_data[repoid]['mirrors_errors'] = mirrors_errors
924 repo_data[repoid]['successfull_mirrors'] = successfull_mirrors
925 repo_data[repoid]['broken_mirrors'] = broken_mirrors
926 repo_data[repoid]['check_data'] = check_data
927
928 if (not successfull_mirrors) and (not repository_data[repoid]['pretend']): continue
929
930 if (not mirrors_errors) and repository_data[repoid]['db']:
931
932 if mirrors_tainted and Entropy.SystemSettings[sys_settings_srv_plugin_id]['server']['rss']['enabled']:
933 commit_msg = repository_data[repoid]['commit_msg']
934 if not commit_msg: commit_msg = "Autodriven update"
935 Entropy.rssMessages['commitmessage'] = commit_msg
936
937 errors, fine, broken = sync_remote_databases(repoid, repository_data[repoid]['pretend'])
938 repo_data[repoid]['db_errors'] = errors
939 repo_data[repoid]['db_fine'] = fine.copy()
940 repo_data[repoid]['db_broken'] = broken.copy()
941 if errors: continue
942 Entropy.MirrorsService.lock_mirrors(lock = False, repo = repoid)
943 Entropy.MirrorsService.tidy_mirrors(
944 repo = repoid, ask = False,
945 pretend = repository_data[repoid]['pretend']
946 )
947
948 return True, repo_data
949
950 except Exception, e:
951 self.entropyTools.print_traceback()
952 return False,unicode(e)
953 finally:
954 sys.stdout.write("\n### Done ###\n")
955 sys.stdout.flush()
956 sys.stdout = sys.__stdout__
957 sys.stderr = sys.__stderr__
958 sys.stdin = sys.__stdin__
959
960 def write_pid(pid):
961 self._set_processing_pid(queue_id, pid)
962
963 data = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
964 stdout_err.flush()
965 stdout_err.close()
966 return data
967
969
970 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
971 if queue_data == None:
972 return False,'no item in queue'
973
974 data = {}
975 glsa_ids = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.list_glsa_packages(list_type)
976 if not glsa_ids: return False,data
977 for myid in glsa_ids:
978 data[myid] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_glsa_id_information(myid)
979 return True,data
980
982
983 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
984 if queue_data == None:
985 return False,'no item in queue'
986
987 stdout_err = open(queue_data['stdout'],"a+")
988
989 def myfunc():
990 sys.stdout = stdout_err
991 sys.stderr = stdout_err
992 mystdin = self._get_stdin(queue_id)
993 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
994 try:
995 data = self.SystemManagerExecutor.SystemInterface.Entropy.MirrorsService.read_notice_board(repo = repoid)
996 if data == None:
997 return False,None
998 return True,data
999 except Exception, e:
1000 self.entropyTools.print_traceback()
1001 return False,unicode(e)
1002 finally:
1003 sys.stdout.write("\n### Done ###\n")
1004 sys.stdout.flush()
1005 sys.stdout = sys.__stdout__
1006 sys.stderr = sys.__stderr__
1007 sys.stdin = sys.__stdin__
1008
1009 def write_pid(pid):
1010 self._set_processing_pid(queue_id, pid)
1011
1012 mydata = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
1013 stdout_err.flush()
1014 stdout_err.close()
1015 return mydata
1016
1018
1019 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
1020 if queue_data == None:
1021 return False,'no item in queue'
1022
1023 stdout_err = open(queue_data['stdout'],"a+")
1024
1025 def myfunc():
1026 sys.stdout = stdout_err
1027 sys.stderr = stdout_err
1028 mystdin = self._get_stdin(queue_id)
1029 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
1030 try:
1031 for entry_id in entry_ids:
1032 data = self.SystemManagerExecutor.SystemInterface.Entropy.MirrorsService.remove_from_notice_board(entry_id, repo = repoid)
1033 self.SystemManagerExecutor.SystemInterface.Entropy.MirrorsService.upload_notice_board(repo = repoid)
1034 return True,data
1035 except Exception, e:
1036 self.entropyTools.print_traceback()
1037 return False,unicode(e)
1038 finally:
1039 sys.stdout.write("\n### Done ###\n")
1040 sys.stdout.flush()
1041 sys.stdout = sys.__stdout__
1042 sys.stderr = sys.__stderr__
1043 sys.stdin = sys.__stdin__
1044
1045 def write_pid(pid):
1046 self._set_processing_pid(queue_id, pid)
1047
1048 mydata = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
1049 stdout_err.flush()
1050 stdout_err.close()
1051 return mydata
1052
1053 - def add_notice_board_entry(self, queue_id, repoid, title, notice_text, link):
1054
1055 queue_data, key = self.SystemManagerExecutor.SystemInterface.get_item_by_queue_id(queue_id, copy = True)
1056 if queue_data == None:
1057 return False,'no item in queue'
1058
1059 stdout_err = open(queue_data['stdout'],"a+")
1060
1061 def myfunc():
1062 sys.stdout = stdout_err
1063 sys.stderr = stdout_err
1064 mystdin = self._get_stdin(queue_id)
1065 if mystdin: sys.stdin = os.fdopen(mystdin, 'rb')
1066 try:
1067 data = self.SystemManagerExecutor.SystemInterface.Entropy.MirrorsService.update_notice_board(title, notice_text, link = link, repo = repoid)
1068 return True,data
1069 except Exception, e:
1070 self.entropyTools.print_traceback()
1071 return False,unicode(e)
1072 finally:
1073 sys.stdout.write("\n### Done ###\n")
1074 sys.stdout.flush()
1075 sys.stdout = sys.__stdout__
1076 sys.stderr = sys.__stderr__
1077 sys.stdin = sys.__stdin__
1078
1079 def write_pid(pid):
1080 self._set_processing_pid(queue_id, pid)
1081
1082 mydata = self.entropyTools.spawn_function(myfunc, write_pid_func = write_pid)
1083 stdout_err.flush()
1084 stdout_err.close()
1085 return mydata
1086
1088 mystdin = None
1089 std_data = self.SystemManagerExecutor.SystemInterface.ManagerQueueStdInOut.get(queue_id)
1090 if std_data != None: mystdin = std_data[0]
1091 return mystdin
1092
1094
1095 f.flush()
1096 back = mykwargs.get("back")
1097 count = mykwargs.get("count")
1098 header = mykwargs.get("header")
1099 percent = mykwargs.get("percent")
1100 text = myargs[0].encode('utf-8')
1101 if not header: header = ''
1102
1103 count_str = ""
1104 if count:
1105 if len(count) > 1:
1106 if percent:
1107 count_str = " ("+str(round((float(count[0])/count[1])*100,1))+"%) "
1108 else:
1109 count_str = " (%s/%s) " % (red(str(count[0])),blue(str(count[1])),)
1110
1111 def is_last_newline(f):
1112 try:
1113 f.seek(-1,os.SEEK_END)
1114 last = f.read(1)
1115 if last == "\n":
1116 return True
1117 except IOError:
1118 pass
1119 return False
1120
1121 if back:
1122 self.entropyTools.seek_till_newline(f)
1123 txt = header+count_str+text
1124 else:
1125 if not is_last_newline(f): f.write("\n")
1126 txt = header+count_str+text+"\n"
1127 f.write(txt)
1128
1129 f.flush()
1130
1131
1133 data = {}
1134 try:
1135 data['atom'], data['name'], data['version'], data['versiontag'], \
1136 data['description'], data['category'], data['chost'], \
1137 data['cflags'], data['cxxflags'],data['homepage'], \
1138 data['license'], data['branch'], data['download'], \
1139 data['digest'], data['slot'], data['etpapi'], \
1140 data['datecreation'], data['size'], data['revision'] = dbconn.getBaseData(idpackage)
1141 except TypeError:
1142 return data
1143 data['injected'] = dbconn.isInjected(idpackage)
1144 data['repoid'] = repoid
1145 data['idpackage'] = idpackage
1146 return data
1147
1149 data = {}
1150 data['atom'] = matched_atom
1151 data['key'] = self.entropyTools.dep_getkey(matched_atom)
1152 try:
1153 if from_installed:
1154 data['slot'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_installed_package_slot(matched_atom)
1155 portage_matched_atom = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_best_atom("%s:%s" % (data['key'],data['slot'],))
1156
1157 data['available_atom'] = portage_matched_atom
1158 if portage_matched_atom:
1159 data['use'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_package_useflags(portage_matched_atom)
1160 else:
1161
1162 data['use'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_installed_package_useflags(matched_atom)
1163 data['description'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_installed_package_description(matched_atom)
1164 else:
1165 data['slot'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_package_slot(matched_atom)
1166 data['use'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_package_useflags(matched_atom)
1167 data['installed_atom'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_installed_atom("%s:%s" % (data['key'],data['slot'],))
1168 data['description'] = self.SystemManagerExecutor.SystemInterface.Entropy.SpmService.get_package_description(matched_atom)
1169 except KeyError:
1170 pass
1171
1172 return data
1173