def _open(self, *args): from quodlibet import qltk self._id = None try: if not os.path.exists(self._path): mkdir(os.path.dirname(self._path)) os.mkfifo(self._path, 0600) fifo = os.open(self._path, os.O_NONBLOCK) f = os.fdopen(fifo, "r", 4096) self._id = qltk.io_add_watch( f, GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_ERR | GLib.IO_HUP, self._process, *args) except (EnvironmentError, AttributeError): pass
def start_write(self): """Trigger at least one call to handle_write() if can_write is True. Used to start writing to a client not triggered by a client request. """ assert not self._closed write_buffer = bytearray() def can_write_cb(sock, flags, *args): if flags & (GLib.IOCondition.HUP | GLib.IOCondition.ERR): self.close() return False if flags & GLib.IOCondition.OUT: if self.can_write(): write_buffer.extend(self.handle_write()) if not write_buffer: self._out_id = None return False while True: try: result = sock.send(write_buffer) except (IOError, OSError) as e: if e.errno in (errno.EWOULDBLOCK, errno.EAGAIN): return True elif e.errno == errno.EINTR: continue else: self.close() return False break del write_buffer[:result] return True if self._out_id is None: self._out_id = io_add_watch( self._sock, GLib.PRIORITY_DEFAULT, GLib.IOCondition.OUT | GLib.IOCondition.ERR | GLib.IOCondition.HUP, can_write_cb, )
def __start_next(self): started = len(filter(lambda row: row[2] != 0, self.downloads)) iter = self.downloads.get_iter_first() while iter is not None: if started >= 2: break if self.downloads[iter][2] == 0: url = urllib.urlopen(self.downloads[iter][3]) sock = url.fp._sock sock.setblocking(0) self.downloads[iter][0] = sock sig_id = qltk.io_add_watch( sock, GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_ERR | GLib.IO_HUP, self.__got_data, self.downloads[iter][1], iter) self.downloads[iter][2] = sig_id started += 1 iter = self.downloads.iter_next(iter)
def start_read(self): """Start to read and call handle_read() if data is available. Only call once. """ assert self._in_id is None and not self._closed def can_read_cb(sock, flags, *args): if flags & (GLib.IOCondition.HUP | GLib.IOCondition.ERR): self.close() return False if flags & GLib.IOCondition.IN: while True: try: data = sock.recv(4096) except (IOError, OSError) as e: if e.errno in (errno.EWOULDBLOCK, errno.EAGAIN): return True elif e.errno == errno.EINTR: continue else: self.close() return False break if not data: self.close() return False self.handle_read(data) # the implementation could close in handle_read() if not self._closed: self.start_write() return True self._in_id = io_add_watch( self._sock, GLib.PRIORITY_DEFAULT, GLib.IOCondition.IN | GLib.IOCondition.ERR | GLib.IOCondition.HUP, can_read_cb, )
def start_read(self): """Start to read and call handle_read() if data is available. Only call once. """ assert self._in_id is None and not self._closed def can_read_cb(sock, flags, *args): if flags & (GLib.IOCondition.HUP | GLib.IOCondition.ERR): self.close() return False if flags & GLib.IOCondition.IN: while True: try: data = sock.recv(4096) except (IOError, OSError) as e: if e.errno in (errno.EWOULDBLOCK, errno.EAGAIN): return True elif e.errno == errno.EINTR: continue else: self.close() return False break if not data: self.close() return False self.handle_read(data) # the implementation could close in handle_read() if not self._closed: self.start_write() return True self._in_id = io_add_watch( self._sock, GLib.PRIORITY_DEFAULT, GLib.IOCondition.IN | GLib.IOCondition.ERR | GLib.IOCondition.HUP, can_read_cb)
def _open(self, ignore_lock, *args): from quodlibet import qltk self._id = None mkdir(os.path.dirname(self._path)) try: os.mkfifo(self._path, 0600) except OSError: # maybe exists, we'll fail below otherwise pass try: fifo = os.open(self._path, os.O_NONBLOCK) except OSError: return while True: try: fcntl.flock(fifo, fcntl.LOCK_EX | fcntl.LOCK_NB) except IOError as e: # EINTR on linux if e.errno == errno.EINTR: continue if ignore_lock: break # OSX doesn't support fifo locking, so check errno if e.errno == errno.EWOULDBLOCK: raise FIFOError("fifo already locked") else: print_d("fifo locking failed: %r" % e) break try: f = os.fdopen(fifo, "r", 4096) except OSError: pass self._id = qltk.io_add_watch( f, GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_ERR | GLib.IO_HUP, self._process, *args)
def _open(self, ignore_lock, *args): from quodlibet import qltk self._id = None mkdir(os.path.dirname(self._path)) try: os.mkfifo(self._path, 0o600) except OSError: # maybe exists, we'll fail below otherwise pass try: fifo = os.open(self._path, os.O_NONBLOCK) except OSError: return while True: try: fcntl.flock(fifo, fcntl.LOCK_EX | fcntl.LOCK_NB) except IOError as e: # EINTR on linux if e.errno == errno.EINTR: continue if ignore_lock: break # OSX doesn't support fifo locking, so check errno if e.errno == errno.EWOULDBLOCK: raise FIFOError("fifo already locked") else: print_d("fifo locking failed: %r" % e) break try: f = os.fdopen(fifo, "r", 4096) except OSError: pass self._id = qltk.io_add_watch(f, GLib.PRIORITY_DEFAULT, GLib.IO_IN | GLib.IO_ERR | GLib.IO_HUP, self._process, *args)