def invoke_reliable(self, frame, content=None): if not self.synchronous: future = Future() self.request(frame, future.put_response, content) if not frame.method.responses: return None else: return future self.request(frame, self.queue_response, content) if not frame.method.responses: if self.use_execution_layer and frame.method_type.is_l4_command(): self.execution_sync() self.completion.wait() if self._closed: raise Closed(self.reason) return None try: resp = self.responses.get() if resp.method_type.content: return Message(self, resp, read_content(self.responses)) else: return Message(self, resp) except QueueClosed, e: if self._closed: raise Closed(self.reason) else: raise e
def read(self, n): while len(self.rx_buf) < n: try: # QPID-5808: never consume more than n bytes from the socket, # otherwise the extra bytes are discarded. s = self.sock.recv(n - len(self.rx_buf)) if self.security_layer_rx: try: s = self.security_layer_rx.decode(s) except SASLError, e: raise Closed(str(e)) except socket.timeout: if self.aborted(): raise Closed() else: continue except socket.error, e: if self.rx_buf != "": raise e else: raise Closed() if len(s) == 0: raise Closed() self.rx_buf += s raw.debug("RECV %r", s)
def invoke_method(self, frame, content = None): if frame.method.result: cmd_id = self.completion.command_id future = Future() self.futures[cmd_id] = future if frame.method.klass.name == "basic" and frame.method.name == "publish": self._flow_control_wait_condition.acquire() try: self.check_flow_control() self.write(frame, content) finally: self._flow_control_wait_condition.release() else: self.write(frame, content) try: # here we depend on all nowait fields being named nowait f = frame.method.fields.byname["nowait"] nowait = frame.args[frame.method.fields.index(f)] except KeyError: nowait = False try: if not nowait and frame.method.responses: resp = self.responses.get() if resp.method.content: content = read_content(self.responses) else: content = None if resp.method in frame.method.responses: return Message(self, resp, content) else: raise ValueError(resp) elif frame.method.result: if self.synchronous: fr = future.get_response(timeout=10) if self._closed: raise Closed(self.reason) return fr else: return future elif self.synchronous and not frame.method.response \ and self.use_execution_layer and frame.method.is_l4_command(): self.execution_sync() completed = self.completion.wait(timeout=10) if self._closed: raise Closed(self.reason) if not completed: self.closed("Timed-out waiting for completion of %s" % frame) except QueueClosed, e: if self._closed: raise Closed(self.reason) else: raise e
def get(self, block=True, timeout=None): result = BaseQueue.get(self, block, timeout) if result == Queue.END: # this guarantees that any other waiting threads or any future # calls to get will also result in a Closed exception self.put(Queue.END) raise Closed(self.error) else: return result
def write(self, frame, content=None): if self._closed: raise Closed(self.reason) frame.channel = self.id self.outgoing.put(frame) if (isinstance(frame, (Method, Request)) and content == None and frame.method_type.content): content = Content() if content != None: self.write_content(frame.method_type.klass, content)
def flush(self): self.sock_lock.acquire() try: if self.security_layer_tx: try: cipher_buf = self.security_layer_tx.encode(self.tx_buf) except SASLError, e: raise Closed(str(e)) self._write(cipher_buf) else:
def connection_start(self, ch, start): mech_list = "" for mech in start.mechanisms: if (not self.acceptableMechanisms) or mech in self.acceptableMechanisms: mech_list += str(mech) + " " mech = None initial = None try: mech, initial = self.sasl.start(mech_list) except Exception, e: raise Closed(str(e))
def _write(self, buf): while buf: try: n = self.sock.send(buf) except socket.timeout: if self.aborted(): raise Closed() else: continue raw.debug("SENT %r", buf[:n]) buf = buf[n:]
def connection_close(self, ch, close): self.connection.close_code = (close.reply_code, close.reply_text) ch.connection_close_ok() raise Closed(close.reply_text)
def connection_secure(self, ch, secure): resp = None try: resp = self.sasl.step(secure.challenge) except Exception, e: raise Closed(str(e))