auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/cpp/src/transport/TTransportUtils.h

@@ -1,287 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#ifndef _THRIFT_TRANSPORT_TTRANSPORTUTILS_H_
-#define _THRIFT_TRANSPORT_TTRANSPORTUTILS_H_ 1
-
-#include <cstdlib>
-#include <cstring>
-#include <string>
-#include <algorithm>
-#include <transport/TTransport.h>
-// Include the buffered transports that used to be defined here.
-#include <transport/TBufferTransports.h>
-#include <transport/TFileTransport.h>
-
-namespace apache { namespace thrift { namespace transport {
-
-/**
- * The null transport is a dummy transport that doesn't actually do anything.
- * It's sort of an analogy to /dev/null, you can never read anything from it
- * and it will let you write anything you want to it, though it won't actually
- * go anywhere.
- *
- */
-class TNullTransport : public TTransport {
- public:
-  TNullTransport() {}
-
-  ~TNullTransport() {}
-
-  bool isOpen() {
-    return true;
-  }
-
-  void open() {}
-
-  void write(const uint8_t* /* buf */, uint32_t /* len */) {
-    return;
-  }
-
-};
-
-
-/**
- * TPipedTransport. This transport allows piping of a request from one
- * transport to another either when readEnd() or writeEnd(). The typical
- * use case for this is to log a request or a reply to disk.
- * The underlying buffer expands to a keep a copy of the entire
- * request/response.
- *
- */
-class TPipedTransport : virtual public TTransport {
- public:
-  TPipedTransport(boost::shared_ptr<TTransport> srcTrans,
-                  boost::shared_ptr<TTransport> dstTrans) :
-    srcTrans_(srcTrans),
-    dstTrans_(dstTrans),
-    rBufSize_(512), rPos_(0), rLen_(0),
-    wBufSize_(512), wLen_(0) {
-
-    // default is to to pipe the request when readEnd() is called
-    pipeOnRead_ = true;
-    pipeOnWrite_ = false;
-
-    rBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * rBufSize_);
-    wBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * wBufSize_);
-  }
-
-  TPipedTransport(boost::shared_ptr<TTransport> srcTrans,
-                  boost::shared_ptr<TTransport> dstTrans,
-                  uint32_t sz) :
-    srcTrans_(srcTrans),
-    dstTrans_(dstTrans),
-    rBufSize_(512), rPos_(0), rLen_(0),
-    wBufSize_(sz), wLen_(0) {
-
-    rBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * rBufSize_);
-    wBuf_ = (uint8_t*) std::malloc(sizeof(uint8_t) * wBufSize_);
-  }
-
-  ~TPipedTransport() {
-    std::free(rBuf_);
-    std::free(wBuf_);
-  }
-
-  bool isOpen() {
-    return srcTrans_->isOpen();
-  }
-
-  bool peek() {
-    if (rPos_ >= rLen_) {
-      // Double the size of the underlying buffer if it is full
-      if (rLen_ == rBufSize_) {
-        rBufSize_ *=2;
-        rBuf_ = (uint8_t *)std::realloc(rBuf_, sizeof(uint8_t) * rBufSize_);
-      }
-
-      // try to fill up the buffer
-      rLen_ += srcTrans_->read(rBuf_+rPos_, rBufSize_ - rPos_);
-    }
-    return (rLen_ > rPos_);
-  }
-
-
-  void open() {
-    srcTrans_->open();
-  }
-
-  void close() {
-    srcTrans_->close();
-  }
-
-  void setPipeOnRead(bool pipeVal) {
-    pipeOnRead_ = pipeVal;
-  }
-
-  void setPipeOnWrite(bool pipeVal) {
-    pipeOnWrite_ = pipeVal;
-  }
-
-  uint32_t read(uint8_t* buf, uint32_t len);
-
-  void readEnd() {
-
-    if (pipeOnRead_) {
-      dstTrans_->write(rBuf_, rPos_);
-      dstTrans_->flush();
-    }
-
-    srcTrans_->readEnd();
-
-    // If requests are being pipelined, copy down our read-ahead data,
-    // then reset our state.
-    int read_ahead = rLen_ - rPos_;
-    memcpy(rBuf_, rBuf_ + rPos_, read_ahead);
-    rPos_ = 0;
-    rLen_ = read_ahead;
-  }
-
-  void write(const uint8_t* buf, uint32_t len);
-
-  void writeEnd() {
-    if (pipeOnWrite_) {
-      dstTrans_->write(wBuf_, wLen_);
-      dstTrans_->flush();
-    }
-  }
-
-  void flush();
-
-  boost::shared_ptr<TTransport> getTargetTransport() {
-    return dstTrans_;
-  }
-
- protected:
-  boost::shared_ptr<TTransport> srcTrans_;
-  boost::shared_ptr<TTransport> dstTrans_;
-
-  uint8_t* rBuf_;
-  uint32_t rBufSize_;
-  uint32_t rPos_;
-  uint32_t rLen_;
-
-  uint8_t* wBuf_;
-  uint32_t wBufSize_;
-  uint32_t wLen_;
-
-  bool pipeOnRead_;
-  bool pipeOnWrite_;
-};
-
-
-/**
- * Wraps a transport into a pipedTransport instance.
- *
- */
-class TPipedTransportFactory : public TTransportFactory {
- public:
-  TPipedTransportFactory() {}
-  TPipedTransportFactory(boost::shared_ptr<TTransport> dstTrans) {
-    initializeTargetTransport(dstTrans);
-  }
-  virtual ~TPipedTransportFactory() {}
-
-  /**
-   * Wraps the base transport into a piped transport.
-   */
-  virtual boost::shared_ptr<TTransport> getTransport(boost::shared_ptr<TTransport> srcTrans) {
-    return boost::shared_ptr<TTransport>(new TPipedTransport(srcTrans, dstTrans_));
-  }
-
-  virtual void initializeTargetTransport(boost::shared_ptr<TTransport> dstTrans) {
-    if (dstTrans_.get() == NULL) {
-      dstTrans_ = dstTrans;
-    } else {
-      throw TException("Target transport already initialized");
-    }
-  }
-
- protected:
-  boost::shared_ptr<TTransport> dstTrans_;
-};
-
-/**
- * TPipedFileTransport. This is just like a TTransport, except that
- * it is a templatized class, so that clients who rely on a specific
- * TTransport can still access the original transport.
- *
- */
-class TPipedFileReaderTransport : public TPipedTransport,
-                                  public TFileReaderTransport {
- public:
-  TPipedFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans, boost::shared_ptr<TTransport> dstTrans);
-
-  ~TPipedFileReaderTransport();
-
-  // TTransport functions
-  bool isOpen();
-  bool peek();
-  void open();
-  void close();
-  uint32_t read(uint8_t* buf, uint32_t len);
-  uint32_t readAll(uint8_t* buf, uint32_t len);
-  void readEnd();
-  void write(const uint8_t* buf, uint32_t len);
-  void writeEnd();
-  void flush();
-
-  // TFileReaderTransport functions
-  int32_t getReadTimeout();
-  void setReadTimeout(int32_t readTimeout);
-  uint32_t getNumChunks();
-  uint32_t getCurChunk();
-  void seekToChunk(int32_t chunk);
-  void seekToEnd();
-
- protected:
-  // shouldn't be used
-  TPipedFileReaderTransport();
-  boost::shared_ptr<TFileReaderTransport> srcTrans_;
-};
-
-/**
- * Creates a TPipedFileReaderTransport from a filepath and a destination transport
- *
- */
-class TPipedFileReaderTransportFactory : public TPipedTransportFactory {
- public:
-  TPipedFileReaderTransportFactory() {}
-  TPipedFileReaderTransportFactory(boost::shared_ptr<TTransport> dstTrans)
-    : TPipedTransportFactory(dstTrans)
-  {}
-  virtual ~TPipedFileReaderTransportFactory() {}
-
-  boost::shared_ptr<TTransport> getTransport(boost::shared_ptr<TTransport> srcTrans) {
-    boost::shared_ptr<TFileReaderTransport> pFileReaderTransport = boost::dynamic_pointer_cast<TFileReaderTransport>(srcTrans);
-    if (pFileReaderTransport.get() != NULL) {
-      return getFileReaderTransport(pFileReaderTransport);
-    } else {
-      return boost::shared_ptr<TTransport>();
-    }
-  }
-
-  boost::shared_ptr<TFileReaderTransport> getFileReaderTransport(boost::shared_ptr<TFileReaderTransport> srcTrans) {
-    return boost::shared_ptr<TFileReaderTransport>(new TPipedFileReaderTransport(srcTrans, dstTrans_));
-  }
-};
-
-}}} // apache::thrift::transport
-
-#endif // #ifndef _THRIFT_TRANSPORT_TTRANSPORTUTILS_H_

data/vendor/gems/thrift/lib/cpp/src/transport/TZlibTransport.cpp

@@ -1,299 +0,0 @@
-/*
- * Licensed to the Apache Software Foundation (ASF) under one
- * or more contributor license agreements. See the NOTICE file
- * distributed with this work for additional information
- * regarding copyright ownership. The ASF licenses this file
- * to you under the Apache License, Version 2.0 (the
- * "License"); you may not use this file except in compliance
- * with the License. You may obtain a copy of the License at
- *
- *   http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing,
- * software distributed under the License is distributed on an
- * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
- * KIND, either express or implied. See the License for the
- * specific language governing permissions and limitations
- * under the License.
- */
-
-#include <cassert>
-#include <cstring>
-#include <algorithm>
-#include <transport/TZlibTransport.h>
-#include <zlib.h>
-
-using std::string;
-
-namespace apache { namespace thrift { namespace transport {
-
-// Don't call this outside of the constructor.
-void TZlibTransport::initZlib() {
-  int rv;
-  bool r_init = false;
-  try {
-    rstream_ = new z_stream;
-    wstream_ = new z_stream;
-
-    rstream_->zalloc = Z_NULL;
-    wstream_->zalloc = Z_NULL;
-    rstream_->zfree  = Z_NULL;
-    wstream_->zfree  = Z_NULL;
-    rstream_->opaque = Z_NULL;
-    wstream_->opaque = Z_NULL;
-
-    rstream_->next_in   = crbuf_;
-    wstream_->next_in   = uwbuf_;
-    rstream_->next_out  = urbuf_;
-    wstream_->next_out  = cwbuf_;
-    rstream_->avail_in  = 0;
-    wstream_->avail_in  = 0;
-    rstream_->avail_out = urbuf_size_;
-    wstream_->avail_out = cwbuf_size_;
-
-    rv = inflateInit(rstream_);
-    checkZlibRv(rv, rstream_->msg);
-
-    // Have to set this flag so we know whether to de-initialize.
-    r_init = true;
-
-    rv = deflateInit(wstream_, Z_DEFAULT_COMPRESSION);
-    checkZlibRv(rv, wstream_->msg);
-  }
-
-  catch (...) {
-    if (r_init) {
-      rv = inflateEnd(rstream_);
-      checkZlibRvNothrow(rv, rstream_->msg);
-    }
-    // There is no way we can get here if wstream_ was initialized.
-
-    throw;
-  }
-}
-
-inline void TZlibTransport::checkZlibRv(int status, const char* message) {
-  if (status != Z_OK) {
-    throw TZlibTransportException(status, message);
-  }
-}
-
-inline void TZlibTransport::checkZlibRvNothrow(int status, const char* message) {
-  if (status != Z_OK) {
-    string output = "TZlibTransport: zlib failure in destructor: " +
-      TZlibTransportException::errorMessage(status, message);
-    GlobalOutput(output.c_str());
-  }
-}
-
-TZlibTransport::~TZlibTransport() {
-  int rv;
-  rv = inflateEnd(rstream_);
-  checkZlibRvNothrow(rv, rstream_->msg);
-  rv = deflateEnd(wstream_);
-  checkZlibRvNothrow(rv, wstream_->msg);
-
-  delete[] urbuf_;
-  delete[] crbuf_;
-  delete[] uwbuf_;
-  delete[] cwbuf_;
-  delete rstream_;
-  delete wstream_;
-}
-
-bool TZlibTransport::isOpen() {
-  return (readAvail() > 0) || transport_->isOpen();
-}
-
-// READING STRATEGY
-//
-// We have two buffers for reading: one containing the compressed data (crbuf_)
-// and one containing the uncompressed data (urbuf_).  When read is called,
-// we repeat the following steps until we have satisfied the request:
-// - Copy data from urbuf_ into the caller's buffer.
-// - If we had enough, return.
-// - If urbuf_ is empty, read some data into it from the underlying transport.
-// - Inflate data from crbuf_ into urbuf_.
-//
-// In standalone objects, we set input_ended_ to true when inflate returns
-// Z_STREAM_END.  This allows to make sure that a checksum was verified.
-
-inline int TZlibTransport::readAvail() {
-  return urbuf_size_ - rstream_->avail_out - urpos_;
-}
-
-uint32_t TZlibTransport::read(uint8_t* buf, uint32_t len) {
-  int need = len;
-
-  // TODO(dreiss): Skip urbuf on big reads.
-
-  while (true) {
-    // Copy out whatever we have available, then give them the min of
-    // what we have and what they want, then advance indices.
-    int give = std::min(readAvail(), need);
-    memcpy(buf, urbuf_ + urpos_, give);
-    need -= give;
-    buf += give;
-    urpos_ += give;
-
-    // If they were satisfied, we are done.
-    if (need == 0) {
-      return len;
-    }
-
-    // If we get to this point, we need to get some more data.
-
-    // If zlib has reported the end of a stream, we can't really do any more.
-    if (input_ended_) {
-      return len - need;
-    }
-
-    // The uncompressed read buffer is empty, so reset the stream fields.
-    rstream_->next_out  = urbuf_;
-    rstream_->avail_out = urbuf_size_;
-    urpos_ = 0;
-
-    // If we don't have any more compressed data available,
-    // read some from the underlying transport.
-    if (rstream_->avail_in == 0) {
-      uint32_t got = transport_->read(crbuf_, crbuf_size_);
-      if (got == 0) {
-        return len - need;
-      }
-      rstream_->next_in  = crbuf_;
-      rstream_->avail_in = got;
-    }
-
-    // We have some compressed data now.  Uncompress it.
-    int zlib_rv = inflate(rstream_, Z_SYNC_FLUSH);
-
-    if (zlib_rv == Z_STREAM_END) {
-      if (standalone_) {
-        input_ended_ = true;
-      }
-    } else {
-      checkZlibRv(zlib_rv, rstream_->msg);
-    }
-
-    // Okay.  The read buffer should have whatever we can give it now.
-    // Loop back to the start and try to give some more.
-  }
-}
-
-
-// WRITING STRATEGY
-//
-// We buffer up small writes before sending them to zlib, so our logic is:
-// - Is the write big?
-//   - Send the buffer to zlib.
-//   - Send this data to zlib.
-// - Is the write small?
-//   - Is there insufficient space in the buffer for it?
-//     - Send the buffer to zlib.
-//   - Copy the data to the buffer.
-//
-// We have two buffers for writing also: the uncompressed buffer (mentioned
-// above) and the compressed buffer.  When sending data to zlib we loop over
-// the following until the source (uncompressed buffer or big write) is empty:
-// - Is there no more space in the compressed buffer?
-//   - Write the compressed buffer to the underlying transport.
-// - Deflate from the source into the compressed buffer.
-
-void TZlibTransport::write(const uint8_t* buf, uint32_t len) {
-  // zlib's "deflate" function has enough logic in it that I think
-  // we're better off (performance-wise) buffering up small writes.
-  if ((int)len > MIN_DIRECT_DEFLATE_SIZE) {
-    flushToZlib(uwbuf_, uwpos_);
-    uwpos_ = 0;
-    flushToZlib(buf, len);
-  } else if (len > 0) {
-    if (uwbuf_size_ - uwpos_ < (int)len) {
-      flushToZlib(uwbuf_, uwpos_);
-      uwpos_ = 0;
-    }
-    memcpy(uwbuf_ + uwpos_, buf, len);
-    uwpos_ += len;
-  }
-}
-
-void TZlibTransport::flush()  {
-  flushToZlib(uwbuf_, uwpos_, true);
-  assert((int)wstream_->avail_out != cwbuf_size_);
-  transport_->write(cwbuf_, cwbuf_size_ - wstream_->avail_out);
-  transport_->flush();
-}
-
-void TZlibTransport::flushToZlib(const uint8_t* buf, int len, bool finish) {
-  int flush = (finish ? Z_FINISH : Z_NO_FLUSH);
-
-  wstream_->next_in  = const_cast<uint8_t*>(buf);
-  wstream_->avail_in = len;
-
-  while (wstream_->avail_in > 0 || finish) {
-    // If our ouput buffer is full, flush to the underlying transport.
-    if (wstream_->avail_out == 0) {
-      transport_->write(cwbuf_, cwbuf_size_);
-      wstream_->next_out  = cwbuf_;
-      wstream_->avail_out = cwbuf_size_;
-    }
-
-    int zlib_rv = deflate(wstream_, flush);
-
-    if (finish && zlib_rv == Z_STREAM_END) {
-      assert(wstream_->avail_in == 0);
-      break;
-    }
-
-    checkZlibRv(zlib_rv, wstream_->msg);
-  }
-}
-
-const uint8_t* TZlibTransport::borrow(uint8_t* buf, uint32_t* len) {
-  // Don't try to be clever with shifting buffers.
-  // If we have enough data, give a pointer to it,
-  // otherwise let the protcol use its slow path.
-  if (readAvail() >= (int)*len) {
-    *len = (uint32_t)readAvail();
-    return urbuf_ + urpos_;
-  }
-  return NULL;
-}
-
-void TZlibTransport::consume(uint32_t len) {
-  if (readAvail() >= (int)len) {
-    urpos_ += len;
-  } else {
-    throw TTransportException(TTransportException::BAD_ARGS,
-                              "consume did not follow a borrow.");
-  }
-}
-
-void TZlibTransport::verifyChecksum() {
-  if (!standalone_) {
-    throw TTransportException(
-        TTransportException::BAD_ARGS,
-        "TZLibTransport can only verify checksums for standalone objects.");
-  }
-
-  if (!input_ended_) {
-    // This should only be called when reading is complete,
-    // but it's possible that the whole checksum has not been fed to zlib yet.
-    // We try to read an extra byte here to force zlib to finish the stream.
-    // It might not always be easy to "unread" this byte,
-    // but we throw an exception if we get it, which is not really
-    // a recoverable error, so it doesn't matter.
-    uint8_t buf[1];
-    uint32_t got = this->read(buf, sizeof(buf));
-    if (got || !input_ended_) {
-      throw TTransportException(
-          TTransportException::CORRUPTED_DATA,
-          "Zlib stream not complete.");
-    }
-  }
-
-  // If the checksum had been bad, we would have gotten an error while
-  // inflating.
-}
-
-
-}}} // apache::thrift::transport