def register(self, aliases, port, interface=""): self.logger.info("registering on %s:%s", self.ip, self.port) sock = socket.socket(self.sock_family, socket.SOCK_DGRAM) with closing(sock): sock.bind((interface, 0)) if self.bcast: sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True) data = brine.dump(("RPYC", "REGISTER", (aliases, port))) sock.sendto(data, (self.ip, self.port)) tmax = time.time() + self.timeout while time.time() < tmax: sock.settimeout(tmax - time.time()) try: data, address = sock.recvfrom(MAX_DGRAM_SIZE) rip, rport = address[:2] except socket.timeout: self.logger.warn("no registry acknowledged") return False if rport != self.port: continue try: reply = brine.load(data) except Exception: continue if reply == "OK": self.logger.info("registry %s:%s acknowledged", rip, rport) return True else: self.logger.warn("no registry acknowledged") return False
def register(self, aliases, port, interface=""): self.logger.info("registering on %s:%s", self.ip, self.port) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) with closing(sock): sock.bind((interface, 0)) sock.settimeout(self.timeout) data = brine.dump(("RPYC", "REGISTER", (aliases, port))) try: sock.connect((self.ip, self.port)) sock.send(data) except (socket.error, socket.timeout): self.logger.warn("could not connect to registry") return False try: data = sock.recv(MAX_DGRAM_SIZE) except socket.timeout: self.logger.warn("registry did not acknowledge") return False try: reply = brine.load(data) except Exception: self.logger.warn("received corrupted data from registry") return False if reply == "OK": self.logger.info("registry %s:%s acknowledged", self.ip, self.port) return True
def _send(self, msg, seq, args): data = brine.dump((msg, seq, args)) # GC might run while sending data # if so, a BaseNetref.__del__ might be called # BaseNetref.__del__ must call asyncreq, # which will cause a deadlock # Solution: # Add the current request to a queue and let the thread that currently # holds the sendlock send it when it's done with its current job. # NOTE: Atomic list operations should be thread safe, # please call me out if they are not on all implementations! self._send_queue.append(data) # It is crucial to check the queue each time AFTER releasing the lock: while self._send_queue: if not self._sendlock.acquire(False): # Another thread holds the lock. It will send the data after # it's done with its current job. We can safely return. return try: # Can happen if another consumer was scheduled in between # `while` and `acquire`: if not self._send_queue: # Must `continue` to ensure that `send_queue` is checked # after releasing the lock! (in case another producer is # scheduled before `release`) continue data = self._send_queue.pop(0) self._channel.send(data) finally: self._sendlock.release()
def unregister(self, port): self.logger.info("unregistering from %s:%s", self.ip, self.port) sock = socket.socket(self.sock_family, socket.SOCK_DGRAM) with closing(sock): if self.bcast: sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True) data = brine.dump(("RPYC", "UNREGISTER", (port, ))) sock.sendto(data, (self.ip, self.port))
def unregister(self, port): self.logger.info("unregistering from %s:%s", self.ip, self.port) sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) with closing(sock): sock.settimeout(self.timeout) data = brine.dump(("RPYC", "UNREGISTER", (port, ))) try: sock.connect((self.ip, self.port)) sock.send(data) except (socket.error, socket.timeout): self.logger.warn("could not connect to registry")
def discover(self, name): sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM) with closing(sock): sock.settimeout(self.timeout) data = brine.dump(("RPYC", "QUERY", (name, ))) sock.connect((self.ip, self.port)) sock.send(data) try: data = sock.recv(MAX_DGRAM_SIZE) except (socket.error, socket.timeout): servers = () else: servers = brine.load(data) return servers
def discover(self, name): sock = socket.socket(self.sock_family, socket.SOCK_DGRAM) with closing(sock): if self.bcast: sock.setsockopt(socket.SOL_SOCKET, socket.SO_BROADCAST, True) data = brine.dump(("RPYC", "QUERY", (name, ))) sock.sendto(data, (self.ip, self.port)) sock.settimeout(self.timeout) try: data, _ = sock.recvfrom(MAX_DGRAM_SIZE) except (socket.error, socket.timeout): servers = () else: servers = brine.load(data) return servers
def _work(self): while self.active: try: data, addrinfo = self._recv() except (socket.error, socket.timeout): continue try: magic, cmd, args = brine.load(data) except Exception: continue if magic != "RPYC": self.logger.warn("invalid magic: %r", magic) continue cmdfunc = getattr(self, "cmd_%s" % (cmd.lower(), ), None) if not cmdfunc: self.logger.warn("unknown command: %r", cmd) continue try: reply = cmdfunc(addrinfo[0], *args) except Exception: self.logger.exception('error executing function') else: self._send(brine.dump(reply), addrinfo)