PollScheduler: rename sched_iface to _sched_iface

It isn't used externally anymore, since SchedulerInterface is used
directly in those places now. Many of the self.sched_iface references
updated here, it's more appropriate to use self._event_loop.

diff --git a/pym/_emerge/PollScheduler.py b/pym/_emerge/PollScheduler.py
index 8d5c290d7207de0dca56cf5f1f379abd39c59797..1a81e2d1791e81efee9ec1d922169bff6085b355 100644 (file)
--- a/pym/_emerge/PollScheduler.py
+++ b/pym/_emerge/PollScheduler.py
@@ -36,7 +36,7 @@ class PollScheduler(object):
                        self._event_loop = global_event_loop()
                else:
                        self._event_loop = EventLoop(main=False)
-               self.sched_iface = SchedulerInterface(self._event_loop,
+               self._sched_iface = SchedulerInterface(self._event_loop,
                        is_background=self._is_background)
 
        def _is_background(self):

diff --git a/pym/_emerge/Scheduler.py b/pym/_emerge/Scheduler.py
index d64468af0cab09ae38b3b7f93fe279143ca52901..40033c2c34b41febc0bdef23851d016b58722847 100644 (file)
--- a/pym/_emerge/Scheduler.py
+++ b/pym/_emerge/Scheduler.py
@@ -1337,12 +1337,12 @@ class Scheduler(PollScheduler):
                blocker_db.discardBlocker(pkg)
 
        def _main_loop(self):
-               term_check_id = self.sched_iface.idle_add(self._termination_check)
+               term_check_id = self._event_loop.idle_add(self._termination_check)
                loadavg_check_id = None
                if self._max_load is not None:
                        # We have to schedule periodically, in case the load
                        # average has changed since the last call.
-                       loadavg_check_id = self.sched_iface.timeout_add(
+                       loadavg_check_id = self._event_loop.timeout_add(
                                self._loadavg_latency, self._schedule)
 
                try:
@@ -1354,17 +1354,17 @@ class Scheduler(PollScheduler):
 
                        # Loop while there are jobs to be scheduled.
                        while self._keep_scheduling():
-                               self.sched_iface.iteration()
+                               self._event_loop.iteration()
 
                        # Clean shutdown of previously scheduled jobs. In the
                        # case of termination, this allows for basic cleanup
                        # such as flushing of buffered output to logs.
                        while self._is_work_scheduled():
-                               self.sched_iface.iteration()
+                               self._event_loop.iteration()
                finally:
-                       self.sched_iface.source_remove(term_check_id)
+                       self._event_loop.source_remove(term_check_id)
                        if loadavg_check_id is not None:
-                               self.sched_iface.source_remove(loadavg_check_id)
+                               self._event_loop.source_remove(loadavg_check_id)
 
        def _merge(self):
 
@@ -1378,7 +1378,7 @@ class Scheduler(PollScheduler):
                portage.elog.add_listener(self._elog_listener)
                display_timeout_id = None
                if self._status_display._isatty and not self._status_display.quiet:
-                       display_timeout_id = self.sched_iface.timeout_add(
+                       display_timeout_id = self._event_loop.timeout_add(
                                self._max_display_latency, self._status_display.display)
                rval = os.EX_OK
 
@@ -1389,7 +1389,7 @@ class Scheduler(PollScheduler):
                        portage.locks._quiet = False
                        portage.elog.remove_listener(self._elog_listener)
                        if display_timeout_id is not None:
-                               self.sched_iface.source_remove(display_timeout_id)
+                               self._event_loop.source_remove(display_timeout_id)
                        if failed_pkgs:
                                rval = failed_pkgs[-1].returncode
 

diff --git a/pym/portage/tests/ebuild/test_ipc_daemon.py b/pym/portage/tests/ebuild/test_ipc_daemon.py
index 5f2257cbb4b4b7aabb996860560070a4a119d70e..a871076259433fb61fe140d112d649d3158d5611 100644 (file)
--- a/pym/portage/tests/ebuild/test_ipc_daemon.py
+++ b/pym/portage/tests/ebuild/test_ipc_daemon.py
@@ -110,10 +110,8 @@ class IpcDaemonTestCase(TestCase):
                                commands = {'exit' : exit_command}
                                daemon = EbuildIpcDaemon(commands=commands,
                                        input_fifo=input_fifo,
-                                       output_fifo=output_fifo,
-                                       scheduler=task_scheduler.sched_iface)
-                               proc = SleepProcess(seconds=sleep_time_s,
-                                       scheduler=task_scheduler.sched_iface)
+                                       output_fifo=output_fifo)
+                               proc = SleepProcess(seconds=sleep_time_s)
                                task_scheduler = TaskScheduler(iter([daemon, proc]),
                                        max_jobs=2, event_loop=event_loop)
 

diff --git a/pym/portage/util/_async/AsyncScheduler.py b/pym/portage/util/_async/AsyncScheduler.py
index 0648220b62d71ccfd3b582ddc096c366d403148e..c6a37f59e79dde805f3c6f49ac32ce4ec9c3c554 100644 (file)
--- a/pym/portage/util/_async/AsyncScheduler.py
+++ b/pym/portage/util/_async/AsyncScheduler.py
@@ -51,7 +51,7 @@ class AsyncScheduler(AsynchronousTask, PollScheduler):
                                self._remaining_tasks = False
                        else:
                                self._running_tasks.add(task)
-                               task.scheduler = self.sched_iface
+                               task.scheduler = self._sched_iface
                                task.addExitListener(self._task_exit)
                                task.start()
 
@@ -65,31 +65,31 @@ class AsyncScheduler(AsynchronousTask, PollScheduler):
                self._schedule()
 
        def _start(self):
-               self._term_check_id = self.sched_iface.idle_add(self._termination_check)
+               self._term_check_id = self._event_loop.idle_add(self._termination_check)
                if self._max_load is not None:
                        # We have to schedule periodically, in case the load
                        # average has changed since the last call.
-                       self._loadavg_check_id = self.sched_iface.timeout_add(
+                       self._loadavg_check_id = self._event_loop.timeout_add(
                                self._loadavg_latency, self._schedule)
                self._schedule()
 
        def _wait(self):
                # Loop while there are jobs to be scheduled.
                while self._keep_scheduling():
-                       self.sched_iface.iteration()
+                       self._event_loop.iteration()
 
                # Clean shutdown of previously scheduled jobs. In the
                # case of termination, this allows for basic cleanup
                # such as flushing of buffered output to logs.
                while self._is_work_scheduled():
-                       self.sched_iface.iteration()
+                       self._event_loop.iteration()
 
                if self._term_check_id is not None:
-                       self.sched_iface.source_remove(self._term_check_id)
+                       self._event_loop.source_remove(self._term_check_id)
                        self._term_check_id = None
 
                if self._loadavg_check_id is not None:
-                       self.sched_iface.source_remove(self._loadavg_check_id)
+                       self._event_loop.source_remove(self._loadavg_check_id)
                        self._loadavg_check_id = None
 
                if self._error_count > 0: