Esempio n. 1
0
	def _readAndWrite(self, source, condition):
		# note: gtk-1.2's gtk_input_add presents an API in terms of gdk
		# constants like INPUT_READ and INPUT_WRITE. Internally, it will add
		# POLL_HUP and POLL_ERR to the poll() events, but if they happen it
		# will turn them back into INPUT_READ and INPUT_WRITE. gdkevents.c
		# maps IN/HUP/ERR to INPUT_READ, and OUT/ERR to INPUT_WRITE. This
		# means there is no immediate way to detect a disconnected socket.

		# The g_io_add_watch() API is more suited to this task. I don't think
		# pygtk exposes it, though.
		why = None
		didRead = None
		try:
			if condition & gtk.GDK.INPUT_READ:
				why = source.doRead()
				didRead = source.doRead
			if not why and condition & gtk.GDK.INPUT_WRITE:
				# if doRead caused connectionLost, don't call doWrite
				# if doRead is doWrite, don't call it again.
				if not source.disconnected and source.doWrite != didRead:
					why = source.doWrite()
					didRead = source.doWrite # if failed it was in write
		except:
			why = sys.exc_info()[1]
			log.msg('Error In %s' % source)
			log.deferr()

		if why:
			self._disconnectSelectable(source, why, didRead == source.doRead)
Esempio n. 2
0
	def _doReadOrWrite(self, source, condition, faildict={
		error.ConnectionDone: failure.Failure(error.ConnectionDone()),
		error.ConnectionLost: failure.Failure(error.ConnectionLost()),
		}):
		why = None
		inRead = False
		if condition & POLL_DISCONNECTED and not (condition & gobject.IO_IN):
			if source in self._reads:
				why = main.CONNECTION_DONE
				inRead = True
			else:
				why = main.CONNECTION_LOST
		else:
			try:
				if condition & gobject.IO_IN:
					why = source.doRead()
					inRead = True
				if not why and condition & gobject.IO_OUT:
					# if doRead caused connectionLost, don't call doWrite
					# if doRead is doWrite, don't call it again.
					if not source.disconnected:
						why = source.doWrite()
			except:
				why = sys.exc_info()[1]
				log.msg('Error In %s' % source)
				log.deferr()

		if why:
			self._disconnectSelectable(source, why, inRead)
Esempio n. 3
0
	def _doReadOrWrite(self, selectable, fd, event):
		why = None
		inRead = False
		if event & POLL_DISCONNECTED and not (event & POLLIN):
			if fd in self._reads:
				why = main.CONNECTION_DONE
				inRead = True
			else:
				why = main.CONNECTION_LOST
		else:
			try:
				if event & POLLIN:
					why = selectable.doRead()
					inRead = True
				if not why and event & POLLOUT:
					why = selectable.doWrite()
					inRead = False
				if not selectable.fileno() == fd:
					why = error.ConnectionFdescWentAway('Filedescriptor went away')
					inRead = False
			except:
				log.deferr()
				why = sys.exc_info()[1]
		if why:
			self._disconnectSelectable(selectable, why, inRead)
Esempio n. 4
0
    def _readAndWrite(self, source, condition):
        # note: gtk-1.2's gtk_input_add presents an API in terms of gdk
        # constants like INPUT_READ and INPUT_WRITE. Internally, it will add
        # POLL_HUP and POLL_ERR to the poll() events, but if they happen it
        # will turn them back into INPUT_READ and INPUT_WRITE. gdkevents.c
        # maps IN/HUP/ERR to INPUT_READ, and OUT/ERR to INPUT_WRITE. This
        # means there is no immediate way to detect a disconnected socket.

        # The g_io_add_watch() API is more suited to this task. I don't think
        # pygtk exposes it, though.
        why = None
        didRead = None
        try:
            if condition & gtk.GDK.INPUT_READ:
                why = source.doRead()
                didRead = source.doRead
            if not why and condition & gtk.GDK.INPUT_WRITE:
                # if doRead caused connectionLost, don't call doWrite
                # if doRead is doWrite, don't call it again.
                if not source.disconnected and source.doWrite != didRead:
                    why = source.doWrite()
                    didRead = source.doWrite  # if failed it was in write
        except:
            why = sys.exc_info()[1]
            log.msg('Error In %s' % source)
            log.deferr()

        if why:
            self._disconnectSelectable(source, why, didRead == source.doRead)
Esempio n. 5
0
	def _runAction(self, action, fd):
		try:
			closed = getattr(fd, action)()
		except:
			closed = sys.exc_info()[1]
			log.deferr()

		if closed:
			self._disconnectSelectable(fd, closed, action == 'doRead')
Esempio n. 6
0
    def runUntilCurrent(self):
        """Run all pending timed calls.
		"""
        if self.threadCallQueue:
            # Keep track of how many calls we actually make, as we're
            # making them, in case another call is added to the queue
            # while we're in this loop.
            count = 0
            total = len(self.threadCallQueue)
            for (f, a, kw) in self.threadCallQueue:
                try:
                    f(*a, **kw)
                except:
                    log.err()
                count += 1
                if count == total:
                    break
            del self.threadCallQueue[:count]
            if self.threadCallQueue:
                self.wakeUp()

                # insert new delayed calls now
        self._insertNewDelayedCalls()

        now = self.seconds()
        while self._pendingTimedCalls and (self._pendingTimedCalls[0].time <= now):
            call = heappop(self._pendingTimedCalls)
            if call.cancelled:
                self._cancellations -= 1
                continue

            if call.delayed_time > 0:
                call.activate_delay()
                heappush(self._pendingTimedCalls, call)
                continue

            try:
                call.called = 1
                call.func(*call.args, **call.kw)
            except:
                log.deferr()
                if hasattr(call, "creator"):
                    e = "\n"
                    e += " C: previous exception occurred in " + "a DelayedCall created here:\n"
                    e += " C:"
                    e += "".join(call.creator).rstrip().replace("\n", "\n C:")
                    e += "\n"
                    log.msg(e)

        if self._cancellations > 50 and self._cancellations > len(self._pendingTimedCalls) >> 1:
            self._cancellations = 0
            self._pendingTimedCalls = [x for x in self._pendingTimedCalls if not x.cancelled]
            heapify(self._pendingTimedCalls)

        if self._justStopped:
            self._justStopped = False
            self.fireSystemEvent("shutdown")
Esempio n. 7
0
    def _doWriteOrRead(self, selectable, fd, filter):
        try:
            if filter == EVFILT_READ:
                why = selectable.doRead()
            if filter == EVFILT_WRITE:
                why = selectable.doWrite()
            if not selectable.fileno() == fd:
                why = main.CONNECTION_LOST
        except:
            why = sys.exc_info()[1]
            log.deferr()

        if why:
            self.removeReader(selectable)
            self.removeWriter(selectable)
            selectable.connectionLost(failure.Failure(why))
Esempio n. 8
0
	def _doWriteOrRead(self, selectable, fd, filter):
		try:
			if filter == EVFILT_READ:
				why = selectable.doRead()
			if filter == EVFILT_WRITE:
				why = selectable.doWrite()
			if not selectable.fileno() == fd:
				why = main.CONNECTION_LOST
		except:
			why = sys.exc_info()[1]
			log.deferr()

		if why:
			self.removeReader(selectable)
			self.removeWriter(selectable)
			selectable.connectionLost(failure.Failure(why))
Esempio n. 9
0
	def _runWrite(self, fd):
		closed = 0
		try:
			closed = fd.doWrite()
		except:
			closed = sys.exc_info()[1]
			log.deferr()

		if closed:
			self.removeReader(fd)
			self.removeWriter(fd)
			try:
				fd.connectionLost(failure.Failure(closed))
			except:
				log.deferr()
		elif closed is None:
			return 1
Esempio n. 10
0
	def runUntilCurrent(self):
		"""Run all pending timed calls.
		"""
		if self.threadCallQueue:
			# Keep track of how many calls we actually make, as we're
			# making them, in case another call is added to the queue
			# while we're in this loop.
			count = 0
			total = len(self.threadCallQueue)
			for (f, a, kw) in self.threadCallQueue:
				try:
					f(*a, **kw)
				except:
					log.err()
				count += 1
				if count == total:
					break
			del self.threadCallQueue[:count]
			if self.threadCallQueue:
				self.wakeUp()

		# insert new delayed calls now
		self._insertNewDelayedCalls()

		now = self.seconds()
		while self._pendingTimedCalls and (self._pendingTimedCalls[0].time <= now):
			call = heappop(self._pendingTimedCalls)
			if call.cancelled:
				self._cancellations-=1
				continue

			if call.delayed_time > 0:
				call.activate_delay()
				heappush(self._pendingTimedCalls, call)
				continue

			try:
				call.called = 1
				call.func(*call.args, **call.kw)
			except:
				log.deferr()
				if hasattr(call, "creator"):
					e = "\n"
					e += " C: previous exception occurred in " + \
						 "a DelayedCall created here:\n"
					e += " C:"
					e += "".join(call.creator).rstrip().replace("\n","\n C:")
					e += "\n"
					log.msg(e)


		if (self._cancellations > 50 and
			 self._cancellations > len(self._pendingTimedCalls) >> 1):
			self._cancellations = 0
			self._pendingTimedCalls = [x for x in self._pendingTimedCalls
									   if not x.cancelled]
			heapify(self._pendingTimedCalls)

		if self._justStopped:
			self._justStopped = False
			self.fireSystemEvent("shutdown")
Esempio n. 11
0
		read = 0
		while read < self.maxThroughput:
			try:
				data, addr = self.socket.recvfrom(self.maxPacketSize)
				read += len(data)
				self.protocol.datagramReceived(data)
			except socket.error, se:
				no = se.args[0]
				if no in (EAGAIN, EINTR, EWOULDBLOCK):
					return
				if no == ECONNREFUSED:
					self.protocol.connectionRefused()
				else:
					raise
			except:
				log.deferr()


	def write(self, data):
		"""
		Write a datagram.
		"""
		try:
			return self.socket.send(data)
		except socket.error, se:
			no = se.args[0]
			if no == EINTR:
				return self.write(data)
			elif no == EMSGSIZE:
				raise error.MessageLengthError, "message too long"
			elif no == ECONNREFUSED: