def __init__(self, glib_context=None, gtk=False, application=None): assert (glib_context is not None) + bool(gtk) + (application is not None) <= 1 self._gtk = gtk self._application = application if gtk or self._application is not None: self._context = GLib.main_context_default() else: self._context = glib_context if glib_context else GLib.MainContext( ) self._readers = {} self._writers = {} self._sighandlers = {} self._chldhandlers = {} self._handlers = set() self._ready = collections.deque() self._wakeup = None self._will_dispatch = False self._loop_implem = None self._interrupted = False super(BaseGLibEventLoop, self).__init__() # install a default handler for SIGINT # in the default context if self._context == GLib.main_context_default(): assert hasattr(self, "_default_sigint_handler" ), "Must call BaseGLibEventLoop.init_class() first" self._default_sigint_handler.attach(self)
def pulse(self, owner): """Callback to update progress information""" if self.transaction.cancelled: return False self.transaction.progress_details = (self.current_items, self.total_items, self.current_bytes, self.total_bytes, self.current_cps, self.elapsed_time) percent = (((self.current_bytes + self.current_items) * 100.0) / float(self.total_bytes + self.total_items)) progress = int(self.progress_begin + percent / 100 * (self.progress_end - self.progress_begin)) # If the progress runs backwards emit an illegal progress value # e.g. during cache updates. if self.progress > progress: self.transaction.progress = 101 else: self.transaction.progress = progress self.progress = progress # Show all currently downloaded files items = [] for worker in owner.workers: if not worker.current_item: continue self._emit_acquire_item(worker.current_item, worker.total_size, worker.current_size) items.append(worker.current_item) self._emit_status_details(items) while GLib.main_context_default().pending(): GLib.main_context_default().iteration() return True
def __init__(self, glib_context=None, gtk=False, application=None): assert (glib_context is not None) + bool(gtk) + (application is not None) <= 1 self._gtk = gtk self._application = application if gtk or self._application is not None: self._context = GLib.main_context_default() else: self._context = glib_context if glib_context else GLib.MainContext() self._closed = False self._readers = {} self._writers = {} self._sighandlers = {} self._chldhandlers = {} self._handlers = set() self._ready = collections.deque() self._wakeup = None self._will_dispatch = False self._loop_implem = None self._interrupted = False super().__init__() # install a default handler for SIGINT # in the default context if self._context == GLib.main_context_default(): assert hasattr(self, "_default_sigint_handler"), "Must call BaseGLibEventLoop.init_class() first" self._default_sigint_handler.attach(self)
def pulse(self, owner): """Callback to update progress information""" if self.transaction.cancelled: return False self.transaction.progress_details = ( self.current_items, self.total_items, self.current_bytes, self.total_bytes, self.current_cps, self.elapsed_time, ) percent = ((self.current_bytes + self.current_items) * 100.0) / float(self.total_bytes + self.total_items) progress = int(self.progress_begin + percent / 100 * (self.progress_end - self.progress_begin)) # If the progress runs backwards emit an illegal progress value # e.g. during cache updates. if self.progress > progress: self.transaction.progress = 101 else: self.transaction.progress = progress self.progress = progress # Show all currently downloaded files items = [] for worker in owner.workers: if not worker.current_item: continue self._emit_acquire_item(worker.current_item, worker.total_size, worker.current_size) items.append(worker.current_item) self._emit_status_details(items) while GLib.main_context_default().pending(): GLib.main_context_default().iteration() return True
def get_license_key(uid, pkg_name, json_token, server_name): """Return the license key and the path for the given package.""" rootdir = apt_pkg.config["Dir"] license_key_helper = os.path.join( rootdir, "usr/share/software-center/ubuntu-license-key-helper") cmd = [license_key_helper, "--server", server_name, "--pkgname", pkg_name] proc = subprocess.Popen( cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE, stdout=subprocess.PIPE, preexec_fn=lambda: os.setuid(uid), close_fds=True, # this will give us str in py3 instead of bytes universal_newlines=True) # send json token to the process proc.stdin.write(json_token + "\n") # wait until it finishes while proc.poll() is None: while GLib.main_context_default().pending(): GLib.main_context_default().iteration() time.sleep(0.05) if proc.returncode != 0: stderr = proc.stderr.read() raise TransactionFailed(ERROR_LICENSE_KEY_DOWNLOAD_FAILED, stderr) # get data from stdout license_key_path = proc.stdout.readline().strip() license_key = proc.stdout.read() return license_key, license_key_path
def get_license_key(uid, pkg_name, json_token, server_name): """Return the license key and the path for the given package.""" rootdir = apt_pkg.config["Dir"] license_key_helper = os.path.join(rootdir, "usr/share/software-center/ubuntu-license-key-helper") cmd = [license_key_helper, "--server", server_name, "--pkgname", pkg_name] proc = subprocess.Popen( cmd, stdin=subprocess.PIPE, stderr=subprocess.PIPE, stdout=subprocess.PIPE, preexec_fn=lambda: os.setuid(uid), close_fds=True, # this will give us str in py3 instead of bytes universal_newlines=True, ) # send json token to the process proc.stdin.write(json_token + "\n") # wait until it finishes while proc.poll() is None: while GLib.main_context_default().pending(): GLib.main_context_default().iteration() time.sleep(0.05) if proc.returncode != 0: stderr = proc.stderr.read() raise TransactionFailed(ERROR_LICENSE_KEY_DOWNLOAD_FAILED, stderr) # get data from stdout license_key_path = proc.stdout.readline().strip() license_key = proc.stdout.read() return license_key, license_key_path
def test_sources(self): loop = GLib.MainLoop() self.setup_timeout(loop) idle = Idle(loop) self.assertEqual(idle.get_context(), None) idle.attach() self.assertEqual(idle.get_context(), GLib.main_context_default()) self.pos = 0 m = MySource() self.assertEqual(m.get_context(), None) m.set_callback(self.my_callback, loop) m.attach() self.assertEqual(m.get_context(), GLib.main_context_default()) loop.run() m.destroy() idle.destroy() self.assertGreater(self.pos, 0) self.assertGreaterEqual(idle.count, 0) self.assertTrue(m.is_destroyed()) self.assertTrue(idle.is_destroyed())
def open(uri): """Connects to the given URI.""" def mount_done(location, result, ignored): try: location.mount_enclosing_volume_finish(result) except GLib.GError as exc: print(colored("Could not connect: {}".format(exc.args[0]), "red")) else: print("Connected to {} :-)".format(location.get_uri())) connected.set() # XXX disconnect first connection = Gio.file_new_for_uri(uri) if not connection.query_exists(): connected = Event() mount_operation = Gio.MountOperation() connection.mount_enclosing_volume( Gio.MountMountFlags.NONE, mount_operation, None, mount_done, None) while not connected.is_set(): GLib.main_context_default().iteration(False) else: print("Connected to", uri) return connection
def show(self): """Show this mouse indicator and ignore awaiting fade away request.""" if self.timeout_timer and self.shown: # There is a fade away request, ignore it if GLib.main_context_default().find_source_by_id(self.timeout_timer) and not GLib.main_context_default().find_source_by_id(self.timeout_timer).is_destroyed(): GLib.source_remove(self.timeout_timer) self.timeout_timer = None # This method only is called when mouse is pressed, so there will be a # release and fade_away call, no need to set up another timer. super(ShapedWindow, self).show()
def wait_for_status(self, desiredstatus, alternative_breakfunc=lambda: False): """Wait until the instrument comes into the desired state or alternative_breakfunc() returns True. During the wait, this calls the default GObject main loop. """ while not (self.status == desiredstatus or alternative_breakfunc()): for i in range(100): GLib.main_context_default().iteration(False) if not GLib.main_context_default().pending(): break return not alternative_breakfunc()
def wait_for_vacuum(self, pthreshold=1.0, alternative_breakfunc=lambda: False): """Wait until the vacuum becomes better than pthreshold or alternative_breakfunc() returns True. During the wait, this calls the default GObject main loop. """ while not (self.pressure <= pthreshold or alternative_breakfunc()): for i in range(100): GLib.main_context_default().iteration(False) if not GLib.main_context_default().pending(): break return (not alternative_breakfunc())
def wait_for_idle(self, alternative_breakfunc=lambda: False): """Wait until the instrument becomes idle or alternative_breakfunc() returns True. During the wait, this calls the default GObject main loop. """ while not (self.is_idle() or alternative_breakfunc()): for i in range(100): GLib.main_context_default().iteration(False) if not GLib.main_context_default().pending(): break return (not alternative_breakfunc())
def media_change(self, medium, drive): """Callback for media changes""" self.transaction.required_medium = medium, drive self.transaction.paused = True self.transaction.status = enums.STATUS_WAITING_MEDIUM while self.transaction.paused: GLib.main_context_default().iteration() self.transaction.status = enums.STATUS_DOWNLOADING if self.transaction.cancelled: return False return True
def block_on(self, func, *args, **kwargs): done = threading.Event() result = [None] def cb(data): result[0] = func(*args, **kwargs) done.set() GLib.main_context_default().invoke_full(GLib.PRIORITY_DEFAULT, cb, None) done.wait() return result[0]
def wait_for_temperature(self, interval, delta=0.01, setpoint=None, alternative_breakfunc=lambda: False): """Wait until the vacuum becomes better than pthreshold or alternative_breakfunc() returns True. During the wait, this calls the default GObject main loop. """ if setpoint is None: setpoint = self.get_setpoint() lastwrong = time.time() while not ((time.time() - lastwrong) > interval or alternative_breakfunc()): for i in range(100): GLib.main_context_default().iteration(False) if not GLib.main_context_default().pending(): break if abs(setpoint - self.get_temperature()) > delta: lastwrong = time.time() return (not alternative_breakfunc())
def __init__(self, **kwargs): super(GioConsole, self).__init__(**kwargs) self.main_context = GLib.main_context_default() self.input_stream = Gio.UnixInputStream.new(self.input_fd, False) self._active = False self.input_stream.read_bytes_async( 1, GLib.PRIORITY_HIGH, None, self._read_char, None)
def setUp(self): self.timeout_seconds = 10 # seconds per test self._main_context = GLib.main_context_default() self.__timed_out = False self.__old_service_file = '/etc/avahi/services/eos-updater.service' self.__new_service_file = '/etc/avahi/services/eos-ostree-updater-0.service' self.__config_file = '/etc/eos-updater/eos-update-server.conf'
def apply_search(self, panel, add_list): """ Add persons to specified panel by self.queue. """ thread_event = Event() context = GLib.main_context_default() while True: item = self.queue.get() if item == 'stop': self.queue.task_done() return add_list.append(item.handle) task_id = GLib.idle_add(self.do_this, thread_event, self.add_to_result, item.handle, panel) task = context.find_source_by_id(task_id) # wait until person is added to list while not thread_event.wait(timeout=0.01): if not self.in_search: if task and not task.is_destroyed(): GLib.source_remove(task.get_id()) self.queue.task_done() return thread_event.clear() self.queue.task_done()
def do_activate(self): # only one instance if len(self.get_windows()) > 0: self.window.present(); # main window to foreground return # start setup if no login if not HubLinuxConfig().hasLogin: loop = GLib.MainLoop(GLib.main_context_default()) assistance = InitialSetupAssistant(loop) assistance.show() loop.run() # setup canceled? if HubLinuxConfig().hasLogin: self.set_app_menu(self.appMenu) self.appWindow = Window(self) self.provider = Gtk.CssProvider() self.provider.load_from_path(ROOT_DIR + "/data/style.css") screen = self.appWindow.get_screen() self.appWindow.get_style_context().add_provider_for_screen(screen, self.provider, 1000) self.appWindow.show_all() else: LOG.warning("No login credentials -> Exit")
def tearDown(self): self.roster.window.destroy() # Clean main loop from gi.repository import GLib mc = GLib.main_context_default() while mc.pending(): mc.iteration()
def __zerolistener(self, *args): if self.ended: return False cur_time = time() t1 = cur_time + self.getPlayerTime(WHITE) t2 = cur_time + self.getPlayerTime(BLACK) if t1 <= t2: t = t1 color = WHITE else: t = t2 color = BLACK s = t - cur_time + 0.01 if s > 0 and s != self.zero_listener_time: if ( (self.zero_listener_id is not None) and (self.zero_listener_source is not None) and not self.zero_listener_source.is_destroyed() ): GLib.source_remove(self.zero_listener_id) self.zero_listener_time = s self.zero_listener_id = GLib.timeout_add(10, self.__checkzero, color) default_context = GLib.main_context_get_thread_default() or GLib.main_context_default() if hasattr(default_context, "find_source_by_id"): self.zero_listener_source = default_context.find_source_by_id(self.zero_listener_id)
def __init__(self): super(UPnPDeviceManager, self).__init__() GObject.threads_init() GObject.signal_new("device-available", UPnPDeviceManager, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, (GObject.TYPE_PYOBJECT,)) GObject.signal_new("device-unavailable", UPnPDeviceManager, GObject.SIGNAL_RUN_LAST, GObject.TYPE_BOOLEAN, (GObject.TYPE_PYOBJECT,)) atexit.register(self.cleanup_files) self.contexts = [] self.cps = [] self.devices = [] self.sources = [] self.renderers = [] self.device_services = {} self.introspections = {} self.created_files = [] # Get a default maincontext self.main_ctx = GLib.main_context_default() # Use the built in GUPnP Network Manager to listen on # all interfaces self.ctx_mgr = GUPnP.ContextManager.new(self.main_ctx, 0) self.ctx_mgr.connect("context_available", self.new_ctx) self.new_ctx(self.ctx_mgr, GUPnP.Context(interface="eth0"))
def do_activate(self): # only one instance if len(self.get_windows()) > 0: image = os.path.realpath("./assets/icon.png") Notify.init(APP_NAME) notification = Notify.Notification.new( APP_NAME, _('Another instance of %(name)s is running. You can start %(name)s only once.') % {'name': APP_NAME}, image ) notification.show() return # start setup if no login if not HubLinuxConfig().hasLogin: loop = GLib.MainLoop(GLib.main_context_default()) assistance = InitialSetupAssistant(loop) assistance.show() loop.run() # setup canceled? if HubLinuxConfig().hasLogin: self.set_app_menu(self.appMenu) self.appWindow = Window(self) self.appWindow.show_all() else: LOG.warning("No login credentials -> Exit")
def test_get_total_size(self): def _on_query_total_size_on_install_done(pkginfo, pkgname, download, space): self.need_download = download self.need_space = space loop.quit() TEST_PKG = "casper" ADDONS_TO_INSTALL = [ "lupin-casper" ] ADDONS_TO_REMOVE = [] loop = GLib.MainLoop(GLib.main_context_default()) cache = get_test_pkg_info() cache.connect( "query-total-size-on-install-done", _on_query_total_size_on_install_done) cache.query_total_size_on_install( TEST_PKG, ADDONS_TO_INSTALL, ADDONS_TO_REMOVE) loop.run() # ensure the test eventually stops and does not hang GLib.timeout_add_seconds(10, loop.quit) # work out the numbers that we at least need to get (this will # not include dependencies so it is probably lower) need_at_least_download = ( cache[TEST_PKG].candidate.size + sum([cache[pkg].candidate.size for pkg in ADDONS_TO_INSTALL])) need_at_least_installed = ( cache[TEST_PKG].candidate.installed_size + sum([cache[pkg].candidate.installed_size for pkg in ADDONS_TO_INSTALL])) self.assertTrue(self.need_download >= need_at_least_download) self.assertTrue(self.need_space >= need_at_least_installed) del self.need_download del self.need_space
def __zerolistener(self, *args): if self.ended: return False cur_time = time() whites_time = cur_time + self.getPlayerTime(WHITE) blacks_time = cur_time + self.getPlayerTime(BLACK) if whites_time <= blacks_time: the_time = whites_time color = WHITE else: the_time = blacks_time color = BLACK remaining_time = the_time - cur_time + 0.01 if remaining_time > 0 and remaining_time != self.zero_listener_time: if (self.zero_listener_id is not None) and \ (self.zero_listener_source is not None) and \ not self.zero_listener_source.is_destroyed(): GLib.source_remove(self.zero_listener_id) self.zero_listener_time = remaining_time self.zero_listener_id = GLib.timeout_add(10, self.__checkzero, color) default_context = GLib.main_context_get_thread_default( ) or GLib.main_context_default() if hasattr(default_context, "find_source_by_id"): self.zero_listener_source = default_context.find_source_by_id( self.zero_listener_id)
def initiate_purchase(self, app, iconname, url=None, html=None): """ initiates the purchase workflow inside the embedded webkit window for the item specified """ if not self._ask_for_tos_acceptance_if_needed(): self.emit("terms-of-service-declined") return False self.init_view() self.app = app self.iconname = iconname self.wk.webkit.load_html_string(self.LOADING_HTML, "file:///") self.wk.show() context = GLib.main_context_default() while context.pending(): context.iteration() if url: self.wk.webkit.load_uri(url) elif html: self.wk.webkit.load_html_string(html, "file:///") else: self.wk.webkit.load_html_string(DUMMY_HTML, "file:///") # only for debugging if os.environ.get("SOFTWARE_CENTER_DEBUG_BUY"): GLib.timeout_add_seconds(1, _generate_events, self) return True
def __init__(self, figure): if _debug: print('FigureCanvasGTK3.%s' % fn_name()) FigureCanvasBase.__init__(self, figure) GObject.GObject.__init__(self) self._idle_draw_id = 0 self._need_redraw = True self._lastCursor = None self.connect('scroll_event', self.scroll_event) self.connect('button_press_event', self.button_press_event) self.connect('button_release_event', self.button_release_event) self.connect('configure_event', self.configure_event) self.connect('draw', self.on_draw_event) self.connect('key_press_event', self.key_press_event) self.connect('key_release_event', self.key_release_event) self.connect('motion_notify_event', self.motion_notify_event) self.connect('leave_notify_event', self.leave_notify_event) self.connect('enter_notify_event', self.enter_notify_event) self.connect('size_allocate', self.size_allocate) self.set_events(self.__class__.event_mask) self.set_double_buffered(True) self.set_can_focus(True) self._renderer_init() self._idle_event_id = GLib.idle_add(self.idle_event) default_context = GLib.main_context_get_thread_default( ) or GLib.main_context_default() self._idle_event_source = default_context.find_source_by_id( self._idle_event_id)
def getPosition(self, blocks=False): """ Get the current position of the L{Pipeline}. @return: The current position or Gst.CLOCK_TIME_NONE @rtype: L{long} @raise PipelineError: If the position couldn't be obtained. """ maincontext = GLib.main_context_default() if blocks and self._recovery_state == self.RecoveryState.NOT_RECOVERING: while self._waiting_for_async_done and self._recovery_state == self.RecoveryState.NOT_RECOVERING: self.info("Iterating mainloop waiting for the pipeline to be ready to be queried") maincontext.iteration(True) try: res, cur = self._pipeline.query_position(Gst.Format.TIME) except Exception as e: self.handleException(e) raise PipelineError("Couldn't get position") if not res: raise PipelineError("Position not available") self.log("Got position %s", format_ns(cur)) return cur
def update_from_app_install_data(db, cache, datadir=None): """ index the desktop files in $datadir/desktop/*.desktop """ if not datadir: datadir = softwarecenter.paths.APP_INSTALL_DESKTOP_PATH context = GLib.main_context_default() for desktopf in glob(datadir + "/*.desktop") + glob(datadir + "/*.scope"): LOG.debug("processing %r", desktopf) # process events while context.pending(): context.iteration() try: if desktopf.endswith('.scope'): parser = ScopeConfigParser() else: parser = DesktopConfigParser() parser.read(desktopf) parser.index_app_info(db, cache) except Exception as e: # Print a warning, no error (Debian Bug #568941) LOG.debug("error processing: %r %r", desktopf, e) warning_text = _( "The file: '%s' could not be read correctly. The application " "associated with this file will not be included in the " "software catalog. Please consider raising a bug report " "for this issue with the maintainer of that application") LOG.warning(warning_text, desktopf) return True
def gobject_thread(): ctx = GLib.main_context_default() while not self.qtile.is_stopped(): try: ctx.iteration(True) except Exception: logger.exception('got exception from gobject')
def test_blocking_put_wait(self): def gen(): when = yield self.assertAlmostEqual(0.01, when) yield 0.01 loop = gpotato.GLibEventLoop(GLib.main_context_default()) self.addCleanup(loop.close) q = asyncio.Queue(maxsize=1, loop=loop) started = asyncio.Event(loop=loop) finished = False @asyncio.coroutine def queue_put(): nonlocal finished started.set() yield from q.put(1) yield from q.put(2) finished = True @asyncio.coroutine def queue_get(): loop.call_later(0.01, q.get_nowait) queue_put_task = asyncio.Task(queue_put(), loop=loop) yield from started.wait() self.assertFalse(finished) yield from queue_put_task self.assertTrue(finished) loop.run_until_complete(queue_get()) self.assertAlmostEqual(0.01, loop.time())
def test_get_cancelled(self): def gen(): when = yield self.assertAlmostEqual(0.01, when) when = yield 0.01 self.assertAlmostEqual(0.061, when) yield 0.05 loop = gpotato.GLibEventLoop(GLib.main_context_default()) self.addCleanup(loop.close) q = asyncio.Queue(loop=loop) @asyncio.coroutine def queue_get(): return (yield from asyncio.wait_for(q.get(), 0.051, loop=loop)) @asyncio.coroutine def test(): get_task = asyncio.Task(queue_get(), loop=loop) yield from asyncio.sleep(0.01, loop=loop) # let the task start q.put_nowait(1) return (yield from get_task) self.assertEqual(1, loop.run_until_complete(test())) self.assertAlmostEqual(0.06, loop.time())
def __init__(self, figure): if _debug: print('FigureCanvasGTK3.%s' % fn_name()) FigureCanvasBase.__init__(self, figure) GObject.GObject.__init__(self) self._idle_draw_id = 0 self._need_redraw = True self._lastCursor = None self.connect('scroll_event', self.scroll_event) self.connect('button_press_event', self.button_press_event) self.connect('button_release_event', self.button_release_event) self.connect('configure_event', self.configure_event) self.connect('draw', self.on_draw_event) self.connect('key_press_event', self.key_press_event) self.connect('key_release_event', self.key_release_event) self.connect('motion_notify_event', self.motion_notify_event) self.connect('leave_notify_event', self.leave_notify_event) self.connect('enter_notify_event', self.enter_notify_event) self.connect('size_allocate', self.size_allocate) self.set_events(self.__class__.event_mask) self.set_double_buffered(True) self.set_can_focus(True) self._renderer_init() default_context = GLib.main_context_get_thread_default() or GLib.main_context_default()
def __init__(self, figure): FigureCanvasBase.__init__(self, figure) GObject.GObject.__init__(self) self._idle_draw_id = 0 self._lastCursor = None self.connect('scroll_event', self.scroll_event) self.connect('button_press_event', self.button_press_event) self.connect('button_release_event', self.button_release_event) self.connect('configure_event', self.configure_event) self.connect('draw', self.on_draw_event) self.connect('key_press_event', self.key_press_event) self.connect('key_release_event', self.key_release_event) self.connect('motion_notify_event', self.motion_notify_event) self.connect('leave_notify_event', self.leave_notify_event) self.connect('enter_notify_event', self.enter_notify_event) self.connect('size_allocate', self.size_allocate) self.set_events(self.__class__.event_mask) self.set_double_buffered(True) self.set_can_focus(True) self._renderer_init() default_context = GLib.main_context_get_thread_default( ) or GLib.main_context_default()
def _perform(self, multi, handles): # While we're performing the cURL downloads, we need to periodically # process D-Bus events, otherwise we won't be able to cancel downloads # or handle other interruptive events. To do this, we grab the GLib # main loop context and then ask it to do an iteration over its events # once in a while. It turns out that even if we're not running a D-Bus # main loop (i.e. during the in-process tests) periodically dispatching # into GLib doesn't hurt, so just do it unconditionally. self.received = 0 context = GLib.main_context_default() while True: # Do the progress callback, but only if the current received size # is different than the last one. Don't worry about in which # direction it's different. received = int( sum(c.getinfo(pycurl.SIZE_DOWNLOAD) for c in handles)) if received != self.received: self._do_callback() self.received = received if not self._do_once(multi, handles): break multi.select(SELECT_TIMEOUT) # Let D-Bus events get dispatched, but only block if downloads are # paused. while context.iteration(may_block=self._paused): pass if self._queued_cancel: raise Canceled # One last callback, unconditionally. self.received = int( sum(c.getinfo(pycurl.SIZE_DOWNLOAD) for c in handles)) self._do_callback()
def __init__(self, bus_address: str = None, bus_type: BusType = BusType.SESSION): if _import_error: raise _import_error super().__init__(bus_address, bus_type, ProxyObject) self._main_context = GLib.main_context_default()
def __init__(self): super().__init__() if isinstance(threading.current_thread(), threading._MainThread): self._context = GLib.main_context_default() else: self._context = GLib.MainContext() self.loop = GLib.MainLoop(self._context) self.pending_events = set()
def _conffile(self, current, new): """Callback for a config file conflict""" log.warning("Config file prompt: '%s' (%s)" % (current, new)) self.transaction.config_file_conflict = (current, new) self.transaction.paused = True self.transaction.status = enums.STATUS_WAITING_CONFIG_FILE_PROMPT while self.transaction.paused: GLib.main_context_default().iteration() log.debug("Sending config file answer: %s", self.transaction.config_file_conflict_resolution) if self.transaction.config_file_conflict_resolution == "replace": os.write(self.master_fd, b"y\n") elif self.transaction.config_file_conflict_resolution == "keep": os.write(self.master_fd, b"n\n") self.transaction.config_file_conflict_resolution = None self.transaction.config_file_conflict = None self.transaction.status = enums.STATUS_COMMITTING return True
def wait_main_milli(t): _state = {"ready": False} c = GLib.main_context_default() def _func(): _state["ready"] = True GLib.timeout_add(int(t), _func) while not _state["ready"]: c.iteration(True)
def __worker(): try: res = func(self, *_args) except: print_except() res = error_ret ctx = GLib.main_context_default() ctx.invoke_full(0, _reply_hdl, res)
def setUp(self): self.loop = GLib.MainLoop(GLib.main_context_default()) # setup bus dbus_service_name = DBUS_BUS_NAME proc, dbus_address = start_dbus_daemon() bus = dbus.bus.BusConnection(dbus_address) # run the checks self.bus_name = dbus.service.BusName(dbus_service_name, bus)
def show(self): """Show this mouse indicator and ignore awaiting fade away request.""" if self.timeout_timer and self.shown: # There is a fade away request, ignore it if GLib.main_context_default().find_source_by_id( self.timeout_timer) and not GLib.main_context_default( ).find_source_by_id(self.timeout_timer).is_destroyed(): GLib.source_remove(self.timeout_timer) self.timeout_timer = None # This method only is called when mouse is pressed, so there will be a # release and fade_away call, no need to set up another timer. super(ShapedWindow, self).show() # Fix click-through pm = gtk.gdk.Pixmap(None, self.get_size()[0], self.get_size()[1], 1) pmcr = pm.cairo_create() pmcr.rectangle(0, 0, 1, 1) pmcr.fill() self.input_shape_combine_mask(pm, 0, 0)
def get_url_title_async(url, readycallback, userdata, context=None): """Gets url's title assynchronously """ if context is None: context = GLib.main_context_default() source = GetURLTitleThreadSource(url, readycallback, userdata) #pylint: disable=E1101 source.attach(context)
def get_url_title_async(url, readycallback, userdata, context=None): """Gets url's title asynchronously """ if context is None: context = GLib.main_context_default() source = GetURLTitleThreadSource(url, readycallback, userdata) #pylint: disable=E1101 source.attach(context)
def wait_for_lock(trans, alt_lock=None): """Acquire the system lock or the optionally given one. If the lock cannot be obtained pause the transaction in the meantime. :param trans: the transaction :param lock: optional alternative lock """ def watch_lock(): """Helper to unpause the transaction if the lock can be obtained. Keyword arguments: trans -- the corresponding transaction alt_lock -- alternative lock to the system lock """ try: if alt_lock: alt_lock.acquire() else: acquire() except LockFailedError: return True trans.paused = False return True try: if alt_lock: alt_lock.acquire() else: acquire() except LockFailedError as error: trans.paused = True trans.status = enums.STATUS_WAITING_LOCK if error.process: # TRANSLATORS: %s is the name of a package manager msg = trans.gettext("Waiting for %s to exit") trans.status_details = msg % error.process lock_watch = GLib.timeout_add_seconds(3, watch_lock) while trans.paused and not trans.cancelled: GLib.main_context_default().iteration() GLib.source_remove(lock_watch) if trans.cancelled: raise TransactionCancelled()
def wait(self, timeout=0): """Wait until the corouine is finished or return after timeout seconds. This is achieved by running the GTK+ main loop. """ clock = time.clock start_time = clock() main = GLib.main_context_default() while self.is_alive(): main.iteration(False) if timeout and (clock() - start_time >= timeout): return
def ensure_installation_date_and_lazy_history_loading(self, appdetails): # we run two tests, the first is to ensure that we get a # result from installation_data immediately (at this point the # history is not loaded yet) so we expect "None" self.assertEqual(appdetails.installation_date, None) # then we need to wait until the history is loaded in the idle # handler context = GLib.main_context_default() while context.pending(): context.iteration() # ... and finally we test that its really there # FIXME: this will only work if software-center is installed self.assertNotEqual(appdetails.installation_date, None)
def setUp(self): self.loop = GLib.MainLoop(GLib.main_context_default()) self.error = False if "SOFTWARE_CENTER_RECOMMENDER_HOST" in os.environ: orig_host = os.environ.get("SOFTWARE_CENTER_RECOMMENDER_HOST") self.addCleanup(os.environ.__setitem__, "SOFTWARE_CENTER_RECOMMENDER_HOST", orig_host) else: self.addCleanup(os.environ.pop, "SOFTWARE_CENTER_RECOMMENDER_HOST") server = "https://rec.staging.ubuntu.com" os.environ["SOFTWARE_CENTER_RECOMMENDER_HOST"] = server # most tests need it self.recommender_agent = RecommenderAgent() self.recommender_agent.connect("error", self.on_query_error)
def __init__(self, use_cache=True): LOG.debug("AptHistory.__init__()") self.main_context = GLib.main_context_default() self.history_file = apt_pkg.config.find_file("Dir::Log::History") #Copy monitoring of history file changes from historypane.py self.logfile = Gio.File.new_for_path(self.history_file) self.monitor = self.logfile.monitor_file(0, None) self.monitor.connect("changed", self._on_apt_history_changed) self.update_callback = None LOG.debug("init history") # this takes a long time, run it in the idle handler self._transactions = [] self._history_ready = False GLib.idle_add(self._rescan, use_cache)
def __init__(self): import gi.repository.GLib as glib self.IO_ERR = glib.IO_ERR self.IO_HUP = glib.IO_HUP self.IO_IN = glib.IO_IN self.IO_NVAL = glib.IO_NVAL self.IO_OUT = glib.IO_OUT self.IO_PRI = glib.IO_PRI self.iteration = glib.main_context_default().iteration self.child_watch_add = glib.child_watch_add self.idle_add = glib.idle_add self.io_add_watch = glib.io_add_watch self.timeout_add = glib.timeout_add self.source_remove = glib.source_remove