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)
