def _noIntrWatchFd(self, fd, isEpoll, mask=select.POLLERR):
if isEpoll:
poller = select.epoll()
pollInterval = self.SLEEP_INTERVAL * self.RETRIES * 2
else:
poller = select.poll()
pollInterval = self.SLEEP_INTERVAL * self.RETRIES * 2 * 1000
poller.register(fd, mask)
osutils.uninterruptible_poll(poller.poll, pollInterval)
poller.unregister(fd)
def _noIntrWatchFd(self, fd, isEpoll, mask=select.POLLERR):
if isEpoll:
poller = select.epoll()
pollInterval = self.SLEEP_INTERVAL * self.RETRIES * 2
else:
poller = select.poll()
pollInterval = self.SLEEP_INTERVAL * self.RETRIES * 2 * 1000
poller.register(fd, mask)
osutils.uninterruptible_poll(poller.poll, pollInterval)
poller.unregister(fd)
def _scan(self):
with closing(select.epoll()) as epoll:
with _monitoring_socket(self._queue, self._groups, epoll) as sock:
with _pipetrick(epoll) as self._pipetrick:
self._scanning_started.set()
while True:
if self._timeout:
timeout = self._end_time - monotonic_time()
# timeout expired
if timeout <= 0:
self._scanning_stopped.set()
self._queue.put(_TIMEOUT_FLAG)
break
else:
timeout = -1
events = uninterruptible_poll(epoll.poll,
timeout=timeout)
# poll timeouted
if len(events) == 0:
self._scanning_stopped.set()
self._queue.put(_TIMEOUT_FLAG)
break
# stopped by pipetrick
elif (self._pipetrick[0], select.POLLIN) in events:
uninterruptible(os.read, self._pipetrick[0], 1)
self._queue.put(_STOP_FLAG)
break
libnl.nl_recvmsgs_default(sock)
def _scan(self):
with closing(select.epoll()) as epoll:
with _monitoring_socket(self._queue, self._groups, epoll) as sock:
with _pipetrick(epoll) as self._pipetrick:
self._scanning_started.set()
while True:
if self._timeout:
timeout = self._end_time - monotonic_time()
# timeout expired
if timeout <= 0:
self._scanning_stopped.set()
self._queue.put(_TIMEOUT_FLAG)
break
else:
timeout = -1
events = uninterruptible_poll(epoll.poll,
timeout=timeout)
# poll timeouted
if len(events) == 0:
self._scanning_stopped.set()
self._queue.put(_TIMEOUT_FLAG)
break
# stopped by pipetrick
elif (self._pipetrick[0], select.POLLIN) in events:
uninterruptible(os.read, self._pipetrick[0], 1)
self._queue.put(_STOP_FLAG)
break
libnl.nl_recvmsgs_default(sock)
def _poll_timeout(self, timeout):
fdevents = uninterruptible_poll(self._poll.poll, timeout)
for fileno, event in fdevents:
if event & select.EPOLLIN:
self._poll_input(fileno)
elif event & (select.EPOLLHUP | select.EPOLLERR):
self._poll_event(fileno)
def _poll_timeout(self, timeout):
fdevents = uninterruptible_poll(self._poll.poll, timeout)
for fileno, event in fdevents:
if event & select.EPOLLIN:
self._poll_input(fileno)
elif event & (select.EPOLLHUP | select.EPOLLERR):
self._poll_event(fileno)
def _wait_for_events(self):
""" Wait for an epoll event and handle channels' timeout. """
events = uninterruptible_poll(self._epoll.poll, 1)
for (fileno, event) in events:
self._handle_event(fileno, event)
else:
self._update_channels()
if (self._timeout is not None) and (self._timeout > 0):
self._handle_timeouts()
with self._update_lock:
self._handle_unconnected()
def _wait_for_events(self):
""" Wait for an epoll event and handle channels' timeout. """
events = uninterruptible_poll(self._epoll.poll, 1)
for (fileno, event) in events:
self._handle_event(fileno, event)
else:
self._update_channels()
if (self._timeout is not None) and (self._timeout > 0):
self._handle_timeouts()
with self._update_lock:
self._handle_unconnected()
def _processStreams(self):
if len(self._closedfds) == 3:
return
if not self._streamLock.acquire(False):
self._streamLock.acquire()
self._streamLock.release()
return
try:
if self._stdin.len > 0 and self._stdin.pos == 0:
# Polling stdin is redundant if there is nothing to write
# turn on only if data is waiting to be pushed
self._poller.modify(self._fdin, select.EPOLLOUT)
pollres = uninterruptible_poll(self._poller.poll, 1)
for fd, event in pollres:
stream = self._fdMap[fd]
if event & select.EPOLLOUT and self._stdin.len > 0:
buff = self._stdin.read(BUFFSIZE)
written = os.write(fd, buff)
stream.pos -= len(buff) - written
if stream.pos == stream.len:
stream.truncate(0)
self._poller.modify(fd, 0)
elif event & (select.EPOLLIN | select.EPOLLPRI):
data = os.read(fd, BUFFSIZE)
oldpos = stream.pos
stream.pos = stream.len
stream.write(data)
stream.pos = oldpos
elif event & (select.EPOLLHUP | select.EPOLLERR):
self._poller.unregister(fd)
self._closedfds.append(fd)
# I don't close the fd because the original Popen
# will do it.
if self.stdin.closed and self._fdin not in self._closedfds:
self._poller.unregister(self._fdin)
self._closedfds.append(self._fdin)
self._proc.stdin.close()
finally:
self._streamLock.release()
def _processStreams(self):
if len(self._closedfds) == 3:
return
if not self._streamLock.acquire(False):
self._streamLock.acquire()
self._streamLock.release()
return
try:
if self._stdin.len > 0 and self._stdin.pos == 0:
# Polling stdin is redundant if there is nothing to write
# turn on only if data is waiting to be pushed
self._poller.modify(self._fdin, select.EPOLLOUT)
pollres = uninterruptible_poll(self._poller.poll, 1)
for fd, event in pollres:
stream = self._fdMap[fd]
if event & select.EPOLLOUT and self._stdin.len > 0:
buff = self._stdin.read(BUFFSIZE)
written = os.write(fd, buff)
stream.pos -= len(buff) - written
if stream.pos == stream.len:
stream.truncate(0)
self._poller.modify(fd, 0)
elif event & (select.EPOLLIN | select.EPOLLPRI):
data = os.read(fd, BUFFSIZE)
oldpos = stream.pos
stream.pos = stream.len
stream.write(data)
stream.pos = oldpos
elif event & (select.EPOLLHUP | select.EPOLLERR):
self._poller.unregister(fd)
self._closedfds.append(fd)
# I don't close the fd because the original Popen
# will do it.
if self.stdin.closed and self._fdin not in self._closedfds:
self._poller.unregister(self._fdin)
self._closedfds.append(self._fdin)
self._proc.stdin.close()
finally:
self._streamLock.release()
def testNoTimeoutPipePoll(self):
def _sigChldAndClose(fd):
self._waitAndSigchld()
time.sleep(self.SLEEP_INTERVAL)
os.close(fd)
myPipe, hisPipe = os.pipe()
poller = select.poll()
poller.register(myPipe, select.POLLHUP)
intrThread = threading.Thread(target=_sigChldAndClose, args=(hisPipe,))
intrThread.setDaemon(True)
intrThread.start()
try:
self.assertTrue(len(
osutils.uninterruptible_poll(poller.poll, -1)) > 0)
finally:
os.close(myPipe)
def testNoTimeoutPipePoll(self):
def _sigChldAndClose(fd):
self._waitAndSigchld()
time.sleep(self.SLEEP_INTERVAL)
os.close(fd)
myPipe, hisPipe = os.pipe()
poller = select.poll()
poller.register(myPipe, select.POLLHUP)
intrThread = threading.Thread(target=_sigChldAndClose,
args=(hisPipe, ))
intrThread.setDaemon(True)
intrThread.start()
try:
self.assertTrue(
len(osutils.uninterruptible_poll(poller.poll, -1)) > 0)
finally:
os.close(myPipe)
def _scan(self):
try:
epoll = select.epoll()
with closing(epoll):
with _monitoring_socket(
self._queue, self._groups, epoll, self._c_callback_function
) as sock:
with _pipetrick(epoll) as self._pipetrick:
self._scanning_started.set()
while True:
if self._timeout:
timeout = self._end_time - monotonic_time()
# timeout expired
if timeout <= 0:
self._scanning_stopped.set()
self._queue.put(Event(EventType.TIMEOUT))
break
else:
timeout = -1
events = uninterruptible_poll(
epoll.poll, timeout=timeout
)
# poll timeouted
if len(events) == 0:
self._scanning_stopped.set()
self._queue.put(Event(EventType.TIMEOUT))
break
# stopped by pipetrick
elif (self._pipetrick[0], select.POLLIN) in events:
uninterruptible(os.read, self._pipetrick[0], 1)
self._queue.put(Event(EventType.STOP))
break
libnl.nl_recvmsgs_default(sock)
except:
event = Event(EventType.EXCEPTION, sys.exc_info())
self._queue.put(event)
raise
def _scan(self):
try:
epoll = select.epoll()
with closing(epoll):
with _monitoring_socket(
self._queue, self._groups, epoll) as sock:
with _pipetrick(epoll) as self._pipetrick:
self._scanning_started.set()
while True:
if self._timeout:
timeout = self._end_time - monotonic_time()
# timeout expired
if timeout <= 0:
self._scanning_stopped.set()
self._queue.put(Event(EventType.TIMEOUT))
break
else:
timeout = -1
events = uninterruptible_poll(epoll.poll,
timeout=timeout)
# poll timeouted
if len(events) == 0:
self._scanning_stopped.set()
self._queue.put(Event(EventType.TIMEOUT))
break
# stopped by pipetrick
elif (self._pipetrick[0], select.POLLIN) in events:
uninterruptible(os.read, self._pipetrick[0], 1)
self._queue.put(Event(EventType.STOP))
break
libnl.nl_recvmsgs_default(sock)
except:
event = Event(EventType.EXCEPTION, sys.exc_info())
self._queue.put(event)
raise
