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