def start_session(self, host, port, session, username, password, wait): """ Start a session using x2go """ # Start in the background and attach a watch for when it exits cmd = [os.path.join(softwarecenter.paths.datadir, softwarecenter.paths.X2GO_HELPER)] (self.helper_pid, stdin, stdout, stderr) = GObject.spawn_async( cmd, standard_input=True, standard_output=True, standard_error=True, flags=GObject.SPAWN_DO_NOT_REAP_CHILD) self.helper_stdin = os.fdopen(stdin, "w") self.helper_stdout = os.fdopen(stdout) self.helper_stderr = os.fdopen(stderr) # Add a watch for when the process exits GObject.child_watch_add(self.helper_pid, self._on_x2go_exit) # Add a watch on stdout GObject.io_add_watch(self.helper_stdout, GObject.IO_IN, self._on_x2go_activity) # Start the connection self.state = "connecting" self.helper_stdin.write( "CONNECT: \"%s\" \"%s\" \"%s\" \"%s\" \"%s\"\n" % (host, port, username, password, session)) self.helper_stdin.flush()
def run(): """ Run the UI. """ global loop loop = gobject.MainLoop() ui.set_mouse_tracking() app = appGUI() # Connect signals and whatnot to UI screen control functions bus.add_signal_receiver(app.dbus_scan_finished, 'SendEndScanSignal', 'org.wicd.daemon.wireless') bus.add_signal_receiver(app.dbus_scan_started, 'SendStartScanSignal', 'org.wicd.daemon.wireless') # I've left this commented out many times. bus.add_signal_receiver(app.update_netlist, 'StatusChanged', 'org.wicd.daemon') # Update the connection status on the bottom every 2 s. gobject.timeout_add(2000, app.update_status) # Get input file descriptors and add callbacks to the ui-updating function fds = ui.get_input_descriptors() for fd in fds: gobject.io_add_watch(fd, gobject.IO_IN, app.call_update_ui) app.update_ui() loop.run()
def notify_read(self, func): """ This function can be called when the callsite must know when data is coming from the serial port. It is necessary that a gobject main loop is already running before calling this method. """ GObject.io_add_watch(self.get_port().fd, GObject.IO_IN, lambda fd, cond: func(self, cond))
def listen_to_port(self): self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.socket.bind((config.host, config.port)) self.socket.setblocking(0) self.socket.listen(5) conds = GObject.IO_IN | GObject.IO_ERR | GObject.IO_HUP GObject.io_add_watch(self.socket, conds, self.socket_callback)
def got_input(source, data, *port): '''Asynchronous connection listener. Starts a handler for each connection.''' conn, temp = source.accept() print( "mpdserver connected from " + str(conn.getsockname())) GObject.io_add_watch(conn, GObject.IO_IN, handle_input) conn.send('OK MPD 0.16.0\n') return True
def __init__(self, cmd, resultHandler, prio=GObject.PRIORITY_LOW): self.lineSplitter = LineSplitter(resultHandler) #print("executing command: %s" % cmd) self.proc = subprocess.Popen(cmd, stdout=subprocess.PIPE, close_fds=True) self.pipe = self.proc.stdout # make pipe non-blocking: fl = fcntl.fcntl(self.pipe, fcntl.F_GETFL) fcntl.fcntl(self.pipe, fcntl.F_SETFL, fl | os.O_NONBLOCK) #print "(add watch)" if GObject.pygobject_version < (3, 7, 2): GObject.io_add_watch(self.pipe, GObject.IO_IN | GObject.IO_ERR | GObject.IO_HUP, self.onPipeReadable, priority=prio) else: # avoid deprecation warning in newer versions of PyGObject: GLib.io_add_watch(self.pipe, prio, GLib.IO_IN | GLib.IO_ERR | GLib.IO_HUP, self.onPipeReadable)
def serial_write(self, data): l = len(self.serial_write_pending_) self.serial_write_pending_ += data if l == 0 and len(self.serial_write_pending_) > 0: dev = self.serial_device_ GObject.io_add_watch(dev.fileno(), GObject.IO_OUT, self.on_serial_data_write, dev)
def start_listening(handler): '''Start listening to socket or named pipe for new commandline calls. Also sets current process to be the main process. @param handler: the method to call when new commands are recieveds ''' set_in_main_process(True) logger.debug('Start listening on: %s', SERVER_ADDRESS) try: if SERVER_ADDRESS_FAMILY == 'AF_UNIX' \ and os.path.exists(SERVER_ADDRESS): # Clean up old socket (someone should already have checked # before whether or not it is functional) os.unlink(SERVER_ADDRESS) listener = Listener(SERVER_ADDRESS, SERVER_ADDRESS_FAMILY) except: logger.exception('Error setting up Listener') return False else: socket = _get_socket_for_listener(listener) if socket is not None: # Unix file descriptor GObject.io_add_watch(socket.fileno(), GObject.IO_IN, partial(_do_accept, listener, handler)) else: # Win32 pipe t = threading.Thread(target=_listener_thread_main, args=(listener, handler)) t.daemon = True t.start() return True
def __init__(self, bus, index, service, queue): Characteristic.__init__(self, bus, index, UART_TX_CHARACTERISTIC_UUID, ['notify'], service) self.notifying = False self.queue = queue GObject.io_add_watch(self.queue._reader, GObject.IO_IN, self.on_console_input)
def enterNonblockingMode(): global conn, log log.debug('entering nonblocking-mode') conn.setblocking(False) GObject.io_add_watch(conn, GObject.IO_IN, on_data, ['']) GObject.idle_add(on_loop)
def run(self): """Launch the clipboard manager daemon. Listen for clipboard events & client socket connections.""" # Set up socket, pid file etc self.prepare_files() # We need to get the display instance from the window # for use in obtaining mouse state. # POPUP windows can do this without having to first show the window self.window = Gtk.Window(type=Gtk.WindowType.POPUP) # Handle clipboard changes self.c_id = self.clipboard.connect('owner-change', self.owner_change) # Handle socket connections GObject.io_add_watch(self.sock, GObject.IO_IN, self.socket_accept) # Handle unix signals GLib.unix_signal_add(GLib.PRIORITY_HIGH, signal.SIGINT, self.exit) GLib.unix_signal_add(GLib.PRIORITY_HIGH, signal.SIGTERM, self.exit) GLib.unix_signal_add(GLib.PRIORITY_HIGH, signal.SIGHUP, self.exit) GLib.unix_signal_add(GLib.PRIORITY_DEFAULT, signal.SIGUSR1, self.fdbquery.signal_handler) # Timeout for flushing history to disk # Do nothing if timeout is 0, or write_on_change is set in config history_timeout = self.config.getint('clipster', 'history_update_interval') if history_timeout and not self.config.getboolean( 'clipster', 'write_on_change'): logging.debug("Writing history file every %s seconds", history_timeout) GObject.timeout_add_seconds(history_timeout, self.write_history_file) Gtk.main()
def __init__(self, maxConcurrentThreads=10): ThreadManager.__init__(self, maxConcurrentThreads) # watch the queue for updates _fd = self.queue_in._reader.fileno() GObject.io_add_watch(_fd, GObject.IO_IN, self._on_cb)
def run(self): signal.signal(signal.SIGTERM, self.shutdown) if self.proc_title: setproctitle.setproctitle(self.proc_title) dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) signals = ( ('NewPlaybackStream', 'org.PulseAudio.Core1.{}', self.on_new_playback_stream), ('PlaybackStreamRemoved', 'org.PulseAudio.Core1.{}', self.on_playback_stream_removed), ('FallbackSinkUpdated', 'org.PulseAudio.Core1.{}', self.on_fallback_sink_updated), ('DeviceUpdated', 'org.PulseAudio.Core1.Stream.{}', self.on_device_updated), ) self._connect(signals) self.update() self.default_sink = self.fallback_sink self.thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1) mainloop = GObject.MainLoop() GObject.io_add_watch( self.pulse_queue._reader, GObject.IO_IN | GObject.IO_PRI, self._on_new_message) try: mainloop.run() except KeyboardInterrupt: self.shutdown()
def __init__(self, bus, index, service): Characteristic.__init__(self, bus, index, UART_TX_CHARACTERISTIC_UUID, ['notify'], service) self.notifying = False # GObject.io_add_watch(sys.stdin, GObject.IO_IN, self.on_console_input) # Sposto il watcher sul Character Device Driver GObject.io_add_watch(dev_tx, GObject.IO_IN, self.on_cdev_input)
def run(self): signal.signal(signal.SIGTERM, self.shutdown) if self.proc_title: setproctitle.setproctitle(self.proc_title) dbus.mainloop.glib.DBusGMainLoop(set_as_default=True) signals = ( ('NewPlaybackStream', 'org.PulseAudio.Core1.{}', self.on_new_playback_stream), ('PlaybackStreamRemoved', 'org.PulseAudio.Core1.{}', self.on_playback_stream_removed), ('FallbackSinkUpdated', 'org.PulseAudio.Core1.{}', self.on_fallback_sink_updated), ('DeviceUpdated', 'org.PulseAudio.Core1.Stream.{}', self.on_device_updated), ) self._connect(signals) self.update() self.default_sink = self.fallback_sink self.thread_pool = concurrent.futures.ThreadPoolExecutor(max_workers=1) mainloop = GObject.MainLoop() GObject.io_add_watch(self.pulse_queue._reader, GObject.IO_IN | GObject.IO_PRI, self._on_new_message) try: mainloop.run() except KeyboardInterrupt: self.shutdown()
def __init__(self, server_address, RequestHandlerClass): SocketServer.TCPServer.__init__(self, server_address, RequestHandlerClass) self.socket.setblocking(0) # Set nonblocking # Watch the listener socket for data GObject.io_add_watch(self.socket, GObject.IO_IN, self._handle_accept)
def run(self, line=1, column=1): dirname = os.path.dirname(self.filename) filename = os.path.basename(self.filename) self.ret = None try: self.pipe = subprocess.Popen( ['cdn-context', filename, '-l', str(line), '-c', str(column)], cwd=dirname, stdout=subprocess.PIPE) except Exception as (e): sys.stderr.write('Failed to execute cdn-context: %s\n' % (e, )) self.pipe = None return False self.read_buffer = '' flags = fcntl.fcntl(self.pipe.stdout.fileno(), fcntl.F_GETFL) | os.O_NONBLOCK fcntl.fcntl(self.pipe.stdout.fileno(), fcntl.F_SETFL, flags) GObject.io_add_watch(self.pipe.stdout, GObject.IO_IN | GObject.IO_HUP, self.on_output) GObject.child_watch_add(self.pipe.pid, self.on_parser_end)
def listener(self, sock, *args): '''Asynchronous connection listener. Starts a handler for each connection.''' self.conn, temp = sock.accept() loggy.log( "mpdserver connected from " + str(self.conn.getsockname())) GObject.io_add_watch(self.conn, GObject.IO_IN, self.handler) self.conn.send('OK MPD 0.16.0\n') return True
def register(controller=None): # The BrailleInput event has a 'cursor' parameter, which is the # cursor position, available through the request/cursor TALES # expression controller.register_event('BrailleInput', _("Input from the braille table.")) method=controller.message_log if brlapi is None: controller.log(_("BrlTTY not installed. There will be no braille support.")) else: engine=BrlEngine(controller) try: engine.init_brlapi() if engine.brlconnection is not None: GObject.io_add_watch(engine.brlconnection.fileDescriptor, GObject.IO_IN, engine.input_handler) method=engine.action_brldisplay engine.brldisplay("Advene connected") except: controller.log(_("Could not initialize BrlTTY. No braille support.")) # Register the Braille action even if the API is not available. controller.register_action(RegisteredAction( name="Braille", method=method, description=_("Display a message in Braille"), parameters={'message': _("Message to display.")}, defaults={'message': 'annotation/content/data'}, predefined={'message': ( ( 'annotation/content/data', _("The annotation content") ), )}, category='external', ))
def run(): mask = None opts, args = getopt.getopt(sys.argv[1:], "hdWk:") for opt in opts: if opt[0] == '-h': print('Snaptile.py') print('-W use Windows key') print('-h this help text') sys.exit() elif opt[0] == '-d': isDualMonitor = True elif opt[0] == '-W': mask = 'Windows' global disp, root, lastkey_state, posmap, posmapLeft disp, root, lastkey_state, posmap = global_inital_states() initkey0(disp, root) initkeys(keymap, disp, root) for _ in range(0, root.display.pending_events()): root.display.next_event() GObject.io_add_watch(root.display, GObject.IO_IN, checkevt) print('Snaptile running. Press CTRL+C to quit.') signal.signal(signal.SIGINT, signal.SIG_DFL) Gtk.main()
def _schedule_write(self, conn, message): queue = self.currentConnections[conn] self.log.debug('re-starting on_write[%u] scheduling', conn.fileno()) GObject.io_add_watch(conn, GObject.IO_OUT, self.on_write) queue.put(message)
def run(): mask = None opts, args = getopt.getopt(sys.argv, "hdW") for opt in args: if opt == '-h': print ('Snaptile.py') print ('-d expanded dual-monitor keybinds') print ('-W use Windows key') print ('-h this help text') sys.exit() elif opt == '-d': global keymap; keymap = [ ['Q', 'W', 'E', 'R', 'T', 'Y', 'U', 'I'], ['A', 'S', 'D', 'F', 'G', 'H', 'J', 'K'], ['Z', 'X', 'C', 'V', 'B', 'N', 'M', 'comma'] ] elif opt == '-W': mask = 'Windows' global disp, root, lastkey_state, posmap disp, root, lastkey_state, posmap = global_inital_states() initkeys(keymap, disp, root, mask) for _ in range(0, root.display.pending_events()): root.display.next_event() GObject.io_add_watch(root.display, GObject.IO_IN, checkevt) print('Snaptile running. Press CTRL+C to quit.') signal.signal(signal.SIGINT, signal.SIG_DFL) Gtk.main()
def __init__(self, sock, addr, clients, pinfo_msg, msg_handler_fn, c_type): self.__sock = sock self.__addr = addr self.__clients = clients self.__pinfo_msg = pinfo_msg self.__msg_handler_fn = msg_handler_fn self.__conn_type = c_type # client info self.info = ClientInfo() self.__psave = False # the following fields are used for iterative receiving on message data # see io_recv() and io_recv_buff() self.__rcv_buff_header = ReceiveBuffer() self.__rcv_buff_data = ReceiveBuffer() self.__rcv_msg_id = message.IGNORE self.__rcv_msg_size = 0 self.__snd_buff = b'' # buffer for outgoing data # source IDs for various events self.__sids = [ GObject.io_add_watch(self.__sock, GObject.IO_IN, self.__io_recv), GObject.io_add_watch(self.__sock, GObject.IO_ERR, self.__io_error), GObject.io_add_watch(self.__sock, GObject.IO_HUP, self.__io_hup) ] self.__sid_out = 0 log.debug("send 'hello' to %s" % self) self.send(ClientConnection.IO_HELLO)
def enterNonblockingMode(): global conn, log log.debug("entering nonblocking-mode") conn.setblocking(False) GObject.io_add_watch(conn, GObject.IO_IN, on_data, [""]) GObject.idle_add(on_loop)
def __init__(self,gyotoytop): GObject.set_application_name("Gyotoy") GObject.set_prgname("Gyotoy") self.gyotoytop = gyotoytop self._pyk_blocked=0 self.length_unit="geometrical" # read GUI definition self.builder = Gtk.Builder() self.builder.add_from_file(os.path.join(self.gyotoytop,'gyotoy.xml')) # handle destroy event (so that we can kill the window through window bar) self.window = self.builder.get_object('window1') if (self.window): self.window.connect('destroy', self.destroy) # autoconnect to callback functions # this will automatically connect the event handler "on_something_event" # to the here-defined function of the same name. This avoid defining a # long dictionary that serves the same purpose self.builder.connect_signals(self) # set stdin non blocking, this will prevent readline to block # stdin is coming from yorick (yorick spawned this python process) fd = sys.stdin.fileno() flags = fcntl.fcntl(fd, fcntl.F_GETFL) fcntl.fcntl(fd, fcntl.F_SETFL, flags | os.O_NONBLOCK) # ... and add stdin to the event loop (yorick input pipe by spawn) GObject.io_add_watch(sys.stdin,GObject.IO_IN|GObject.IO_HUP,self.yo2py,None) # run: realize the interface, start event management Gtk.main()
def listener(self, sock, *args): '''Asynchronous connection listener. Starts a handler for each connection.''' self.conn, self.addr = self.sock.accept() print _("Connected") GObject.io_add_watch(self.conn, GObject.IO_IN, self.handler) self.conn.send(self.msg_banner()) return True
def __init__(self): self.mainloop = GObject.MainLoop() self.source_pipeline = None self.sink_pipeline = Gst.parse_launch(""" intervideosrc channel=video ! queue ! video/x-raw,width=800,height=450,format=I420,framerate=25/1 ! textoverlay halignment=left valignment=top ypad=50 text=intervideosrc ! timeoverlay halignment=left valignment=top ypad=50 xpad=400 ! tee name=vtee interaudiosrc blocksize=4096 channel=audio ! queue ! audio/x-raw,format=S16LE,layout=interleaved,rate=48000,channels=2 ! tee name=atee vtee. ! queue ! videoconvert ! textoverlay halignment=left valignment=top ypad=75 text=avenc_mpeg2video ! timeoverlay halignment=left valignment=top ypad=75 xpad=400 ! avenc_mpeg2video bitrate=50000 max-key-interval=0 ! queue ! mux. atee. ! queue ! avenc_mp2 bitrate=192000 ! queue ! mux. mpegtsmux name=mux ! filesink location=foo.ts vtee. ! queue ! textoverlay halignment=left valignment=top ypad=75 text=xvimagesink ! timeoverlay halignment=left valignment=top ypad=75 xpad=400 ! videoconvert ! xvimagesink atee. ! queue ! audioconvert ! alsasink """) # Create the server, binding to localhost on port 5000 sock = socket.socket(socket.AF_INET6) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.setsockopt(socket.IPPROTO_IPV6, socket.IPV6_V6ONLY, False) sock.bind(('::', 10000)) sock.listen(1) # register socket for callback inside the GTK-Mainloop GObject.io_add_watch(sock, GObject.IO_IN, self.on_connect)
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 gobject.io_add_watch(source.fileno(), condition, wrapper) else: return gobject.io_add_watch(source, condition, callback)
def socket_accept(self, sock, _): """Accept a connection and 'select' it for readability.""" conn, _ = sock.accept() self.client_msgs[conn.fileno()] = [] GObject.io_add_watch(conn, GObject.IO_IN, self.socket_recv) logging.debug("Client connection received.") return True
def run(): initkeys(keymap, disp, root) for _ in range(0, root.display.pending_events()): root.display.next_event() GObject.io_add_watch(root.display, GObject.IO_IN, checkevt) print('Snaptile running. Press CTRL+C to quit.') signal.signal(signal.SIGINT, signal.SIG_DFL) Gtk.main()
def server(self, host, port): '''Initialize server and start listening.''' self.sock = socket.socket() self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) self.sock.bind((host, port)) self.sock.listen(1) print _("Listening on port %i...") % (port) GObject.io_add_watch(self.sock, GObject.IO_IN, self.listener)
def __init__(self, bus, index, service): global pty Characteristic.__init__(self, bus, index, UART_TX_CHARACTERISTIC_UUID, ['notify'], service) self.notifying = False #GObject.io_add_watch(sys.stdin, GObject.IO_IN, self.on_console_input) GObject.io_add_watch(pty.fileno(), GObject.IO_IN, self.on_console_input)
def init_mqtt(): global MQTT_CLIENT MQTT_CLIENT = mqtt.Client( client_id='d:quickstart:mosquitto:019283hb' ) MQTT_CLIENT.connect( MQTT_SERVER ) MQTT_CLIENT.on_connect = on_connect MQTT_CLIENT.on_message = on_message GObject.io_add_watch(MQTT_CLIENT.socket().makefile(), GObject.IO_IN | GObject.IO_OUT, on_message_received)
def accept_interrupt(self, source, cond): self.interrupt_channel, cinfo = self.interrupt_socket.accept() gobject.io_add_watch(self.interrupt_channel.fileno(), gobject.IO_ERR | gobject.IO_HUP, self.close_interrupt) gobject.io_add_watch(self.interrupt_channel.fileno(), gobject.IO_IN | gobject.IO_PRI, self.callback, self.interrupt_channel) return False
def accept_control(self, source, cond): self.control_channel, cinfo = self.control_socket.accept() gobject.io_add_watch(self.control_channel.fileno(), gobject.IO_ERR | gobject.IO_HUP, self.close_control) gobject.io_add_watch(self.control_channel.fileno(), gobject.IO_IN | gobject.IO_PRI, self.callback, self.control_channel) return False # Stop watching, we only accept one connection
def start(self): """ Write config if not found and watch for keyboard events. """ self._get_config() self.root.change_attributes(event_mask=X.KeyPressMask) self._bind_keys() for event in range(0, self.root.display.pending_events()): self.root.display.next_event() GObject.io_add_watch(self.root.display, GObject.IO_IN, self._check_event) print('PyGrid running. Press CTRL+C to cancel.') Gtk.main()
def add_input_port(server, port): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: sock.bind((server, port)) #TODO: check port empty first except: print ('Server failed to start on host %s port %s' % (server, port)) return False sock.listen(1) print('Server Interface Running on ' + server + ':' + str(port) ) GObject.io_add_watch(sock, GObject.IO_IN, got_input, port)
def add_listen_port (hostname,port): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) sock.settimeout(2) try: sock.connect((hostname,port)) except: print ('Could not connect to '+str(hostname)+'@'+str(port)) listen_ports[port] = sock recent_text[port] = [] #sock.send('GET /index.html HTTP/1.1\nHost: pygtk.org\n\n') GObject.io_add_watch(sock, GObject.IO_IN, handle_data, port)
def stegcrack(self, widget): outguess = ("OFF", "ON")[self.checkoutguess.get_active()] jphide = ("OFF", "ON")[self.checkjph.get_active()] jsteg = ("OFF", "ON")[self.checkjsteg.get_active()] dictionary = self.dict.get_filename() self.sfile = self.file.get_text() tests = " -t " if outguess == "ON": tests += "o" if jphide == "ON": tests += "p" if jsteg == "ON": tests += "j" if self.sfile != '' and dictionary != None: self.buffer3.set_text("Please Wait \n") cmd = re.escape( execdir ) + "/programs/" + self.arch + "/stegbreak " + tests + " -r " + re.escape( execdir) + "/programs/noarch/rules.ini -f " + re.escape( dictionary) + " " + self.sfile self.showprogress() p = Popen("exec " + cmd, shell=True, stdout=PIPE, stderr=PIPE) self.pid = p.pid def test_io_watch(f, cond): out = f.readline() if out == '': return False end_iter = self.buffer3.get_end_iter() self.buffer3.insert(end_iter, out) adj = self.sw.get_vadjustment() adj.set_value(adj.get_upper() - adj.get_page_size()) return True def tester(): if p.poll() is None: time.sleep(5) GObject.timeout_add(2000, update) return True GObject.io_add_watch(p.stderr, GObject.IO_IN | GObject.IO_HUP, test_io_watch) GObject.io_add_watch(p.stdout, GObject.IO_IN | GObject.IO_HUP, test_io_watch) def update(): os.system("kill -s 2 " + str(self.pid)) GObject.idle_add(tester) else: self.buffer1.set_text( "You must select a stego file and a dictionary file.") self.showdiag()
def sniffThread(self): logging.info("Launching sniff process") self.stracePid = subprocess.Popen([ "/usr/bin/strace", "-xx", "-s", "65536", "-e", "read,write", "-p", str(self.pid) ], stdout=subprocess.PIPE, stderr=subprocess.PIPE) GObject.io_add_watch(self.stracePid.stderr, GObject.IO_IN | GObject.IO_HUP, self.handle_new_pkt)
def create_lircd_socket(self, socket_path): try: os.remove(socket_path) except OSError: pass sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind(socket_path) sock.listen(5) GObject.io_add_watch(sock, GObject.IO_IN, self.listener) print("created Lirc-Socket %s"%(socket_path)) return sock
def listener(self, sock, *args): '''Asynchronous connection listener. Starts a handler for each connection.''' conn, addr = sock.accept() f = conn.makefile(conn) self.shell = ShoebotCmd(self.bot, stdin=f, stdout=f, intro=INTRO) print(_("Connected")) GObject.io_add_watch(conn, GObject.IO_IN, self.handler) if self.shell.intro: self.shell.stdout.write(str(self.shell.intro)+"\n") self.shell.stdout.flush() return True
def listener(self, sock, *args): '''Asynchronous connection listener. Starts a handler for each connection.''' conn, addr = sock.accept() f = conn.makefile(conn) self.shell = ShoebotCmd(self.bot, stdin=f, stdout=f, intro=INTRO) print(_("Connected")) GObject.io_add_watch(conn, GObject.IO_IN, self.handler) if self.shell.intro: self.shell.stdout.write(str(self.shell.intro) + "\n") self.shell.stdout.flush() return True
def NewConnection(self, path, fd, properties): print("new control connectin") self.conns[path] = HIDConnection(fd.take()) def new_intr_conn(ssock, ip_type): sock, info = ssock.accept() print("interrput connection:", info) self.conns[path].register_intr_sock(sock) return False gobject.io_add_watch(self.sock, gobject.IO_IN, new_intr_conn)
def run_command(self, command): try: p = subprocess.Popen(command, stdout=subprocess.PIPE, stderr=subprocess.PIPE, stdin=subprocess.PIPE, shell=True) self.io_id = GObject.io_add_watch(p.stdout, GObject.IO_IN, self.feed) GObject.io_add_watch(p.stdout, GObject.IO_HUP, self.command_finished) except Exception as err: message_dialog(self.win, 'error', _("An error has occured"), str(err))
def create_lircd_socket(self, socket_path): try: os.remove(socket_path) except OSError: pass sock = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM) sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) sock.bind(socket_path) sock.listen(5) GObject.io_add_watch(sock, GObject.IO_IN, self.listener) print("created Lirc-Socket %s" % (socket_path)) return sock
def serve_forever(self, poll_interval=0.5): mainloop = GObject.MainLoop() if hasattr(self, 'socket'): GObject.io_add_watch( self, GObject.IO_IN | GObject.IO_PRI, self._on_new_request) if hasattr(self, 'stream_queue'): GObject.io_add_watch( self.stream_queue._reader, GObject.IO_IN | GObject.IO_PRI, self._on_new_message) try: mainloop.run() except KeyboardInterrupt: self.shutdown()
def connect_callback(self, response): if "CONNECT" in response: dprint("Starting pppd") self.pppd = subprocess.Popen( ["/usr/sbin/pppd", "%s" % self.port, "115200", "defaultroute", "updetach", "usepeerdns"], bufsize=1, stdout=subprocess.PIPE) GObject.io_add_watch(self.pppd.stdout, GObject.IO_IN | GObject.IO_ERR | GObject.IO_HUP, self.on_pppd_stdout) GObject.timeout_add(1000, self.check_pppd) self.cleanup() else: self.cleanup() raise PPPException("Bad modem response %s, expected CONNECT" % response[0])
def watch_debconf_fd(self, from_debconf, process_input): """Event loop interface to debconffilter. A frontend typically provides its own event loop. When a debconffiltered command is running, debconffilter must be given an opportunity to process input from that command as it arrives. This method will be called with from_debconf as a file descriptor reading from the filtered command and a process_input callback which should be called when input events are received.""" GObject.io_add_watch(from_debconf, GObject.IO_IN | GObject.IO_ERR | GObject.IO_HUP, self.watch_debconf_fd_helper, process_input)
def start(self): """ Write config if not found and watch for keyboard events. """ self._get_config() self.root.change_attributes(event_mask=X.KeyPressMask) self.keys = {self.display.keysym_to_keycode(k):v for k,v in self.KEYS.items()} for keycode in self.keys: self.root.grab_key(keycode, X.ControlMask | X.Mod1Mask, 1, X.GrabModeAsync, X.GrabModeAsync) self.root.grab_key(keycode, X.ControlMask | X.Mod1Mask | X.Mod2Mask, 1, X.GrabModeAsync, X.GrabModeAsync) for event in range(0, self.root.display.pending_events()): self.root.display.next_event() GObject.io_add_watch(self.root.display, GObject.IO_IN, self._check_event) print('PyGrid running. Press CTRL+C to cancel.') Gtk.main()
def startserver(self, host, port): self.host = host self.port = port self.sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) self.sock.setsockopt(socket.SOL_SOCKET, socket.SO_REUSEADDR, 1) try: self.sock.bind((self.host, self.port)) #TODO: check port empty first except: loggy.warn('mpdserver failed to start on host %s port %s' % (self.host, self.port)) return False self.sock.listen(1) loggy.log('mpdserver Interface Running on ' + host + ':' + str(port) ) GObject.io_add_watch(self.sock, GObject.IO_IN, self.listener)