def main():
opts = get_config()
#dbus.glib.threads_init()
#glib.theads_init()
bus_loop = DBusGMainLoop(set_as_default=True)
main_loop = glib.MainLoop()
bus = dbus.SystemBus()
bluez_proxy = bus.get_object('org.bluez', '/')
bluez_manager = dbus.Interface(bluez_proxy, 'org.bluez.Manager')
if opts.adapter is not None:
adapter = bluez_manager.FindAdapter(opts.adapter)
else:
adapter = bluez_manager.DefaultAdapter()
bd_path = '%s/dev_%s' % (adapter, opts.bdaddr.upper().replace(':', '_'))
def input_callback(*args):
# print 'INPUT: %s' % repr(args)
main_loop.quit()
return True # What return value signifies what?
glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback)
try:
bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop,
opts.reconnect)
except dbus.exceptions.DBusException as e:
return 1
print 'Press enter to close connection'
main_loop.run()
def _configure_io_handler(self, handler):
"""Register an io-handler with the glib main loop."""
if self.check_events():
return
if handler in self._unprepared_handlers:
old_fileno = self._unprepared_handlers[handler]
prepared = self._prepare_io_handler(handler)
else:
old_fileno = None
prepared = True
fileno = handler.fileno()
if old_fileno is not None and fileno != old_fileno:
tag = self._io_sources.pop(handler, None)
if tag is not None:
glib.source_remove(tag)
if not prepared:
self._unprepared_handlers[handler] = fileno
if fileno is None:
logger.debug(
" {0!r}.fileno() is None, not polling".format(handler))
return
events = 0
if handler.is_readable():
logger.debug(" {0!r} readable".format(handler))
events |= glib.IO_IN | glib.IO_ERR
if handler.is_writable():
logger.debug(" {0!r} writable".format(handler))
events |= glib.IO_OUT | glib.IO_HUP | glib.IO_ERR
if events:
logger.debug(" registering {0!r} handler fileno {1} for"
" events {2}".format(handler, fileno, events))
glib.io_add_watch(fileno, events, self._io_callback, handler)
def __init__(self):
self.__init_curses()
self.__bus = ibus.Bus()
self.__ic_path = self.__bus.create_input_context("DemoTerm")
self.__ic = ibus.InputContext(self.__bus, self.__ic_path, True)
self.__ic.set_capabilities(7)
self.__ic.connect("commit-text", self.__commit_text_cb)
self.__ic.connect("update-preedit-text", self.__update_preedit_text_cb)
self.__ic.connect("show-preedit-text", self.__show_preedit_text_cb)
self.__ic.connect("hide-preedit-text", self.__hide_preedit_text_cb)
self.__ic.connect("update-auxiliary-text", self.__update_aux_text_cb)
self.__ic.connect("show-auxiliary-text", self.__show_aux_text_cb)
self.__ic.connect("hide-auxiliary-text", self.__hide_aux_text_cb)
self.__ic.connect("update-lookup-table", self.__update_lookup_table_cb)
self.__ic.connect("show-lookup-table", self.__show_lookup_table_cb)
self.__ic.connect("hide-lookup-table", self.__hide_lookup_table_cb)
glib.io_add_watch(0, glib.IO_IN, self.__stdin_cb)
# glib.timeout_add(500, self.__timeout_cb)
# self.__master_fd, self.__slave_fd = os.openpty()
# self.__run_shell()
self.__is_invalidate = False
self.__preedit = None
self.__preedit_visible = False
self.__aux_string = None
self.__aux_string_visible = False
self.__lookup_table = None
self.__lookup_table_visible = False
def main():
opts = get_config()
#dbus.glib.threads_init()
#glib.theads_init()
bus_loop = DBusGMainLoop(set_as_default=True)
main_loop = glib.MainLoop()
bus = dbus.SystemBus()
# FIXME: BROKEN IN BLUEZ 5!!!!
adapter = fucking_bluez_devs_hate_backwards_compatibility_what_bloody_arseholes(
bus, opts.adapter)
bd_path = '%s/dev_%s' % (adapter, opts.bdaddr.upper().replace(':', '_'))
def input_callback(*args):
# print 'INPUT: %s' % repr(args)
main_loop.quit()
return True # What return value signifies what?
glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback)
try:
bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop,
opts.reconnect)
except dbus.exceptions.DBusException as e:
return 1
print 'Press enter to close connection'
main_loop.run()
# Bluez 5 now seem to require manual disconnection... probably for the best,
# but an incompatible change none the less:
bluez_net_monitor.disconnect()
def __init__(self):
self.__init_curses()
self.__bus = ibus.Bus()
self.__ic = self.__bus.create_input_context("DemoTerm")
self.__bus.set_capabilities(self.__ic, 7)
self.__bus.connect("commit-string", self.__commit_string_cb)
self.__bus.connect("update-preedit", self.__update_preedit_cb)
self.__bus.connect("show-preedit", self.__show_preedit_cb)
self.__bus.connect("hide-preedit", self.__hide_preedit_cb)
self.__bus.connect("update-aux-string", self.__update_aux_string_cb)
self.__bus.connect("show-aux-string", self.__show_aux_string_cb)
self.__bus.connect("hide-aux-string", self.__hide_aux_string_cb)
self.__bus.connect("update-lookup-table", self.__update_lookup_table_cb)
self.__bus.connect("show-lookup-table", self.__show_lookup_table_cb)
self.__bus.connect("hide-lookup-table", self.__hide_lookup_table_cb)
glib.io_add_watch(0, glib.IO_IN, self.__stdin_cb)
# glib.timeout_add(500, self.__timeout_cb)
# self.__master_fd, self.__slave_fd = os.openpty()
# self.__run_shell()
self.__is_invalidate = False
self.__preedit = ""
self.__preedit_visible = False
self.__aux_string = ""
self.__aux_string_visible = False
self.__lookup_table = None
self.__lookup_table_visible = False
def __init__(self,
device_name,
printer_class=None,
baudrate=9600,
printer=None,
delay=5):
"""
@param device_name:
@param printer_class:
@param delay:
"""
if not printer and not printer_class:
raise TypeError
gobject.GObject.__init__(self)
self._reply = ''
self._device_name = device_name
self._delay = delay
self._baudrate = baudrate
if printer_class:
port = self._create_port()
printer = printer_class(port)
else:
port = printer.get_port()
self._port = port
self.printer = printer
self._add_timeout()
if port is not None:
glib.io_add_watch(port, glib.IO_OUT, self._fd_watch_out)
glib.io_add_watch(port, glib.IO_IN, self._fd_watch_in)
def _connect_socket(address, callback):
def ready(sock, cond):
if not cond & (glib.IO_OUT | glib.IO_ERR):
return True
# Get error code
err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
if err:
# os.strerror() can't convert WinSock error codes, but the
# socket module has an undocumented mapping table
errortab = getattr(socket, 'errorTab', {})
callback(error=errortab.get(err, os.strerror(err)))
sock.close()
else:
sock.setblocking(1)
callback(sock=sock)
return False
try:
sock = socket.socket()
sock.setblocking(0)
sock.connect(address)
except socket.error, e:
# EWOULDBLOCK on Windows (actually WSAEWOULDBLOCK)
if e.errno in (errno.EINPROGRESS, errno.EWOULDBLOCK):
# IO_ERR on Windows
glib.io_add_watch(sock, glib.IO_OUT | glib.IO_ERR, ready)
else:
callback(error=str(e))
sock.close()
def start_scanner(self, widget):
self._count = 0
buf = self.text.get_buffer().set_text('')
video_dev = self.device_list['video'][self.video_combo.get_active()]
tty_dev = self.device_list['tty'][self.tty_combo.get_active()]
path = self.xml.get_widget('target_path').get_current_folder()
steps = [1, 2, 4,
8][int(self.xml.get_widget('scan-degree-combo').get_active())]
#steps = [steps]
widget.set_sensitive(False)
self.xml.get_widget('main_stop').set_sensitive(True)
frame = self.xml.get_widget('scanner-settings-frame')
frame.set_sensitive(False)
#script = 'pylatscan_cli'
#script = os.path.realpath('%s/../run_scanner.py' % os.path.dirname(__file__));
script = os.path.realpath('%s/scanner_cli.py' %
os.path.dirname(__file__))
cmd = [
'python', '-u', script,
'-s%d' % steps, '-x', '640', '-y', '480', '-t', tty_dev, '-d',
video_dev, path
]
print str.join(' ', cmd)
self.proc = sp.Popen(cmd, stdout=sp.PIPE)
glib.io_add_watch(self.proc.stdout, glib.IO_IN, self.update_status)
glib.io_add_watch(self.proc.stdout, glib.IO_HUP, self.stop_scanner)
def _connect_socket(address, callback):
def ready(sock, cond):
if not cond & (glib.IO_OUT | glib.IO_ERR):
return True
# Get error code
err = sock.getsockopt(socket.SOL_SOCKET, socket.SO_ERROR)
if err:
# os.strerror() can't convert WinSock error codes, but the
# socket module has an undocumented mapping table
errortab = getattr(socket, 'errorTab', {})
callback(error=errortab.get(err, os.strerror(err)))
sock.close()
else:
sock.setblocking(1)
callback(sock=sock)
return False
try:
sock = socket.socket()
sock.setblocking(0)
sock.connect(address)
except socket.error, e:
# EWOULDBLOCK on Windows (actually WSAEWOULDBLOCK)
if e.errno in (errno.EINPROGRESS, errno.EWOULDBLOCK):
# IO_ERR on Windows
glib.io_add_watch(sock, glib.IO_OUT | glib.IO_ERR, ready)
else:
callback(error=str(e))
sock.close()
def __init__(self, line_callback):
self.buffer = ''
self.line_callback = line_callback
flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
flags |= os.O_NONBLOCK
fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags)
glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def set_up_extraction_process(status):
"""
run process_ballot_on_input in separate Python,
asking it to extract one ballot per request and print back
the number of the processed ballot.
"""
global extraction_stdin
global extraction_stdout
global extraction_stderr
global extraction_object
global extraction_pid
try:
extraction_object = subprocess.Popen(
["/usr/bin/python", "process_ballot_on_input.py"],
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE,
close_fds = True)
extraction_pid = extraction_object.pid
(extraction_stdin,
extraction_stdout,
extraction_stderr) = (extraction_object.stdin,
extraction_object.stdout,
extraction_object.stderr)
glib.io_add_watch(extraction_object.stdout,
glib.IO_IN,
data_available_from_extraction_process, status)
glib.io_add_watch(extraction_object.stdout,
glib.IO_HUP,
extraction_process_done, status)
return extraction_pid
except Exception,e:
print e
return -1
def __init__(self, device_name, printer_class=None, baudrate=9600,
printer=None, delay=5):
"""
@param device_name:
@param printer_class:
@param delay:
"""
if not printer and not printer_class:
raise TypeError
gobject.GObject.__init__(self)
self._reply = ''
self._device_name = device_name
self._delay = delay
self._baudrate = baudrate
if printer_class:
port = self._create_port()
printer = printer_class(port)
else:
port = printer.get_port()
self._port = port
self.printer = printer
self._add_timeout()
if port is not None:
glib.io_add_watch(port, glib.IO_OUT, self._fd_watch_out)
glib.io_add_watch(port, glib.IO_IN, self._fd_watch_in)
def __init__(self, line_callback):
self.buffer = ''
self.line_callback = line_callback
flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
flags |= os.O_NONBLOCK
fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags)
glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def main():
opts = get_config()
# dbus.glib.threads_init()
# glib.theads_init()
bus_loop = DBusGMainLoop(set_as_default=True)
main_loop = glib.MainLoop()
bus = dbus.SystemBus()
# FIXME: BROKEN IN BLUEZ 5!!!!
adapter = fucking_bluez_devs_hate_backwards_compatibility_what_bloody_arseholes(bus, opts.adapter)
bd_path = "%s/dev_%s" % (adapter, opts.bdaddr.upper().replace(":", "_"))
def input_callback(*args):
# print 'INPUT: %s' % repr(args)
main_loop.quit()
return True # What return value signifies what?
glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback)
try:
bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop, opts.reconnect)
except dbus.exceptions.DBusException as e:
return 1
print "Press enter to close connection"
main_loop.run()
# Bluez 5 now seem to require manual disconnection... probably for the best,
# but an incompatible change none the less:
bluez_net_monitor.disconnect()
def start_scanner( self, widget ):
self._count = 0
buf = self.text.get_buffer().set_text('')
video_dev = self.device_list['video'][self.video_combo.get_active()]
tty_dev = self.device_list['tty'][self.tty_combo.get_active()]
path = self.xml.get_widget( 'target_path' ).get_current_folder()
steps = [1,2,4,8][int(self.xml.get_widget( 'scan-degree-combo' ).get_active())]
#steps = [steps]
widget.set_sensitive( False )
self.xml.get_widget( 'main_stop' ).set_sensitive(True)
frame = self.xml.get_widget('scanner-settings-frame')
frame.set_sensitive( False )
#script = 'pylatscan_cli'
#script = os.path.realpath('%s/../run_scanner.py' % os.path.dirname(__file__));
script = os.path.realpath( '%s/scanner_cli.py' % os.path.dirname(__file__));
cmd = ['python', '-u', script, '-s%d'%steps, '-x', '640', '-y', '480', '-t', tty_dev, '-d', video_dev, path]
print str.join( ' ', cmd )
self.proc = sp.Popen(cmd,stdout=sp.PIPE)
glib.io_add_watch(self.proc.stdout, glib.IO_IN, self.update_status)
glib.io_add_watch(self.proc.stdout, glib.IO_HUP, self.stop_scanner)
def _configure_io_handler(self, handler):
"""Register an io-handler with the glib main loop."""
if self.check_events():
return
if handler in self._unprepared_handlers:
old_fileno = self._unprepared_handlers[handler]
prepared = self._prepare_io_handler(handler)
else:
old_fileno = None
prepared = True
fileno = handler.fileno()
if old_fileno is not None and fileno != old_fileno:
tag = self._io_sources.pop(handler, None)
if tag is not None:
glib.source_remove(tag)
if not prepared:
self._unprepared_handlers[handler] = fileno
if fileno is None:
logger.debug(" {0!r}.fileno() is None, not polling"
.format(handler))
return
events = 0
if handler.is_readable():
logger.debug(" {0!r} readable".format(handler))
events |= glib.IO_IN | glib.IO_ERR
if handler.is_writable():
logger.debug(" {0!r} writable".format(handler))
events |= glib.IO_OUT | glib.IO_HUP | glib.IO_ERR
if events:
logger.debug(" registering {0!r} handler fileno {1} for"
" events {2}".format(handler, fileno, events))
glib.io_add_watch(fileno, events, self._io_callback, handler)
def main():
opts = get_config()
#dbus.glib.threads_init()
#glib.theads_init()
bus_loop = DBusGMainLoop(set_as_default = True)
main_loop = glib.MainLoop()
bus = dbus.SystemBus()
bluez_proxy = bus.get_object('org.bluez', '/')
bluez_manager = dbus.Interface(bluez_proxy, 'org.bluez.Manager')
if opts.adapter is not None:
adapter = bluez_manager.FindAdapter(opts.adapter)
else:
adapter = bluez_manager.DefaultAdapter()
bd_path = '%s/dev_%s' % (adapter, opts.bdaddr.upper().replace(':', '_'))
def input_callback(*args):
# print 'INPUT: %s' % repr(args)
main_loop.quit()
return True # What return value signifies what?
glib.io_add_watch(sys.stdin, glib.IO_IN, input_callback)
try:
bluez_net_monitor = BluezNetMonitor(bus, bd_path, main_loop, opts.reconnect)
except dbus.exceptions.DBusException as e:
return 1
print 'Press enter to close connection'
main_loop.run()
def main(): listen_sock = setup_socket() glib.io_add_watch(listen_sock.fileno(), glib.IO_IN, gui_callback, listen_sock); try: gtk.main() except: listen_sock.close()
def __init__ (self, port, obj, address = '', backlog = 5, tls = None, disconnect_cb = None):
'''Listen on a port and accept connections. Set tls to a key+certificate file to use tls.'''
self._disconnect_cb = disconnect_cb
self.group = None
self.obj = obj
self.port = ''
self.ipv6 = False
self.socket = None
self.tls = tls
self.connections = set ()
if isinstance (port, str) and '/' in port:
# Unix socket.
# TLS is ignored for these sockets.
self.tls = False
self.socket = socket.socket (socket.AF_UNIX)
self.socket.bind (port)
self.port = port
self.socket.listen (backlog)
elif have_avahi and isinstance (port, str) and '|' in port:
self._tls_init ()
self.socket = socket.socket ()
self.socket.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
if address == '':
self.socket6 = socket.socket (socket.AF_INET6)
self.socket6.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
info = port.split ('|')
self.port = port
if len (info) > 2:
self.socket.bind ((address, lookup (info[2])))
self.socket.listen (backlog)
if address == '':
p = self.socket.getsockname ()[1]
self.socket6.bind (('::1', p))
self.socket6.listen (backlog)
self.ipv6 = True
bus = dbus.SystemBus ()
server = dbus.Interface (bus.get_object (avahi.DBUS_NAME, avahi.DBUS_PATH_SERVER), avahi.DBUS_INTERFACE_SERVER)
self.group = dbus.Interface (bus.get_object (avahi.DBUS_NAME, server.EntryGroupNew ()), avahi.DBUS_INTERFACE_ENTRY_GROUP)
self.group.AddService (avahi.IF_UNSPEC, avahi.PROTO_UNSPEC, dbus.UInt32 (0), info[1], '_%s._tcp' % info[0], '', '', dbus.UInt16 (self.socket.getsockname ()[1]), '')
self.group.Commit ()
else:
self._tls_init ()
port = lookup (port)
self.socket = socket.socket ()
self.socket.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket.bind ((address, port))
self.socket.listen (backlog)
if address == '':
self.socket6 = socket.socket (socket.AF_INET6)
self.socket6.setsockopt (socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self.socket6.bind (('::1', port))
self.socket6.listen (backlog)
self.ipv6 = True
self.port = port
fd = self.socket.fileno ()
glib.io_add_watch (fd, glib.IO_IN | glib.IO_PRI, self._cb)
if self.ipv6:
fd = self.socket6.fileno ()
glib.io_add_watch (fd, glib.IO_IN | glib.IO_PRI, self._cb)
def __init__(self, ipmi_obj):
self.buffer = ""
self.seq = 0
self.ipmi_obj = ipmi_obj
flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
flags |= os.O_NONBLOCK
fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags)
glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def input_add(self, source, condition, callback):
if hasattr(source, 'fileno'):
# handle python objects
def wrapper(source, condition, real_s=source, real_cb=callback):
return real_cb(real_s, condition)
return glib.io_add_watch(source.fileno(), condition, wrapper)
else:
return glib.io_add_watch(source, condition, callback)
def __init__(self, ipmi_obj):
self.buffer = ''
self.seq = 0
self.ipmi_obj = ipmi_obj
flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
flags |= os.O_NONBLOCK
fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags)
glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def run(self):
''' RUNS THE PROCESS '''
proc = subprocess.Popen(self.command,
stdout=subprocess.PIPE) # SPAWNING
glib.io_add_watch(
proc.stdout, # FILE DESCRIPTOR
glib.IO_IN, # CONDITION
self.write_to_buffer) # CALLBACK
def main():
widget = MyDotWidget()
glib.io_add_watch(sys.stdin, # FILE DESCRIPTOR
glib.IO_IN, # CONDITION
widget.on_input_response) # CALLBACK
gtk.main()
def input_add(self, source, condition, callback):
if hasattr(source, 'fileno'):
# handle python objects
def wrapper(source, condition, real_s=source, real_cb=callback):
return real_cb(real_s, condition)
return glib.io_add_watch(source.fileno(), condition, wrapper)
else:
return glib.io_add_watch(source, condition, callback)
def consume_pty(editor, proc, master, on_finish):
console = get_console_widget(editor)
buf = console.view.get_buffer()
buf.delete(*buf.get_bounds())
unblock_fd(master)
glib.io_add_watch(master, glib.IO_IN|glib.IO_ERR|glib.IO_HUP,
consume_io, editor, console, proc, on_finish)
pty_master[0] = master
def open(m):
m.open_file()
m.expect_message = None
m.expect_next = ""
m.expect_reason = ""
m.line_buf = ""
# | glib.IO_OUT | glib.IO_PRI | glib.IO_ERR | glib.IO_HUP
glib.io_add_watch(m.at, glib.IO_IN, m.data_ready, m)
m.l = "\r"
def RegisterForUdevMonitor(self):
# have udevadm output to a pty so it will line buffer
(master, slave) = pty.openpty()
monitor = self.Popen(['udevadm', 'monitor'],
stdout=os.fdopen(slave),
bufsize=1)
glib.io_add_watch(os.fdopen(master), glib.IO_IN | glib.IO_HUP,
self.ExceptionWrapper(self.UdevOutputReceived))
def main():
widget = MyDotWidget()
glib.io_add_watch(
sys.stdin, # FILE DESCRIPTOR
glib.IO_IN, # CONDITION
widget.on_input_response) # CALLBACK
gtk.main()
def run(self):
# set up the control socket
self.server_sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.server_sock.bind(("", 8989))
self.server_sock.listen(1)
glib.io_add_watch(self.server_sock, glib.IO_IN, self.__accept_listener)
gobject.threads_init()
loop = glib.MainLoop()
loop.run()
def main(args):
global manager
global bus
global mainloop
global interactive
global n_iterations
# D-Bus initialization
DBusGMainLoop(set_as_default=True)
mainloop = gobject.MainLoop()
bus = dbus.SystemBus()
if not bus:
print("ERROR: failed to get system bus")
exit(1)
# Create the manager for handling resource sets.
manager_obj = None
# TODO: get service and manager path from command line?
try:
manager_obj = bus.get_object('org.Murphy', '/org/murphy/resource')
except:
pass
if not manager_obj:
print("ERROR: failed get Murphy resource manager object")
exit(1)
manager = dbus.Interface(manager_obj, dbus_interface='org.murphy.manager')
if (len(args) > 0 and args[0] == "fuzz"):
interactive = False
n_iterations = 1000
if (len(args) == 2):
n_iterations = int(args[1])
if (len(args) == 3):
limit = int(args[2])
glib.idle_add(fuzz_test)
else:
# interactive mode
interactive = True
manager.connect_to_signal("propertyChanged",
mgr_handler,
path_keyword='path')
# make STDIN non-blocking
fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
# listen for user input
glib.io_add_watch(sys.stdin, glib.IO_IN, stdin_cb)
add_prompt()
mainloop.run()
def open_server(self):
try:
self.sock.bind(self.sock_path)
self.sock.listen(5)
except:
error_except(msg='-server')
return False
fd=self.sock.makefile()
glib.io_add_watch(fd,glib.IO_IN|glib.IO_ERR|glib.IO_HUP,self.callback)
return True
def __init__(self, displaier, sendMess, sendShutdown):
self.buffer = ''
self.line_callback = self.commandSwitch
self.sendMess = sendMess
self.displaier = displaier
self.sendShutdown = sendShutdown
flags = fcntl.fcntl(sys.stdin.fileno(), fcntl.F_GETFL)
flags |= os.O_NONBLOCK
fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, flags)
glib.io_add_watch(sys.stdin, glib.IO_IN, self.io_callback)
def consume_output(editor, proc, on_finish):
console = get_console_widget(editor)
buf = console.view.get_buffer()
buf.delete(*buf.get_bounds())
unblock_fd(proc.stdout)
unblock_fd(proc.stderr)
glib.io_add_watch(proc.stdout, glib.IO_IN|glib.IO_ERR|glib.IO_HUP,
consume_io, editor, console, proc, on_finish)
glib.io_add_watch(proc.stderr, glib.IO_IN|glib.IO_ERR|glib.IO_HUP,
consume_io, editor, console, proc, on_finish)
def run(self):
self._findPlayer()
glib.io_add_watch(sys.stdin, glib.IO_IN, self._processStdin)
glib.io_add_watch(sys.stdin, glib.IO_HUP, self._processClose)
try:
self._loop.run()
except KeyboardInterrupt:
pass
def connect_callback(self, response):
if "CONNECT" in response:
dprint("Starting pppd")
self.pppd = subprocess.Popen(["/usr/sbin/pppd", "%s" % self.port, "defaultroute", "updetach", "usepeerdns"], bufsize=1, stdout=subprocess.PIPE)
glib.io_add_watch(self.pppd.stdout, glib.IO_IN | glib.IO_ERR | glib.IO_HUP, self.on_pppd_stdout)
glib.timeout_add(1000, self.check_pppd)
self.cleanup()
else:
self.cleanup()
raise PPPException("Bad modem response %s, expected CONNECT" % response[0])
def main(args):
global manager
global bus
global mainloop
global interactive
global n_iterations
# D-Bus initialization
DBusGMainLoop(set_as_default=True)
mainloop = gobject.MainLoop()
bus = dbus.SystemBus()
if not bus:
print("ERROR: failed to get system bus")
exit(1)
# Create the manager for handling resource sets.
manager_obj = None
# TODO: get service and manager path from command line?
try:
manager_obj = bus.get_object('org.Murphy', '/org/murphy/resource')
except:
pass
if not manager_obj:
print("ERROR: failed get Murphy resource manager object")
exit(1)
manager = dbus.Interface(manager_obj, dbus_interface='org.murphy.manager')
if (len(args) > 0 and args[0] == "fuzz"):
interactive = False
n_iterations = 1000
if (len(args) == 2):
n_iterations = int(args[1])
if (len(args) == 3):
limit = int(args[2])
glib.idle_add(fuzz_test)
else:
# interactive mode
interactive = True
manager.connect_to_signal("propertyChanged", mgr_handler, path_keyword='path')
# make STDIN non-blocking
fcntl.fcntl(sys.stdin.fileno(), fcntl.F_SETFL, os.O_NONBLOCK)
# listen for user input
glib.io_add_watch(sys.stdin, glib.IO_IN, stdin_cb)
add_prompt()
mainloop.run()
def run(self):
global read_pipe
global main_window
glib.io_add_watch(read_pipe, glib.IO_IN, self.handle_queue)
main_window = gui.MyWindow()
main_window.init(gdb)
main_window.connect("delete-event", gtk.main_quit)
main_window.show_all()
gtk.main()
def run(self):
global read_pipe
global main_window
glib.io_add_watch(read_pipe, glib.IO_IN, self.handle_queue)
main_window = gui.MyWindow()
main_window.init(gdb)
main_window.connect("delete-event", gtk.main_quit)
main_window.show_all()
gtk.main()
def start (self):
"""
Start the subprocess and begin collecting results from it.
"""
with open ("/dev/null", "r") as null:
child = subprocess.Popen ([sys.argv[0], "--subprocess", self.__player_name, self.__daemon_prefix,
self.__prefix, self.__user, self.__password] + self.__test_names,
shell = False, close_fds = True, preexec_fn = os.setsid,
stdin = null, stdout = subprocess.PIPE, env = self.__env)
glib.io_add_watch (child.stdout, glib.IO_IN | glib.IO_HUP, self.__child_io_cb)
def listener(self, source, condition, sock):
conn, addr = sock.accept()
conn.setblocking(False)
oid = id(conn)
self.__connections[oid] = conn
self.__oids[oid] = None
glib.io_add_watch(conn,
glib.IO_IN |
glib.IO_HUP,
self._data_callback,
oid)
return True
def create_peer_socket(self):
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True)
sock.bind(("", self.port))
glib.io_add_watch(sock, glib.IO_IN, self.peer_socket_event)
self.peersock = sock
# self.peeraddrs = set()
self.send_peer_announce()
def __init__ (self, test_widget_size=(640,480), trigger_set=None):
self.fail = True
label = gtk.Label("摄像头测试,成功按回车键,失败按Tab键\n")
label.modify_font(pango.FontDescription('courier new condensed 20'))
label.modify_fg(gtk.STATE_NORMAL, gdk.color_parse('light green'))
test_widget = gtk.VBox()
test_widget.modify_bg(gtk.STATE_NORMAL, gdk.color_parse('black'))
test_widget.add(label)
self.test_widget = test_widget
self.img = None
dev = v4l2.Device(DEVICE_NAME)
if not dev.cap.capabilities & v4l2.V4L2_CAP_VIDEO_CAPTURE:
raise ValueError("%s doesn't support video capture interface"
% (DEVICE_NAME, ))
if not dev.cap.capabilities & v4l2.V4L2_CAP_STREAMING:
raise ValueError("%s doesn't support streaming I/O"
% (DEVICE_NAME, ))
glib.io_add_watch(dev.fd, glib.IO_IN,
lambda *x:dev.capture_mmap_shot(self.render) or True,
priority=glib.PRIORITY_LOW)
frame_size = self.get_best_frame_size(dev, v4l2.V4L2_PIX_FMT_YUYV,
PREFERRED_WIDTH, PREFERRED_HEIGHT)
adj_fmt = dev.capture_set_format(frame_size[0], frame_size[1],
v4l2.V4L2_PIX_FMT_YUYV, v4l2.V4L2_FIELD_INTERLACED)
width, height = adj_fmt.fmt.pix.width, adj_fmt.fmt.pix.height
self.pixbuf = gdk.Pixbuf(gdk.COLORSPACE_RGB, False, 8,
width, height)
self.pixels = self.pixbuf.get_pixels_array()
self.img = gtk.image_new_from_pixbuf(self.pixbuf);
self.test_widget.add(self.img)
self.img.show()
dev.capture_mmap_prepare(PREFERRED_BUFFER_COUNT, 2)
dev.capture_mmap_start()
self.run_test_widget(
test_widget=test_widget,
test_widget_size=test_widget_size)
dev.capture_mmap_stop()
dev.capture_mmap_finish()
def create_peer_socket(self):
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True)
sock.bind(("", self.port))
glib.io_add_watch(
sock,
glib.IO_IN,
self.peer_socket_event)
self.peersock = sock
#self.peeraddrs = set()
self.send_peer_announce()
def run(self):
glib.idle_add(self.__start_cb)
glib.io_add_watch(0, glib.IO_IN, self.__stdin_cb)
glib.io_add_watch(0, glib.IO_ERR | glib.IO_HUP, self.__io_error_cb)
while True:
try:
super(IBusModeMainLoop, self).run()
except:
import traceback
print_command('error', traceback.format_exc())
else:
break
for ic in imcontexts:
if ic:
ic.destroy()
def start(self):
self.p= subprocess.Popen(self.cmdline_array,
bufsize = 0,
close_fds = True,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.STDOUT)
#(self.stdin,self.stdout,self.stderr) = (
# self.p.stdin,self.p.stdout,self.p.stderr)
self.pid = self.p.pid
self.stdout_watch_id = glib.io_add_watch(
self.p.stdout,glib.IO_IN,self.receive_stdout,self.data)
#if self.hup_cb is not None:
self.hup_watch_id = glib.io_add_watch(
self.p.stdout,glib.IO_HUP,self.receive_hup, None)
def ChannelConnected(self, channel, interface, device):
#print "Device %s channel %s up" % (device, channel)
channel = bus.get_object("org.bluez", channel)
channel = dbus.Interface(channel, "org.bluez.HealthChannel1")
fd = channel.Acquire()
#print "Got raw rd %s" % fd
# take fd ownership
fd = fd.take()
#print "FD number is %d" % fd
# encapsulate numericfd in Python socket object
sk = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
# fromfd() does dup() so we need to close the original
os.close(fd)
#print "FD acquired"
glib.io_add_watch(sk, watch_bitmap, data_received)
def run(self):
glib.idle_add(self.__start_cb)
glib.io_add_watch(0, glib.IO_IN, self.__stdin_cb)
glib.io_add_watch(0, glib.IO_ERR | glib.IO_HUP, self.__io_error_cb)
while True:
try:
super(IBusModeMainLoop, self).run()
except:
import traceback
print_command('error', traceback.format_exc())
else:
break
for ic in imcontexts:
if ic:
ic.destroy()
def ChannelConnected(self, channel, interface, device):
#print "Device %s channel %s up" % (device, channel)
channel = bus.get_object("org.bluez", channel)
channel = dbus.Interface(channel, "org.bluez.HealthChannel1")
fd = channel.Acquire()
#print "Got raw rd %s" % fd
# take fd ownership
fd = fd.take()
#print "FD number is %d" % fd
# encapsulate numericfd in Python socket object
sk = socket.fromfd(fd, socket.AF_UNIX, socket.SOCK_STREAM)
# fromfd() does dup() so we need to close the original
os.close(fd)
#print "FD acquired"
glib.io_add_watch(sk, watch_bitmap, data_received)
def start_processing( self ):
script = os.path.realpath( '%s/parser_cli.py' % os.path.dirname(__file__));
do_left = self.xml.get_widget('radiobutton_scan_left').get_active()
do_right = self.xml.get_widget('radiobutton_scan_right').get_active()
do_both = self.xml.get_widget('radiobutton_scan_both').get_active()
#print "left, right, both?", do_left, do_right, do_both
filename = self.xml.get_widget( "entry_output_file").get_text()
basepath = self.xml.get_widget( 'fileselect_target_path' ).get_current_folder()
path = "%s%s%s.wrl" % ( basepath, os.sep, self.safe_filename(filename,basepath) )
left, top, width, height = [str(int(i)) for i in self.roi]
cmd = [
'python',
'-u', script,
'-x', left,
'-y', top,
'-w', width,
'-g', height,
'-f', path,
self.xml.get_widget( 'fileselect_source_path' ).get_current_folder()
]
if do_both:
#print "do both"
cmd.extend(['-l','-r'])
elif do_left:
#print "do left"
cmd.append('-r')
elif do_right:
#print "do right"
cmd.append('-l')
#
#print str.join( ' ', cmd )
self.current_safe_path = path
self.set_status_bar( str.join( ' ', cmd ) )
self.proc = sp.Popen(cmd,stdout=sp.PIPE)
self.events.append(glib.io_add_watch(self.proc.stdout, glib.IO_IN, self.status_processing))
self.events.append(glib.io_add_watch(self.proc.stdout, glib.IO_HUP, self.stop_processing))
def start(self):
self.p= subprocess.Popen(self.cmdline_array,
bufsize = 0,
stdin=subprocess.PIPE,
stdout=subprocess.PIPE,
stderr=subprocess.PIPE)
(self.stdin,self.stdout,self.stderr) = (
self.p.stdin,self.p.stdout,self.p.stderr)
self.pid = self.p.pid
self.stdout_watch_id = glib.io_add_watch(
self.p.stdout,glib.IO_IN,self.receive_stdout,self.data)
self.stderr_watch_id = glib.io_add_watch(
self.p.stderr,glib.IO_IN,self.receive_stderr,self.data)
#if self.hup_cb is not None:
self.hup_watch_id = glib.io_add_watch(
self.p.stdout,glib.IO_HUP,self.receive_hup, None)
def initialize(self):
# Prepare environment for local controllers
LocalController.setup_environment()
http_server = HttpServer(self._options, self)
host = self._options['http_host']
port = self._options['http_port']
self._http = Thread(target=http_server.run,
kwargs={"host": host, "port": port, "threaded": True})
# The http server should exit when the main thread terminates
self._http.daemon = True
self._http.start()
self._listen = socket.socket()
self._listen.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1)
self._listen.bind((self._options['host'], self._options['port']))
self._listen.listen(16)
self._listen.setblocking(0)
self._listen_source = glib.io_add_watch(self._listen, glib.IO_IN,
self._accept)
# Start garbage collection
self._gc_timer = glib.timeout_add_seconds(self._options['gc_interval'],
self._gc)
self.running = True
def __init__(self): #Creates a new instance of gtp with which to interface with GnuGo
args = shlex.split("/usr/games/gnugo --mode gtp")
self.proc = subprocess.Popen(args, stdin=subprocess.PIPE,
stdout=subprocess.PIPE)
(self.infile, self.outfile) = (self.proc.stdin, self.proc.stdout)
self.watch = glib.io_add_watch(self.outfile,glib.IO_IN, self.__gnugo_write_callback)
self.waiting = False
def _update(self):
if self._sock is None:
return
if (self._send_closing and not self._send_closed
and not self._send_buf):
try:
self._sock.shutdown(socket.SHUT_WR)
except socket.error:
pass
self._send_closed = True
if self._send_close_timeout_source is not None:
glib.source_remove(self._send_close_timeout_source)
self._send_close_timeout_source = None
if self._send_closed and self._recv_closed:
if self._source is not None:
glib.source_remove(self._source)
self._source = None
self._sock.close()
self._sock = None
self.emit('close')
return
cond = 0
if self._recv_callback is not None and not self._recv_closed:
cond |= glib.IO_IN
if self._send_buf and not self._send_closed:
cond |= glib.IO_OUT
if self._source is not None:
glib.source_remove(self._source)
self._source = glib.io_add_watch(self._sock, cond, self._io_ready)
def start(self):
# Start server
try:
uri = self.notebookcombobox.get_notebook()
if uri:
notebook, x = build_notebook(NotebookInfo(uri))
if not notebook:
return
else:
return
port = int(self.portentry.get_value())
public = self.public_checkbox.get_active()
self.httpd = make_server(notebook, port, public,
**self.interface_opts)
if sys.platform == 'win32':
# glib io watch conflicts with socket use on windows..
# idle handler uses a bit to much CPU for my taste,
# timeout every 0.5 sec is better
self.httpd.timeout = 0.1 # 100 ms
self._source_id = glib.timeout_add(500, self.do_serve_on_poll)
else:
self.httpd.timeout = 3 # if no response after 3 sec, drop it
self._source_id = glib.io_add_watch(
self.httpd.fileno(),
glib.IO_IN | glib.IO_OUT | glib.IO_ERR | glib.IO_HUP
| glib.IO_PRI, # any event..
self.do_serve_on_io)
logger.info("Serving HTTP on %s port %i...",
self.httpd.server_name, self.httpd.server_port)
except Exception, error:
ErrorDialog(self, error).run()
return
def enabled(self, value):
if value and self.event_source is None:
# pylint: disable=attribute-defined-outside-init
self.event_source = glib.io_add_watch(self.monitor, glib.IO_IN,
self._process_udev_event)
elif not value and self.event_source is not None:
glib.source_remove(self.event_source)
def set_close_callback(self, callback):
if self.__close_id:
glib.source_remove(self.__close_id)
self.__close_callback = callback
self.__close_id = glib.io_add_watch(self.__socket,
glib.IO_HUP|glib.IO_ERR,
self.__on_close_callback)
