def test_idle_method_callback_no_data(self): self.loop = GLib.MainLoop() GLib.idle_add(self.cb_no_data) self.loop.run()
def main(): SearchPassService() GLib.MainLoop().run()
import gi gi.require_version('NM', '1.0') from gi.repository import GLib, NM # pylint: disable=wrong-import-position try: import configparser as configparser except ImportError: import ConfigParser as configparser ENV = os.environ.copy() ENV['LC_ALL'] = 'C' ENC = locale.getpreferredencoding() CLIENT = NM.Client.new(None) LOOP = GLib.MainLoop() CONNS = CLIENT.get_connections() if sys.version_info.major < 3: str = unicode def dmenu_cmd(num_lines, prompt="Networks", active_lines=None): # pylint: disable=too-many-branches """Parse config.ini if it exists and add options to the dmenu command Args: args - num_lines: number of lines to display prompt: prompt to show Returns: command invocation (as a list of strings) for dmenu -l <num_lines> -p <prompt> -i ... """ dmenu_command = "dmenu"
def __init__(self, timeout): self._mainloop = GLib.MainLoop() self._cancellable = Gio.Cancellable.new() self._timeout = timeout self._timeout_id = None
@dbus.service.method("com.example.SampleInterface", in_signature='', out_signature='(ss)') def GetTuple(self): return ("Hello Tuple", " from example-service.py") @dbus.service.method("com.example.SampleInterface", in_signature='', out_signature='a{ss}') def GetDict(self): return {"first": "Hello Dict", "second": " from example-service.py"} @dbus.service.method("com.example.SampleInterface", in_signature='', out_signature='') def Exit(self): mainloop.quit() if __name__ == '__main__': dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) session_bus = dbus.SessionBus() name = dbus.service.BusName("com.example.SampleService", session_bus) object = SomeObject(session_bus, '/SomeObject') mainloop = GLib.MainLoop() print "Running example service." print usage mainloop.run()
) except Exception as e: sys.stderr.write("Error: %s\n" % e) main_loop.quit() if __name__ == "__main__": # parse arguments persistent = False if len(sys.argv) != 2 and len(sys.argv) != 3: sys.exit('Usage: %s <connection name> [persistent]' % sys.argv[0]) if len(sys.argv) == 3: if sys.argv[2] in "persistent" and sys.argv[2][:1] == "p": persistent = True else: sys.exit('Usage: %s <connection name> [persistent]' % sys.argv[0]) profile_name = sys.argv[1] main_loop = GLib.MainLoop() # create Client object client = NM.Client.new(None) # create a connection profile for NM con = create_profile(profile_name) # send the connection to NM client.add_connection_async(con, persistent, None, added_cb, None) main_loop.run()
def main(): from gi.repository import GLib from xpra.platform import program_context with program_context("Sound-Record"): args = sys.argv log.enable_debug() import os.path if len(args) not in (2, 3): print("usage: %s [-v|--verbose] filename [codec]" % sys.argv[0]) return 1 filename = args[1] if not os.path.exists(filename): print("file %s does not exist" % filename) return 2 decoders = get_decoders() if len(args) == 3: codec = args[2] if codec not in decoders: print("invalid codec: %s" % codec) print("only supported: %s" % str(decoders.keys())) return 2 codecs = [codec] else: codec = None parts = filename.split(".") if len(parts) > 1: extension = parts[-1] if extension.lower() in codecs: codec = extension.lower() print("guessed codec %s from file extension %s" % (codec, extension)) if codec is None: print("assuming this is an mp3 file...") codec = MP3 codecs = [codec] log.enable_debug() with open(filename, "rb") as f: data = f.read() print("loaded %s bytes from %s" % (len(data), filename)) #force no leak since we push all the data at once global QUEUE_LEAK, QUEUE_SILENT QUEUE_LEAK = GST_QUEUE_NO_LEAK QUEUE_SILENT = True ss = SoundSink(codecs=codecs) def eos(*args): print("eos%s" % (args, )) GLib.idle_add(glib_mainloop.quit) ss.connect("eos", eos) ss.start() glib_mainloop = GLib.MainLoop() import signal def deadly_signal(*_args): GLib.idle_add(ss.stop) GLib.idle_add(glib_mainloop.quit) def force_quit(_sig, _frame): sys.exit() signal.signal(signal.SIGINT, force_quit) signal.signal(signal.SIGTERM, force_quit) signal.signal(signal.SIGINT, deadly_signal) signal.signal(signal.SIGTERM, deadly_signal) def check_for_end(*_args): qtime = ss.queue.get_property("current-level-time") // MS_TO_NS if qtime <= 0: log.info("underrun (end of stream)") start_thread(ss.stop, "stop", daemon=True) GLib.timeout_add(500, glib_mainloop.quit) return False return True GLib.timeout_add(1000, check_for_end) GLib.idle_add(ss.add_data, data) glib_mainloop.run() return 0
def setUp(self): self.loop = GLib.MainLoop() self._error = [] self._success = []
import gi from gi.repository import GLib from gi.repository import Gio PYTHONPATH = os.path.join(os.environ["TOPSRCDIR"], "logger") sys.path.append(PYTHONPATH) import fleet_commander_logger as FleetCommander # Set logging level to debug log = logging.getLogger() level = logging.getLevelName("DEBUG") log.setLevel(level) # Get mainloop ml = GLib.MainLoop() # Test helpers def mainloop_quit_callback(*args, **kwargs): logging.error( "Timed out waiting for file update notification. Test probably failed") ml.quit() class MockConnectionManager(object): """ Connection Manager mock class """ def __init__(self):
# start logging logger = logging.getLogger("bt_auto_loader") logger.setLevel(LOG_LEVEL) logger.addHandler(logging.handlers.SysLogHandler(address = LOG_FILE)) logger.info("Starting to monitor Bluetooth/A2DP connections") # Get the system bus try: dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) bus = dbus.SystemBus() except Exception as ex: logger.error("Unable to get the system dbus: '{0}'. Exiting. Is dbus running?".format(ex.message)) sys.exit(1) # listen for signals on the Bluez bus bus.add_signal_receiver(interface_change, bus_name="org.bluez", signal_name="InterfacesAdded", member_keyword="member") bus.add_signal_receiver(interface_change, bus_name="org.bluez", signal_name="InterfacesRemoved", member_keyword="member") try: mainloop = gobject.MainLoop() mainloop.run() except KeyboardInterrupt: pass except: logger.error("Unable to run the gobject main loop") sys.exit(1) logger.info("Shutting down") sys.exit(0)
if 'xesam:artist' in keys and 'xesam:title' in keys: print('{} - {}'.format(metadata['xesam:artist'][0], metadata['xesam:title'])) def init_player(name): # choose if you want to manage the player based on the name if name.name in ['vlc', 'cmus']: player = Playerctl.Player.new_from_name(name) player.connect('playback-status::playing', on_play, manager) player.connect('metadata', on_metadata, manager) manager.manage_player(player) def on_name_appeared(manager, name): init_player(name) def on_player_vanished(manager, player): print('player has exited: {}'.format(player.props.player_name)) manager.connect('name-appeared', on_name_appeared) manager.connect('player-vanished', on_player_vanished) for name in manager.props.player_names: init_player(name) main = GLib.MainLoop() main.run()
def show(self): self._init_player() # Wait for events main = GLib.MainLoop() main.run()
def run(self): logger.info(f"Monitoring Services : {self.services_to_monitor}") try: # Register all the services to signal of 'PropertiesChanged' and # raise an alert if some service is not active on initially or if # Unit is not found for the service services_to_monitor_copy = copy.deepcopy(self.services_to_monitor) for service in services_to_monitor_copy: err = self.connect_to_prop_changed_signal(service) if err: self.raise_alert(service, "N/A", "N/A", "N/A", "N/A", "N/A", "N/A", 0) logger.error( f"{service} is not active initially. \n Error {err}") else: self.services_to_monitor.remove(service) logger.debug(f"failed_services : {self.failed_services}") logger.debug(f"services_to_monitor : {self.services_to_monitor}") # Retrieve the main loop which will be called in the run method self._loop = GLib.MainLoop() # Initialize the gobject threads and get its context GLib.threads_init() context = self._loop.get_context() time_to_check_lists = self.current_time() + self.polling_frequency # WHILE LOOP FUNCTION : every second we check for # properties change event if any generated (using context # iteration) and after a delay of polling frequency we # check for inactive processes. while self.is_running(): # At interval of 'thread_sleep' check for events occured for # registered services and process them(call on_pro_changed()) context.iteration(False) time.sleep(self.thread_sleep) # At interval of 'polling_freqency' process unregistered # services and services with not-active (intermidiate) state. if time_to_check_lists <= self.current_time(): time_to_check_lists = self.current_time() + \ self.polling_frequency # Try to bind the enabled services on the node to the # signal whose Unit was earlier not found. On successfully # registering for service state change signal, remove from # local list as monitoring enabled through SystemD # and to avoid re-registration. services_to_monitor_copy = copy.deepcopy( self.services_to_monitor) for service in services_to_monitor_copy: if not self.connect_to_prop_changed_signal(service): self.services_to_monitor.remove(service) # Check for services in intermidiate state(not active) self.check_notactive_services() logger.info("ServiceMonitor gracefully breaking out " +\ "of dbus Loop, not restarting.") except GLib.Error as err: raise ThreadException( self.SENSOR_NAME, "Ungrecefully breaking out of GLib.MainLoop() with error: %s" % err) except DBusException as err: raise ThreadException( self.SENSOR_NAME, "Ungracefully breaking out of dbus loop with error: %s" % err) except Exception as err: raise ThreadException(self.SENSOR_NAME, "Ungracefully breaking out of ServiceMonitor:run() "\ "with error: %s" % err)
def _create_mainloop(self): ''' Create GLibMainLoop ''' if not self.mainloop: self.mainloop = GLib.MainLoop()
def test_idle_method_callback_with_data(self): self.loop = GLib.MainLoop() data = {} GLib.idle_add(self.cb_with_data, data) self.loop.run() self.assertTrue(data['called'])
def __init__(self, port=8309): Gst.init(None) self.loop = GLib.MainLoop() self.pipe = Gst.Pipeline() self.port = port
def main(): parser = argparse.ArgumentParser(description='Pravega to screen') parser.add_argument('--controller', default='127.0.0.1:9090') parser.add_argument('--log_level', type=int, default=logging.INFO, help='10=DEBUG,20=INFO') parser.add_argument('--scope', default='examples') parser.add_argument('--stream', default='hls3') args = parser.parse_args() logging.basicConfig(level=args.log_level) logging.info('args=%s' % str(args)) # Set GStreamer plugin path. script_dir = os.path.dirname(os.path.abspath(__file__)) pravega_plugin_dir = os.path.join(script_dir, '..', 'gst-plugin-pravega', 'target', 'debug') logging.info('pravega_plugin_dir=%s' % pravega_plugin_dir) python_plugin_dir = os.path.join(script_dir, 'plugins') logging.info('python_plugin_dir=%s' % python_plugin_dir) plugin_path = ':'.join([python_plugin_dir, pravega_plugin_dir, os.environ['GST_PLUGIN_PATH']]) logging.debug('plugin_path=%s' % plugin_path) os.environ['GST_PLUGIN_PATH'] = plugin_path # Set GStreamer log level. if not 'GST_DEBUG' in os.environ: os.environ['GST_DEBUG'] = 'pravegasrc:DEBUG,python:LOG,identity:TRACE' logging.info('GST_DEBUG=%s' % os.environ['GST_DEBUG']) # Standard GStreamer initialization. Gst.init(None) logging.info(Gst.version_string()) # Create Pipeline element that will form a connection of other elements. # pipeline_description = 'videotestsrc name=src ! videoconvert ! autovideosink name=sink' # pipeline_description = 'videotestsrc name=src ! identity_py ! fakesink' # pipeline_description = 'videotestsrc name=src num-buffers=2000 ! example_python_transform_tensorflow ! identity silent=false dump=true ! autovideosink' pipeline_description = ('pravegasrc name=src ! tsdemux ! h264parse ! avdec_h264 ! videoconvert ! ' + 'example_python_transform_tensorflow ! autovideosink') logging.info('Creating pipeline: ' + pipeline_description) pipeline = Gst.parse_launch(pipeline_description) pravegasrc = pipeline.get_by_name('src') pravegasrc.set_property('controller', args.controller) pravegasrc.set_property('stream', '%s/%s' % (args.scope, args.stream)) # Create an event loop and feed GStreamer bus messages to it. loop = GLib.MainLoop() bus = pipeline.get_bus() bus.add_signal_watch() bus.connect('message', bus_call, loop) # Start play back and listen to events. logging.info('Starting pipeline') pipeline.set_state(Gst.State.PLAYING) try: loop.run() except: logging.error(traceback.format_exc()) # Cleanup GStreamer elements. pipeline.set_state(Gst.State.NULL) raise pipeline.set_state(Gst.State.NULL) logging.info('END')
def __init__(self): window = Gtk.Window(Gtk.WindowType.TOPLEVEL) window.set_title("Short-cutting the pipeline") window.set_default_size(300, -1) window.connect("destroy", Gtk.main_quit, "WM destroy") vbox = Gtk.VBox() window.add(vbox) self.button = Gtk.Button("Start") self.button.connect("clicked", self.start_stop) vbox.add(self.button) window.show_all() self.data = CustomData() # Initialize custom data structure self.data.a = 0.0 self.data.b = 1.0 self.data.c = 0.0 self.data.d = 1.0 # Create the elements self.data.app_source = Gst.ElementFactory.make("appsrc", "app_source") self.data.tee = Gst.ElementFactory.make("tee", "tee") self.data.audio_queue = Gst.ElementFactory.make("queue", "audio_queue") self.data.audio_convert1 = Gst.ElementFactory.make( "audioconvert", "audio_convert1") self.data.audio_resample = Gst.ElementFactory.make( "audioresample", "audio_resample") self.data.audio_sink = Gst.ElementFactory.make("autoaudiosink", "audio_sink") self.data.video_queue = Gst.ElementFactory.make("queue", "video_queue") self.data.audio_convert2 = Gst.ElementFactory.make( "audioconvert", "audio_convert2") self.data.visual = Gst.ElementFactory.make("wavescope", "visual") self.data.video_convert = Gst.ElementFactory.make( "videoconvert", "csp") self.data.video_sink = Gst.ElementFactory.make("glimagesink", "video_sink") self.data.app_queue = Gst.ElementFactory.make("queue", "app_queue") self.data.app_sink = Gst.ElementFactory.make("appsink", "app_sink") self.data.pipeline = Gst.Pipeline.new("test-pipeline") if not (self.data.app_source and self.data.tee and self.data.audio_queue and self.data.audio_convert1 and self.data.audio_resample and self.data.audio_sink and self.data.video_queue and self.data.audio_convert2 and self.data.visual and self.data.video_convert and self.data.video_sink and self.data.app_queue and self.data.app_sink and self.data.pipeline): print("Not all elements could be created.", file=sys.stderr) sys.exit(-1) # Configure wavescope self.data.visual.set_properties({"shader": 0, "style": 0}) # Configure appsrc audio_caps = Gst.caps_from_string(AUDIO_CAPS) self.data.app_source.set_property("caps", audio_caps) self.data.app_source.connect("need-data", self.start_feed, self.data) self.data.app_source.connect("enough-data", self.stop_feed, self.data) # Configure appsink self.data.app_sink.set_properties({ "emit-signals": True, "caps": audio_caps }) self.data.app_sink.connect("new-sample", self.new_sample, self.data) # Link all elements that can be automatically linked because they have "Always" pads [ self.data.pipeline.add(k) for k in [ self.data.app_source, self.data.tee, self.data.audio_queue, self.data.audio_convert1, self.data.audio_resample, self.data. audio_sink, self.data.video_queue, self.data.audio_convert2, self.data.visual, self.data.video_convert, self.data.video_sink, self.data.app_queue, self.data.app_sink ] ] if not (self.data.app_source.link(self.data.tee) and (self.data.audio_queue.link(self.data.audio_convert1) and self.data.audio_convert1.link(self.data.audio_resample) and self.data.audio_resample.link(self.data.audio_sink)) and (self.data.video_queue.link(self.data.audio_convert2) and self.data.audio_convert2.link(self.data.visual) and self.data.visual.link(self.data.video_convert) and self.data.video_convert.link(self.data.video_sink)) and self.data.app_queue.link(self.data.app_sink)): print("Elements could not be linked.", file=sys.stderr) sys.exit(-1) # print('data.audio_convert2.parse_context()', data.audio_convert2.parse_context()) # Manually link the Tee, which has "Request" pads tee_audio_pad = self.data.tee.get_request_pad("src_%u") print("Obtained request pad {0} for audio branch".format( tee_audio_pad.get_name())) queue_audio_pad = self.data.audio_queue.get_static_pad("sink") tee_video_pad = self.data.tee.get_request_pad("src_%u") print("Obtained request pad {0} for video branch".format( tee_video_pad.get_name())) queue_video_pad = self.data.video_queue.get_static_pad("sink") tee_app_pad = self.data.tee.get_request_pad("src_%u") print("Obtained request pad {0} for app branch".format( tee_app_pad.get_name())) queue_app_pad = self.data.app_queue.get_static_pad("sink") if (tee_audio_pad.link(queue_audio_pad) != Gst.PadLinkReturn.OK or tee_video_pad.link(queue_video_pad) != Gst.PadLinkReturn.OK or tee_app_pad.link(queue_app_pad) != Gst.PadLinkReturn.OK): print("Tee could not be linked.", file=sys.stderr) sys.exit(-1) # Instruct the bus to emit signals for each received message, and connect to the interesting signals bus = self.data.pipeline.get_bus() bus.add_signal_watch() bus.connect("message", self.bus_message) # bus.connect("message::error", self.error_cb, self.data) # bus.connect("message::eos", self.eos_cb, self.data) # Start playing the pipeline # data.pipeline.set_state(Gst.State.PLAYING) # Create a GLib Mainloop and set it to run self.data.main_loop = GLib.MainLoop() self.data.main_loop.run()
def run(self): self.mainloop = GLib.MainLoop() self.show() self.mainloop.run()
def main(): global args if os.geteuid() != 0: print('[E] No root no party. Try again with sudo.') sys.exit(1) parser = argparse.ArgumentParser() parser.add_argument('--debug', action='store_true', help='add some debug info and additional checks') parser.add_argument('--config', default='/etc/lenovo_fix.conf', help='override default config file path') args = parser.parse_args() config = load_config() power['source'] = 'BATTERY' if is_on_battery(config) else 'AC' platform_info = get_cpu_platform_info() if args.debug: for key, value in platform_info.items(): print('[D] cpu platform info: {} = {}'.format( key.replace("_", " "), value)) regs = calc_reg_values(platform_info, config) if not config.getboolean('GENERAL', 'Enabled'): return exit_event = Event() thread = Thread(target=power_thread, args=(config, regs, exit_event)) thread.daemon = True thread.start() undervolt(config) # handle dbus events for applying undervolt on resume from sleep/hybernate def handle_sleep_callback(sleeping): if not sleeping: undervolt(config) def handle_ac_callback(*args): try: power['source'] = 'BATTERY' if args[1]['Online'] == 0 else 'AC' power['method'] = 'dbus' except: power['method'] = 'polling' DBusGMainLoop(set_as_default=True) bus = dbus.SystemBus() # add dbus receiver only if undervolt is enabled in config if any( config.getfloat('UNDERVOLT', plane) != 0 for plane in VOLTAGE_PLANES): bus.add_signal_receiver(handle_sleep_callback, 'PrepareForSleep', 'org.freedesktop.login1.Manager', 'org.freedesktop.login1') bus.add_signal_receiver( handle_ac_callback, signal_name="PropertiesChanged", dbus_interface="org.freedesktop.DBus.Properties", path="/org/freedesktop/UPower/devices/line_power_AC") try: loop = GLib.MainLoop() loop.run() except (KeyboardInterrupt, SystemExit): pass exit_event.set() loop.quit() thread.join(timeout=1)
def test_add_update_settings(self): connection = { 'connection': { 'timestamp': 1441979296, 'type': 'vpn', 'id': 'a', 'uuid': '11111111-1111-1111-1111-111111111111' }, 'vpn': { 'service-type': 'org.freedesktop.NetworkManager.openvpn', 'data': dbus.Dictionary({ 'connection-type': 'tls' }, signature='ss') }, 'ipv4': { 'routes': dbus.Array([], signature='o'), 'never-default': True, 'addresses': dbus.Array([], signature='o'), 'dns': dbus.Array([], signature='o'), 'method': 'auto' }, 'ipv6': { 'addresses': dbus.Array([], signature='o'), 'ip6-privacy': 0, 'dns': dbus.Array([], signature='o'), 'never-default': True, 'routes': dbus.Array([], signature='o'), 'method': 'auto' } } connectionA = self.settings.AddConnection(connection) self.assertEqual(self.settings.ListConnections(), [connectionA]) connectionA_i = dbus.Interface( self.dbus_con.get_object(MANAGER_IFACE, connectionA), CSETTINGS_IFACE) connection['connection']['id'] = 'b' def do_update(): connectionA_i.Update(connection) caught = [] ml = GLib.MainLoop() def catch(*args, **kwargs): if (kwargs['interface'] == 'org.freedesktop.NetworkManager.Settings.Connection' and kwargs['member'] == 'Updated'): caught.append(kwargs['path']) ml.quit() self.dbus_con.add_signal_receiver(catch, interface_keyword='interface', path_keyword='path', member_keyword='member') GLib.timeout_add(200, do_update) # ensure that the loop quits even when we don't catch anything GLib.timeout_add(3000, ml.quit) ml.run() self.assertEqual(connectionA_i.GetSettings(), connection) self.assertEqual(caught, [connectionA])
def start(): loop = GLib.MainLoop() loop.run()
import dbus.service from dbus.mainloop.glib import DBusGMainLoop from gi.repository import GLib import paths from kano_peripherals.paths import CK2_PRO_HAT_OBJECT_PATH, SERVICE_API_IFACE, \ BUS_NAME as CK2_PRO_HAT_BUS_NAME def power_pressed_cb(): print 'Power button pressed' if __name__ == '__main__': DBusGMainLoop(set_as_default=True) ''' Connect to DBus signal: Bus: System Bus Name: me.kano.boards Interface: me.kano.boards.PiHat Object Path: /me/kano/boards/PiHat Signal: power_button_pressed ''' dbus.SystemBus().add_signal_receiver(power_pressed_cb, 'power_button_pressed', SERVICE_API_IFACE, CK2_PRO_HAT_BUS_NAME, CK2_PRO_HAT_OBJECT_PATH) GLib.MainLoop().run()
def __init__(self): ################ INSTANCES ################ # self.buoydetector = BuoyDetector.BuoyDetector() self.gatedetector = GateDetector.GateDetector() self.pathdetector = PathDetector.PathDetector() self.pathfollowdetector = PathFollowDetector.PathFollowDetector() self.dicedetector = DiceDetector.DiceDetector() # self.chipdetector = ChipDetector.ChipDetector() self.roulettedetector = RouletteDetector.RouletteDetector() # self.slotsdetector = SlotsDetector.SlotsDetector() # self.pingerdetector = PingerDetector.PingerDetector() # self.cashindetector = CashInDetector.CashInDetector() ################ FPS COUNTER ################ self.fps_output = 15 ################ CAMERA FRAME ################ self.current_raw_frame = None self.current_processed_frame = None ################ DICTIONARIES ################ self.tasks = { 'gate': self.gatedetector, 'path': self.pathdetector, 'path_follow': self.pathfollowdetector, 'dice': self.dicedetector, 'roulette': self.roulettedetector } # 'chip': self.chipdetector, # 'slots': self.slotsdetector, # 'pinger_b': self.pingerdetector, # 'pinger_a': self.pingerdetector, # 'cash_in': self.cashindetector # set.models = { # } self.camera_start_dictionary = { 0: self.opencv_camera_start, 1: self.sub_driver_camera_start } self.camera_detect = { 0: self.opencv_camera_detect, 1: self.sub_driver_camera_detect } ################ VIDEOCAMERA INSTANCES ################ ################ SUB CAMERA DRIVER AND OPENCV ################ ##### DO NOT CHANGE ######### self.camera_serials = {'forward': '07714031', 'down': '35710219'} # self.camera_serials = { # 'down' : '07714031', # 'forward' : '35710219' # } ############################# self.sample = {'forward': None, 'down': None} self.pipeline = {'forward': None, 'down': None} self.display_pipeline = {'forward': None, 'down': None} self.display_input = {'forward': None, 'down': None} self.display_buffers = {'forward': None, 'down': None} self.camera_callbacks = { 'forward': self.camera_forward_callback, 'down': self.camera_down_callback } self.time_delay = 1.0 self.camera_direction = 'forward' self.cap = None try: self.loop = GLib.MainLoop() self.thread = None self.sub_camera_found = 1 print '*******initialize Glib.MainLoop() successful*******' except: self.sub_camera_found = 0 print '*******unable to initialize Glib.MainLoop()*******'
def test_signals(self): '''emitting signals''' def do_emit(): self.dbus_mock.EmitSignal('', 'SigNoArgs', '', []) self.dbus_mock.EmitSignal('org.freedesktop.Test.Sub', 'SigTwoArgs', 'su', ['hello', 42]) self.dbus_mock.EmitSignal( 'org.freedesktop.Test.Sub', 'SigTypeTest', 'iuvao', [-42, 42, dbus.String('hello', variant_level=1), ['/a', '/b']]) caught = [] ml = GLib.MainLoop() def catch(*args, **kwargs): if kwargs['interface'].startswith('org.freedesktop.Test'): caught.append((args, kwargs)) if len(caught) == 3: # we caught everything there is to catch, don't wait for the # timeout ml.quit() self.dbus_con.add_signal_receiver(catch, interface_keyword='interface', path_keyword='path', member_keyword='member') GLib.timeout_add(200, do_emit) # ensure that the loop quits even when we catch fewer than 2 signals GLib.timeout_add(3000, ml.quit) ml.run() # check SigNoArgs self.assertEqual(caught[0][0], ()) self.assertEqual(caught[0][1]['member'], 'SigNoArgs') self.assertEqual(caught[0][1]['path'], '/') self.assertEqual(caught[0][1]['interface'], 'org.freedesktop.Test.Main') # check SigTwoArgs self.assertEqual(caught[1][0], ('hello', 42)) self.assertEqual(caught[1][1]['member'], 'SigTwoArgs') self.assertEqual(caught[1][1]['path'], '/') self.assertEqual(caught[1][1]['interface'], 'org.freedesktop.Test.Sub') # check data types in SigTypeTest self.assertEqual(caught[2][1]['member'], 'SigTypeTest') self.assertEqual(caught[2][1]['path'], '/') args = caught[2][0] self.assertEqual(args[0], -42) self.assertEqual(type(args[0]), dbus.Int32) self.assertEqual(args[0].variant_level, 0) self.assertEqual(args[1], 42) self.assertEqual(type(args[1]), dbus.UInt32) self.assertEqual(args[1].variant_level, 0) self.assertEqual(args[2], 'hello') self.assertEqual(type(args[2]), dbus.String) self.assertEqual(args[2].variant_level, 1) self.assertEqual(args[3], ['/a', '/b']) self.assertEqual(type(args[3]), dbus.Array) self.assertEqual(args[3].variant_level, 0) self.assertEqual(type(args[3][0]), dbus.ObjectPath) self.assertEqual(args[3][0].variant_level, 0) # check correct logging with open(self.mock_log.name) as f: log = f.read() self.assertRegex(log, '[0-9.]+ emit org.freedesktop.Test.Main.SigNoArgs\n') self.assertRegex( log, '[0-9.]+ emit org.freedesktop.Test.Sub.SigTwoArgs "hello" 42\n') self.assertRegex( log, '[0-9.]+ emit org.freedesktop.Test.Sub.SigTypeTest -42 42') self.assertRegex( log, r'[0-9.]+ emit org.freedesktop.Test.Sub.SigTypeTest -42 42 "hello" \["/a", "/b"\]\n' )
def __init__(self): self.main_loop = GLib.MainLoop()