def run(self):
logger.info("Initializing skynetd")
# Using Dbus-python's default mainloop to listen to the events
DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
# creating a salt caller object, this is used to push events using
# salt's eventing framework
caller = salt.client.Caller()
cb = callback.Callback(caller)
# this initializes/updates the interested signals
# (read from config file) to be listened by the bus
update_listener(cb, bus)
loop = glib.MainLoop()
glib.threads_init()
# create a thread to run the main loop which will listen to the dbus
# and push the events to salt-master
t = threading.Thread(target=mainSource, args=(loop,))
t.start()
# this will continue and listen to external signals (sighup,sigterm)
# if sighup, the signals to be listened is reread from the config file
# if sigterm, the daemon will be terminated
logger.info("Started skynetd to listen for external signals")
while RUN:
signalHandler(loop, cb, bus)
logger.info("Terminated skynetd")
def run(self):
# Using Dbus-python's default mainloop to listen to the events
DBusGMainLoop(set_as_default=True)
bus = dbus.SystemBus()
# creating a salt caller object, this is used to push events using
# salt's eventing framework
caller = salt.client.Caller()
cb = callBack.CallBack(caller)
# this initializes/updates the interested signals
# (read from config file) to be listened brom the bus
update_listener(cb, bus)
loop = glib.MainLoop()
glib.threads_init()
# create a thread to run the main loop which will listen to the dbus
# and push the events to salt-master
t = threading.Thread(target=mainSource, args=(loop, ))
t.start()
# this will continue and listent to external signals (sighup,sigterm)
# if sighup, the signals to be listened is reread from the config file
# if sigterm, the daemon will be terminated
while RUN:
signalHandler(loop, cb, bus)
def verify_display_ready(xvfb, display_name, shadowing):
from xpra.log import Logger
log = Logger("server")
from xpra.x11.bindings.wait_for_x_server import wait_for_x_server #@UnresolvedImport
# Whether we spawned our server or not, it is now running -- or at least
# starting. First wait for it to start up:
try:
wait_for_x_server(display_name, 3) # 3s timeout
except Exception as e:
sys.stderr.write("%s\n" % e)
return None
# Now we can safely load gtk and connect:
assert "gtk" not in sys.modules
import gtk.gdk #@Reimport
try:
import glib
glib.threads_init()
except:
#old versions do not have this method
pass
display = gtk.gdk.Display(display_name)
manager = gtk.gdk.display_manager_get()
default_display = manager.get_default_display()
if default_display is not None:
default_display.close()
manager.set_default_display(display)
if not shadowing and not check_xvfb_process(xvfb):
#if we're here, there is an X11 server, but it isn't the one we started!
log.error("There is an X11 server already running on display %s:" % display_name)
log.error("You may want to use:")
log.error(" 'xpra upgrade %s' if an instance of xpra is still connected to it" % display_name)
log.error(" 'xpra --use-display start %s' to connect xpra to an existing X11 server only" % display_name)
log.error("")
return None
return display
def get_connman_provider():
"""Get an instance of ConnmanProvider"""
glib.threads_init()
dbus.mainloop.glib.threads_init()
DBusGMainLoop(set_as_default=True)
return ConnmanProvider()
def get_networkmanager_provider():
"""Get an instance of NetworkManagerProvider"""
glib.threads_init()
dbus.mainloop.glib.threads_init()
DBusGMainLoop(set_as_default=True)
return NetworkManagerProvider()
def get_connman_provider():
"""Get an instance of ConnmanProvider"""
glib.threads_init()
dbus.mainloop.glib.threads_init()
DBusGMainLoop(set_as_default=True)
return ConnmanProvider()
def get_networkmanager_provider():
"""Get an instance of NetworkManagerProvider"""
glib.threads_init()
dbus.mainloop.glib.threads_init()
DBusGMainLoop(set_as_default=True)
return NetworkManagerProvider()
def main():
keylog_path = parse_args()
if not isfile(keylog_path):
with open(keylog_path, "w") as keylog_file:
b = [
u"pressed",
u"keycode",
u"keysym",
u"symbol",
u"repr",
u"repeated",
u"mods_mask"]
print("%7s %7s %6s %16s %9s %8s %15s" % tuple(b))
keylog_file = keylog_file.write('\t'.join(b) + u'\n')
def callback(data):
values = {}
for k in dir(data):
if k[0] == '_':
continue
values[k] = getattr(data, k)
# print k, values[k]
if not values[u"filtered"]:
#values[u"mods_mask"] = bin(values[u"mods_mask"])[2:]
values[u"pressed"] = int(values[u"pressed"])
values[u"repeated"] = int(values[u"repeated"])
if values[u"string"] == "'":
values[u"string"] = '\'\\\'\'' # repr of ' with ' string, not " as usual to make all strings in one format
else:
values[u"string"] = repr(values[u"string"])
values[u"symbol"] = values["symbol"].decode("utf-8")
b = [str(values[k]) for k in [u"pressed", u"keycod", u"keysym", u"symbol", u"string", u"repeated", u"mods_mask"]]
print("%7s %7s %6s %16s %9s %8s %15s" % tuple(b))
with open(keylog_path, "a") as keylog_file:
keylog_file.write('\t'.join(b) + u'\n')
glib.threads_init()
kl = InputListener(callback)
try:
# keep running only while the listener is alive
kl.start()
while kl.is_alive():
glib.main_context_default().iteration()
except KeyboardInterrupt:
pass
# check if the thread terminated unexpectedly
if kl.is_alive():
kl.stop()
kl.join()
elif kl.error:
print("initialization error: {}".format(kl.error))
if '__traceback__' in dir(kl.error):
import traceback
traceback.print_tb(kl.error.__traceback__)
exit(1)
def main(argv):
try:
if ('DISPLAY' in os.environ):
glib.threads_init()
s = SessaoMultiseat()
s.inicializa()
else:
s = SessaoMultiseat()
s.inicializaWM()
args = ['xinit', os.path.realpath(__file__), 'vt7']
subprocess.Popen(args)
except:
logging.exception('')
def verify_gdk_display(display_name):
# Now we can safely load gtk and connect:
no_gtk()
import gtk.gdk #@Reimport
import glib
glib.threads_init()
display = gtk.gdk.Display(display_name)
manager = gtk.gdk.display_manager_get()
default_display = manager.get_default_display()
if default_display is not None and default_display != display:
default_display.close()
manager.set_default_display(display)
return display
def initTask(self):
super(DBusMainLoopTask, self).initTask()
needed = getattr(self.service, 'REQUIRE_DBUS', False)
for t in self.service.tasks:
if isinstance(t, DBusTask):
needed = True
if not needed:
raise SkipTask("No DBusTasks found or enabled")
self.dbus_loop = DBusGMainLoop(set_as_default=True)
glib.threads_init()
gobject.threads_init()
dbus.mainloop.glib.threads_init()
self.mainloop = gobject.MainLoop()
def run(self):
import glib
try:
glib.threads_init()
except AttributeError:
#old versions of glib may not have this method
pass
try:
gobject.threads_init()
except AttributeError:
#old versions of gobject may not have this method
pass
self.glib_mainloop = glib.MainLoop()
self.glib_mainloop.run()
return self.exit_code
def run(self):
import glib
try:
glib.threads_init()
except AttributeError:
#old versions of glib may not have this method
pass
try:
gobject.threads_init()
except AttributeError:
#old versions of gobject may not have this method
pass
self.glib_mainloop = glib.MainLoop()
self.glib_mainloop.run()
return self.exit_code
def initTask(self):
super(DBusMainLoopTask, self).initTask()
needed = getattr(self.service, 'REQUIRE_DBUS', False)
for t in self.service.tasks:
if isinstance(t, DBusTask):
needed = True
if not needed:
raise SkipTask("No DBusTasks found or enabled")
self.dbus_loop = DBusGMainLoop(set_as_default=True)
glib.threads_init()
gobject.threads_init()
dbus.mainloop.glib.threads_init()
self.mainloop = gobject.MainLoop()
def LaunchUI(view):
window = gtk.Window()
window.add(view)
window.connect('destroy', destroy)
window.set_title("GTK async test")
window.show_all()
gtk.gdk.threads_init()
glib.threads_init()
with gtk.gdk.lock:
gtk.main()
def init(withgtk=True):
"""Shared metarace program initialisation."""
# Check for data path and change working directory
mk_data_path()
os.chdir(DATA_PATH)
# Set global logging options
logging._srcfile = None
logging.logThreads = 0
logging.logProcesses = 0
# read in system configuration - errors here print to stderr, but
# are not necessarily fatal.
conffile = default_file(SYSCONF_FILE)
try:
if os.path.exists(conffile):
with open(conffile, 'rb') as f:
sysconf.read(f)
except Exception as e:
print(u'Error reading system config from ' + repr(conffile) + ': ' +
repr(e))
# Do GTK init unless disabled
if withgtk:
# Initialise threading in glib
try:
glib.threads_init()
except:
gobject.threads_init()
# Initialise threading in GDK
gtk.gdk.threads_init()
# Try some window methods, but don't worry if they fail
try:
# fix the gnome menubar accelerator mapping
mset = gtk.settings_get_default()
mset.set_string_property('gtk-menu-bar-accel', 'F24', 'override')
gtk.window_set_default_icon_from_file(default_file(LOGO_FILE))
except:
pass # but ignore errors
def verify_display_ready(xvfb, display_name, shadowing):
from xpra.log import Logger
log = Logger("server")
from xpra.x11.bindings.wait_for_x_server import wait_for_x_server #@UnresolvedImport
# Whether we spawned our server or not, it is now running -- or at least
# starting. First wait for it to start up:
try:
wait_for_x_server(display_name, 3) # 3s timeout
except Exception as e:
sys.stderr.write("%s\n" % e)
return None
# Now we can safely load gtk and connect:
no_gtk()
import gtk.gdk #@Reimport
try:
import glib
glib.threads_init()
except:
#old versions do not have this method
pass
display = gtk.gdk.Display(display_name)
manager = gtk.gdk.display_manager_get()
default_display = manager.get_default_display()
if default_display is not None:
default_display.close()
manager.set_default_display(display)
if not shadowing and not check_xvfb_process(xvfb):
#if we're here, there is an X11 server, but it isn't the one we started!
log.error("There is an X11 server already running on display %s:" %
display_name)
log.error("You may want to use:")
log.error(
" 'xpra upgrade %s' if an instance of xpra is still connected to it"
% display_name)
log.error(
" 'xpra --use-display start %s' to connect xpra to an existing X11 server only"
% display_name)
log.error("")
return None
return display
# Galicaster, Multistream Recorder and Player # # galicaster/core/core # # Copyright (c) 2011, Teltek Video Research <*****@*****.**> # # This work is licensed under the Creative Commons Attribution- # NonCommercial-ShareAlike 3.0 Unported License. To view a copy of # this license, visit http://creativecommons.org/licenses/by-nc-sa/3.0/ # or send a letter to Creative Commons, 171 Second Street, Suite 300, # San Francisco, California, 94105, USA. import glib import gtk glib.threads_init() gtk.gdk.threads_init() import os from galicaster import __version__ from galicaster.core import context from galicaster import plugins from galicaster.utils.dbusservice import DBusService from galicaster.classui.recorderui import RecorderClassUI from galicaster.classui.listing import ListingClassUI from galicaster.classui.playerui import PlayerClassUI from galicaster.classui.distrib import DistribUI logger = context.get_logger()
# Copyright(c) 2010-2012: Pablo Seminario <*****@*****.**>
# Copyright(c) 2015-2016: wave++ "Yuri D'Elia" <*****@*****.**>.
from __future__ import print_function, unicode_literals, division
from . import *
from .labelmanager import LabelManager
from threading import Timer
import json
import os
import subprocess
import glib
glib.threads_init()
import pygtk
pygtk.require('2.0')
import gtk
import pango
class Screenkey(gtk.Window):
STATE_FILE = os.path.join(glib.get_user_config_dir(), 'screenkey.json')
def __init__(self, logger, options, show_settings=False):
gtk.Window.__init__(self, gtk.WINDOW_POPUP)
def run(self):
glib.threads_init()
gobject.threads_init()
self.glib_mainloop = glib.MainLoop()
self.glib_mainloop.run()
def run():
glib.threads_init()
gtk.main()
def import_glib2():
import glib #@UnresolvedImport
glib.threads_init()
return glib
def run(self):
import glib
glib.threads_init()
gobject.threads_init()
self.glib_mainloop = glib.MainLoop()
self.glib_mainloop.run()
