Exemplo n.º 1
0
    def flush(self):
        if self._wbuffer_len:
            data = b"".join(self._wbuffer)
            self._wbuffer.clear()
            self._wbuffer_len = 0
        else:
            data = b''

        try:
            future = self._stream.write(data)
        except Exception as e:
            raise TTransport.TTransportException(
                TTransport.TTransportException.END_OF_FILE, str(e))

        if future.done():
            return

        child_gr = greenlet.getcurrent()
        main = child_gr.parent
        assert main is not None, "Execut must be running in child greenlet"

        def write_callback(future):
            try:
                result = future.result()
            except Exception as e:
                return child_gr.throw(
                    TTransport.TTransportException(
                        TTransport.TTransportException.END_OF_FILE, str(e)))
            return child_gr.switch(result)

        self._loop.add_future(future, write_callback)
        return main.switch()
Exemplo n.º 2
0
    def _reconnectOrThrowException(self, maxRetries, retry_interval):
        errors = 0
        self.transport.close()

        while (errors < maxRetries):
            try:
                log.info('Attempting to reconnect')
                self.transport.open()
                log.info('Reconnection success')
                break
            except TTransport.TTransportException as e:
                log.error('Error - Reconnect fail')
                errors += 1

                if errors < maxRetries:
                    try:
                        log.info(
                            'Waiting for milliseconds for retrying connect')
                        time.sleep(retry_interval)

                    except Exception as e:
                        print e

        if errors >= maxRetries:
            raise TTransport.TTransportException("Connect failed")
Exemplo n.º 3
0
    def parseClientUnrouteableMessage(self, msg, channel, queue, thriftClient,
                                      iprot_factory=None):
        tr = TTransport.TMemoryBuffer(msg.content.body)
        if iprot_factory is None:
            iprot = self.factory.iprot_factory.getProtocol(tr)
        else:
            iprot = iprot_factory.getProtocol(tr)
        (fname, mtype, rseqid) = iprot.readMessageBegin()

        # log.msg('Got unroutable. fname = %r, rseqid = %s, mtype = %r, routing key = %r, client = %r, msg.content.body = %r' % (fname, rseqid, mtype, msg.routing_key, thriftClient, msg.content.body))

        try:
            d = thriftClient._reqs.pop(rseqid)
        except KeyError:
            # KeyError will occur if the remote Thrift method is oneway,
            # since there is no outstanding local request deferred for
            # oneway calls.
            pass
        else:
            d.errback(TTransport.TTransportException(
                type=TTransport.TTransportException.NOT_OPEN,
                message='Unrouteable message, routing key = %r calling function %r'
                % (msg.routing_key, fname)))

        d = queue.get()
        d.addCallback(self.parseClientUnrouteableMessage, channel, queue,
            thriftClient, iprot_factory=iprot_factory)
        d.addErrback(self.catchClosedClientQueue)
        d.addErrback(self.handleClientQueueError)
Exemplo n.º 4
0
 def write_callback(future):
     try:
         result = future.result()
     except Exception as e:
         return child_gr.throw(
             TTransport.TTransportException(
                 TTransport.TTransportException.END_OF_FILE, str(e)))
     return child_gr.switch(result)
Exemplo n.º 5
0
 def connect(self, host, port):
     socket = TSocket.TSocket(host=host, port=port)
     self.transport = TTransport.TFramedTransport(socket)
     protocol = TBinaryProtocol.TBinaryProtocol(trans=self.transport,
                                                strictRead=False,
                                                strictWrite=False)
     self.client = scribe.Client(iprot=protocol, oprot=protocol)
     self.connected = 1
     self.thriftEx = TTransport.TTransportException()
Exemplo n.º 6
0
def connectionLost(self, reason=connectionDone):
    while (self.client._reqs != {}):
        tmp = self.client._reqs
        self.client._reqs = {}
        for k, v in tmp.iteritems():
            tex = TTransport.TTransportException(
                type=TTransport.TTransportException.END_OF_FILE,
                message='Connection closed')
            v.errback(tex)
Exemplo n.º 7
0
 def connectionLost(self, reason=connectionDone):
     for (
             k,
             v,
     ) in self.client._reqs.iteritems():
         tex = TTransport.TTransportException(
             type=TTransport.TTransportException.END_OF_FILE,
             message='Connection closed')
         v.errback(tex)
Exemplo n.º 8
0
 def connectionLost(self, reason=connectionDone):
     if sys.version_info[0] >= 3:
         client_req_iter = self.client._reqs.items()
     else:
         client_req_iter = self.client._reqs.items()
     for _, v in client_req_iter:
         tex = TTransport.TTransportException(
             type=TTransport.TTransportException.END_OF_FILE,
             message=self._errormsg or 'Connection closed')
         v.errback(tex)
Exemplo n.º 9
0
        def read_callback(future):
            try:
                data = future.result()
            except Exception as e:
                return child_gr.throw(
                    TTransport.TTransportException(
                        TTransport.TTransportException.END_OF_FILE, str(e)))

            self._rbuffer = StringIO(partialread + data)
            return child_gr.switch(self._rbuffer)
Exemplo n.º 10
0
 def connectionLost(self, reason=connectionDone):
     if self.client:
         tex = TTransport.TTransportException(
             type=TTransport.TTransportException.END_OF_FILE,
             message='Connection closed (%s)' % reason)
         while self.client._reqs:
             _, v = self.client._reqs.popitem()
             v.errback(tex)
         del self.client._reqs
         self.client = None
Exemplo n.º 11
0
 def connectionMade(self):
     self._sendSASLMessage(self.START, self.sasl.mechanism)
     initial_message = yield deferToThread(self.sasl.process)
     self._sendSASLMessage(self.OK, initial_message)
     while True:
         status, challenge = yield self._receiveSASLMessage()
         if status == self.OK:
             response = yield deferToThread(self.sasl.process, challenge)
             self._sendSASLMessage(self.OK, response)
         elif status == self.COMPLETE:
             if not self.sasl.complete:
                 msg = "PROSES " \
                       "FINISH"
                 raise TTransport.TTransportException(msg, message=msg)
             else:
                 break
         else:
             msg = "STATUS: %d (%s)" % (status, challenge)
             raise TTransport.TTransportException(msg, message=msg)
     self._sasl_negotiation_deferred = None
     ThriftClientProtocol.connectionMade(self)
Exemplo n.º 12
0
 def connectionLost(self, reason):
     # the TTwisted version of this call does not account for the
     # possibility of other things happening during the errback.
     tex = TTransport.TTransportException(
         type=TTransport.TTransportException.END_OF_FILE,
         message='Connection closed (%s)' % reason)
     while self.client._reqs:
         k = iter(self.client._reqs).next()
         v = self.client._reqs.pop(k)
         v.errback(tex)
     del self.client._reqs
     del self.client
Exemplo n.º 13
0
 def connectionLost(self, reason=connectionDone):
     # the called errbacks can add items to our client's _reqs,
     # so we need to use a tmp, and iterate until no more requests
     # are added during errbacks
     if self.client:
         tex = TTransport.TTransportException(
             type=TTransport.TTransportException.END_OF_FILE,
             message='Connection closed (%s)' % reason)
         while self.client._reqs:
             _, v = self.client._reqs.popitem()
             v.errback(tex)
         del self.client._reqs
         self.client = None
Exemplo n.º 14
0
    def connectionMade(self):
        self._sendSASLMessage(self.START, self.sasl.mechanism)
        initial_message = yield deferToThread(self.sasl.process)
        self._sendSASLMessage(self.OK, initial_message)

        while True:
            status, challenge = yield self._receiveSASLMessage()
            if status == self.OK:
                response = yield deferToThread(self.sasl.process, challenge)
                self._sendSASLMessage(self.OK, response)
            elif status == self.COMPLETE:
                if not self.sasl.complete:
                    msg = "The seak.vassar_server.server erroneously indicated that SASL " \
                          "negotiation was complete"
                    raise TTransport.TTransportException(msg, message=msg)
                else:
                    break
            else:
                msg = "Bad SASL negotiation status: %d (%s)" % (status, challenge)
                raise TTransport.TTransportException(msg, message=msg)

        self._sasl_negotiation_deferred = None
        ThriftClientProtocol.connectionMade(self)
Exemplo n.º 15
0
        def read_callback(future):
            try:
                data = future.result()
            except Exception as e:
                return child_gr.throw(
                    TTransport.TTransportException(
                        TTransport.TTransportException.END_OF_FILE, str(e)))

            if partialread_len + len(data) == sz:
                return child_gr.switch(bytes(partialread + data))

            self._rbuffer = StringIO(data)
            return child_gr.switch(partialread +
                                   self._rbuffer.read(sz - partialread_len))
Exemplo n.º 16
0
    def write(self, data):
        data = to_tytes(data)
        self._wbuffer.append(data)
        self._wbuffer_len += len(data)
        if self._wbuffer_len >= self.DEFAULT_BUFFER:
            data = b"".join(self._wbuffer)
            self._wbuffer.clear()
            self._wbuffer_len = 0

            try:
                self._stream.write(data)
            except Exception as e:
                raise TTransport.TTransportException(
                    TTransport.TTransportException.END_OF_FILE, str(e))
def _wait_for_transport(transport, num_retries=20, sleep_sec=1):
    """Open thrift transport.

    transport Transport to open
    num_retries Number of times to try opening transport before giving up
    sleep_sec Interval in seconds between retries
    """
    for i in xrange(num_retries):
        try:
            transport.open()
            return
        except TTransport.TTransportException:
            time.sleep(sleep_sec)
    code = TTransport.TTransportException.TIMED_OUT
    raise TTransport.TTransportException(code, "Failed to open %s" % transport)
Exemplo n.º 18
0
  def test_performBackup_transport_exception(self, mock_wait, mock_client):
    mock_scheduler_client = mock.create_autospec(
      spec=scheduler_client.SchedulerClient,
      spec_set=False,
      instance=True)

    mock_thrift_client = mock.create_autospec(spec=AuroraAdmin.Client, instance=True)
    mock_thrift_client.performBackup.side_effect = TTransport.TTransportException('error')
    mock_scheduler_client.get_thrift_client.return_value = mock_thrift_client
    mock_client.get.return_value = mock_scheduler_client

    proxy = scheduler_client.SchedulerProxy(Cluster(name='local'))
    with pytest.raises(scheduler_client.SchedulerProxy.NotRetriableError):
      proxy.performBackup()

    assert mock_thrift_client.performBackup.call_count == 1
    assert not mock_wait.called
Exemplo n.º 19
0
  def test_getTierConfigs_transport_exception(self, mock_wait, mock_client):
    mock_scheduler_client = mock.create_autospec(
      spec=scheduler_client.SchedulerClient,
      spec_set=False,
      instance=True)

    mock_thrift_client = mock.create_autospec(spec=AuroraAdmin.Client, instance=True)
    mock_thrift_client.getTierConfigs.side_effect = [
      TTransport.TTransportException('error'),
      Response(responseCode=ResponseCode.OK)
    ]
    mock_scheduler_client.get_thrift_client.return_value = mock_thrift_client
    mock_client.get.return_value = mock_scheduler_client

    proxy = scheduler_client.SchedulerProxy(Cluster(name='local'))
    proxy.getTierConfigs(retry=True)

    assert mock_thrift_client.getTierConfigs.call_count == 2
    assert mock_wait.call_count == 1
Exemplo n.º 20
0
  def open(self):
    """Open a connection.

    This is mostly copy pasta from thrift.transport.TSocket.open, but adds call to _setup_tunnel().
    """
    try:
      res0 = self._resolveAddr()
      for res in res0:
        try:
          self.handle = self._setup_tunnel(res[4])
          self.handle.settimeout(self._timeout)
        except socket.error as e:
          if res is not res0[-1]:
            continue
          else:
            raise e
        break
    except socket.error as e:
      if self._unix_socket:
        message = 'Could not connect to socket %s' % self._unix_socket
      else:
        message = 'Could not connect to %s:%d' % (self.host, self.port)
      raise TTransport.TTransportException(type=TTransport.TTransportException.NOT_OPEN,
                                message=message)
Exemplo n.º 21
0
        symbol = ""
        price = 0.0
        size = 0


try:
    trans = TTransport.TFileObjectTransport(open("data", "wb"))
    trade = Trade()
    trade.symbol = "F"
    trade.price = 13.10
    trade.size = 2500
    trans.write(pickle.dumps(trade))
    trans.close()

    if len(sys.argv) == 2:
        raise TTransport.TTransportException(
            TTransport.TTransportException.NOT_OPEN, "cmd line ex")

    trans = TTransport.TFileObjectTransport(
        open("data", ("wb" if len(sys.argv) > 2 else "rb")))
    bstr = trans.read(128)
    trade = pickle.loads(bstr)
    print("Trade(%d): %s %d @ %f" %
          (len(bstr), trade.symbol, trade.size, trade.price))

except TTransport.TTransportException as tte:
    print("TTransportException(%d): %s" % (tte.type, tte))
except Thrift.TException as te:
    print("TException: %s" % te)
except Exception as e:
    print("Exception: %s %s" % (type(e), e))
except:
Exemplo n.º 22
0
 def readAll(self, sz):
     try:
         return self.read(sz)
     except Exception as e:
         raise TTransport.TTransportException(
             TTransport.TTransportException.END_OF_FILE, str(e))