auser-poolparty 1.3.1 → 1.3.2

data/vendor/gems/thrift/lib/cpp/src/concurrency/test/ThreadManagerTests.h

@@ -1,379 +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 <config.h>
-#include <concurrency/ThreadManager.h>
-#include <concurrency/PosixThreadFactory.h>
-#include <concurrency/Monitor.h>
-#include <concurrency/Util.h>
-
-#include <assert.h>
-#include <set>
-#include <iostream>
-#include <set>
-#include <stdint.h>
-
-namespace apache { namespace thrift { namespace concurrency { namespace test {
-
-using namespace apache::thrift::concurrency;
-
-/**
- * ThreadManagerTests class
- *
- * @version $Id:$
- */
-class ThreadManagerTests {
-
-public:
-
-  static const double ERROR;
-
-  class Task: public Runnable {
-
-  public:
-
-    Task(Monitor& monitor, size_t& count, int64_t timeout) :
-      _monitor(monitor),
-      _count(count),
-      _timeout(timeout),
-      _done(false) {}
-
-    void run() {
-
-      _startTime = Util::currentTime();
-
-      {
-        Synchronized s(_sleep);
-
-        try {
-          _sleep.wait(_timeout);
-        } catch(TimedOutException& e) {
-          ;
-        }catch(...) {
-          assert(0);
-        }
-      }
-
-      _endTime = Util::currentTime();
-
-      _done = true;
-
-      {
-        Synchronized s(_monitor);
-
-        // std::cout << "Thread " << _count << " completed " << std::endl;
-
-        _count--;
-
-        if (_count == 0) {
-
-          _monitor.notify();
-        }
-      }
-    }
-
-    Monitor& _monitor;
-    size_t& _count;
-    int64_t _timeout;
-    int64_t _startTime;
-    int64_t _endTime;
-    bool _done;
-    Monitor _sleep;
-  };
-
-  /**
-   * Dispatch count tasks, each of which blocks for timeout milliseconds then
-   * completes. Verify that all tasks completed and that thread manager cleans
-   * up properly on delete.
-   */
-  bool loadTest(size_t count=100, int64_t timeout=100LL, size_t workerCount=4) {
-
-    Monitor monitor;
-
-    size_t activeCount = count;
-
-    shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount);
-
-    shared_ptr<PosixThreadFactory> threadFactory = shared_ptr<PosixThreadFactory>(new PosixThreadFactory());
-
-    threadFactory->setPriority(PosixThreadFactory::HIGHEST);
-
-    threadManager->threadFactory(threadFactory);
-
-    threadManager->start();
-
-    std::set<shared_ptr<ThreadManagerTests::Task> > tasks;
-
-    for (size_t ix = 0; ix < count; ix++) {
-
-      tasks.insert(shared_ptr<ThreadManagerTests::Task>(new ThreadManagerTests::Task(monitor, activeCount, timeout)));
-    }
-
-    int64_t time00 = Util::currentTime();
-
-    for (std::set<shared_ptr<ThreadManagerTests::Task> >::iterator ix = tasks.begin(); ix != tasks.end(); ix++) {
-
-        threadManager->add(*ix);
-    }
-
-    {
-      Synchronized s(monitor);
-
-      while(activeCount > 0) {
-
-        monitor.wait();
-      }
-    }
-
-    int64_t time01 = Util::currentTime();
-
-    int64_t firstTime = 9223372036854775807LL;
-    int64_t lastTime = 0;
-
-    double averageTime = 0;
-    int64_t minTime = 9223372036854775807LL;
-    int64_t maxTime = 0;
-
-    for (std::set<shared_ptr<ThreadManagerTests::Task> >::iterator ix = tasks.begin(); ix != tasks.end(); ix++) {
-
-      shared_ptr<ThreadManagerTests::Task> task = *ix;
-
-      int64_t delta = task->_endTime - task->_startTime;
-
-      assert(delta > 0);
-
-      if (task->_startTime < firstTime) {
-        firstTime = task->_startTime;
-      }
-
-      if (task->_endTime > lastTime) {
-        lastTime = task->_endTime;
-      }
-
-      if (delta < minTime) {
-        minTime = delta;
-      }
-
-      if (delta > maxTime) {
-        maxTime = delta;
-      }
-
-      averageTime+= delta;
-    }
-
-    averageTime /= count;
-
-    std::cout << "\t\t\tfirst start: " << firstTime << "ms Last end: " << lastTime << "ms min: " << minTime << "ms max: " << maxTime << "ms average: " << averageTime << "ms" << std::endl;
-
-    double expectedTime = ((count + (workerCount - 1)) / workerCount) * timeout;
-
-    double error = ((time01 - time00) - expectedTime) / expectedTime;
-
-    if (error < 0) {
-      error*= -1.0;
-    }
-
-    bool success = error < ERROR;
-
-    std::cout << "\t\t\t" << (success ? "Success" : "Failure") << "! expected time: " << expectedTime << "ms elapsed time: "<< time01 - time00 << "ms error%: " << error * 100.0 << std::endl;
-
-    return success;
-  }
-
-  class BlockTask: public Runnable {
-
-  public:
-
-    BlockTask(Monitor& monitor, Monitor& bmonitor, size_t& count) :
-      _monitor(monitor),
-      _bmonitor(bmonitor),
-      _count(count) {}
-
-    void run() {
-      {
-        Synchronized s(_bmonitor);
-
-        _bmonitor.wait();
-
-      }
-
-      {
-        Synchronized s(_monitor);
-
-        _count--;
-
-        if (_count == 0) {
-
-          _monitor.notify();
-        }
-      }
-    }
-
-    Monitor& _monitor;
-    Monitor& _bmonitor;
-    size_t& _count;
-  };
-
-  /**
-   * Block test.  Create pendingTaskCountMax tasks.  Verify that we block adding the
-   * pendingTaskCountMax + 1th task.  Verify that we unblock when a task completes */
-
-  bool blockTest(int64_t timeout=100LL, size_t workerCount=2) {
-
-    bool success = false;
-
-    try {
-
-      Monitor bmonitor;
-      Monitor monitor;
-
-      size_t pendingTaskMaxCount = workerCount;
-
-      size_t activeCounts[] = {workerCount, pendingTaskMaxCount, 1};
-
-      shared_ptr<ThreadManager> threadManager = ThreadManager::newSimpleThreadManager(workerCount, pendingTaskMaxCount);
-
-      shared_ptr<PosixThreadFactory> threadFactory = shared_ptr<PosixThreadFactory>(new PosixThreadFactory());
-
-      threadFactory->setPriority(PosixThreadFactory::HIGHEST);
-
-      threadManager->threadFactory(threadFactory);
-
-      threadManager->start();
-
-      std::set<shared_ptr<ThreadManagerTests::BlockTask> > tasks;
-
-      for (size_t ix = 0; ix < workerCount; ix++) {
-
-        tasks.insert(shared_ptr<ThreadManagerTests::BlockTask>(new ThreadManagerTests::BlockTask(monitor, bmonitor,activeCounts[0])));
-      }
-
-      for (size_t ix = 0; ix < pendingTaskMaxCount; ix++) {
-
-        tasks.insert(shared_ptr<ThreadManagerTests::BlockTask>(new ThreadManagerTests::BlockTask(monitor, bmonitor,activeCounts[1])));
-      }
-
-      for (std::set<shared_ptr<ThreadManagerTests::BlockTask> >::iterator ix = tasks.begin(); ix != tasks.end(); ix++) {
-        threadManager->add(*ix);
-      }
-
-      if(!(success = (threadManager->totalTaskCount() == pendingTaskMaxCount + workerCount))) {
-        throw TException("Unexpected pending task count");
-      }
-
-      shared_ptr<ThreadManagerTests::BlockTask> extraTask(new ThreadManagerTests::BlockTask(monitor, bmonitor, activeCounts[2]));
-
-      try {
-        threadManager->add(extraTask, 1);
-        throw TException("Unexpected success adding task in excess of pending task count");
-      } catch(TooManyPendingTasksException& e) {
-        throw TException("Should have timed out adding task in excess of pending task count");
-      } catch(TimedOutException& e) {
-        // Expected result
-      }
-
-      try {
-        threadManager->add(extraTask, -1);
-        throw TException("Unexpected success adding task in excess of pending task count");
-      } catch(TimedOutException& e) {
-        throw TException("Unexpected timeout adding task in excess of pending task count");
-      } catch(TooManyPendingTasksException& e) {
-        // Expected result
-      }
-
-      std::cout << "\t\t\t" << "Pending tasks " << threadManager->pendingTaskCount()  << std::endl;
-
-      {
-        Synchronized s(bmonitor);
-
-        bmonitor.notifyAll();
-      }
-
-      {
-        Synchronized s(monitor);
-
-        while(activeCounts[0] != 0) {
-          monitor.wait();
-        }
-      }
-
-      std::cout << "\t\t\t" << "Pending tasks " << threadManager->pendingTaskCount() << std::endl;
-
-      try {
-        threadManager->add(extraTask, 1);
-      } catch(TimedOutException& e) {
-        std::cout << "\t\t\t" << "add timed out unexpectedly"  << std::endl;
-        throw TException("Unexpected timeout adding task");
-
-      } catch(TooManyPendingTasksException& e) {
-        std::cout << "\t\t\t" << "add encountered too many pending exepctions" << std::endl;
-        throw TException("Unexpected timeout adding task");
-      }
-
-      // Wake up tasks that were pending before and wait for them to complete
-
-      {
-        Synchronized s(bmonitor);
-
-        bmonitor.notifyAll();
-      }
-
-      {
-        Synchronized s(monitor);
-
-        while(activeCounts[1] != 0) {
-          monitor.wait();
-        }
-      }
-
-      // Wake up the extra task and wait for it to complete
-
-      {
-        Synchronized s(bmonitor);
-
-        bmonitor.notifyAll();
-      }
-
-      {
-        Synchronized s(monitor);
-
-        while(activeCounts[2] != 0) {
-          monitor.wait();
-        }
-      }
-
-      if(!(success = (threadManager->totalTaskCount() == 0))) {
-        throw TException("Unexpected pending task count");
-      }
-
-    } catch(TException& e) {
-      std::cout << "ERROR: " << e.what() << std::endl;
-    }
-
-    std::cout << "\t\t\t" << (success ? "Success" : "Failure") << std::endl;
-    return success;
- }
-};
-
-const double ThreadManagerTests::ERROR = .20;
-
-}}}} // apache::thrift::concurrency
-
-using namespace apache::thrift::concurrency::test;
-

data/vendor/gems/thrift/lib/cpp/src/concurrency/test/TimerManagerTests.h

@@ -1,155 +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 <concurrency/TimerManager.h>
-#include <concurrency/PosixThreadFactory.h>
-#include <concurrency/Monitor.h>
-#include <concurrency/Util.h>
-
-#include <assert.h>
-#include <iostream>
-
-namespace apache { namespace thrift { namespace concurrency { namespace test {
-
-using namespace apache::thrift::concurrency;
-
-/**
- * ThreadManagerTests class
- *
- * @version $Id:$
- */
-class TimerManagerTests {
-
- public:
-
-  static const double ERROR;
-
-  class Task: public Runnable {
-   public:
-
-    Task(Monitor& monitor, int64_t timeout) :
-      _timeout(timeout),
-      _startTime(Util::currentTime()),
-      _monitor(monitor),
-      _success(false),
-      _done(false) {}
-
-    ~Task() { std::cerr << this << std::endl; }
-
-    void run() {
-
-      _endTime = Util::currentTime();
-
-      // Figure out error percentage
-
-      int64_t delta = _endTime - _startTime;
-
-
-      delta = delta > _timeout ?  delta - _timeout : _timeout - delta;
-
-      float error = delta / _timeout;
-
-      if(error < ERROR) {
-        _success = true;
-      }
-
-      _done = true;
-
-      std::cout << "\t\t\tTimerManagerTests::Task[" << this << "] done" << std::endl; //debug
-
-      {Synchronized s(_monitor);
-        _monitor.notifyAll();
-      }
-    }
-
-    int64_t _timeout;
-    int64_t _startTime;
-    int64_t _endTime;
-    Monitor& _monitor;
-    bool _success;
-    bool _done;
-  };
-
-  /**
-   * This test creates two tasks and waits for the first to expire within 10%
-   * of the expected expiration time. It then verifies that the timer manager
-   * properly clean up itself and the remaining orphaned timeout task when the
-   * manager goes out of scope and its destructor is called.
-   */
-  bool test00(int64_t timeout=1000LL) {
-
-    shared_ptr<TimerManagerTests::Task> orphanTask = shared_ptr<TimerManagerTests::Task>(new TimerManagerTests::Task(_monitor, 10 * timeout));
-
-    {
-
-      TimerManager timerManager;
-
-      timerManager.threadFactory(shared_ptr<PosixThreadFactory>(new PosixThreadFactory()));
-
-      timerManager.start();
-
-      assert(timerManager.state() == TimerManager::STARTED);
-
-      // Don't create task yet, because its constructor sets the expected completion time, and we
-      // need to delay between inserting the two tasks into the run queue.
-      shared_ptr<TimerManagerTests::Task> task;
-
-      {
-        Synchronized s(_monitor);
-
-        timerManager.add(orphanTask, 10 * timeout);
-
-        try {
-          // Wait for 1 second in order to give timerManager a chance to start sleeping in response
-          // to adding orphanTask. We need to do this so we can verify that adding the second task
-          // kicks the dispatcher out of the current wait and starts the new 1 second wait.
-          _monitor.wait (1000);
-          assert (0 == "ERROR: This wait should time out. TimerManager dispatcher may have a problem.");
-        } catch (TimedOutException &ex) {
-        }
-
-        task.reset (new TimerManagerTests::Task(_monitor, timeout));
-
-        timerManager.add(task, timeout);
-
-        _monitor.wait();
-      }
-
-      assert(task->_done);
-
-
-      std::cout << "\t\t\t" << (task->_success ? "Success" : "Failure") << "!" << std::endl;
-    }
-
-    // timerManager.stop(); This is where it happens via destructor
-
-    assert(!orphanTask->_done);
-
-    return true;
-  }
-
-  friend class TestTask;
-
-  Monitor _monitor;
-};
-
-const double TimerManagerTests::ERROR = .20;
-
-}}}} // apache::thrift::concurrency
-

data/vendor/gems/thrift/lib/cpp/src/processor/PeekProcessor.cpp

@@ -1,122 +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 "PeekProcessor.h"
-
-using namespace apache::thrift::transport;
-using namespace apache::thrift::protocol;
-using namespace apache::thrift;
-
-namespace apache { namespace thrift { namespace processor {
-
-PeekProcessor::PeekProcessor() {
-  memoryBuffer_.reset(new TMemoryBuffer());
-  targetTransport_ = memoryBuffer_;
-}
-PeekProcessor::~PeekProcessor() {}
-
-void PeekProcessor::initialize(boost::shared_ptr<TProcessor> actualProcessor,
-                               boost::shared_ptr<TProtocolFactory> protocolFactory,
-                               boost::shared_ptr<TPipedTransportFactory> transportFactory) {
-  actualProcessor_ = actualProcessor;
-  pipedProtocol_ = protocolFactory->getProtocol(targetTransport_);
-  transportFactory_ = transportFactory;
-  transportFactory_->initializeTargetTransport(targetTransport_);
-}
-
-boost::shared_ptr<TTransport> PeekProcessor::getPipedTransport(boost::shared_ptr<TTransport> in) {
-  return transportFactory_->getTransport(in);
-}
-
-void PeekProcessor::setTargetTransport(boost::shared_ptr<TTransport> targetTransport) {
-  targetTransport_ = targetTransport;
-  if (boost::dynamic_pointer_cast<TMemoryBuffer>(targetTransport_)) {
-    memoryBuffer_ = boost::dynamic_pointer_cast<TMemoryBuffer>(targetTransport);
-  } else if (boost::dynamic_pointer_cast<TPipedTransport>(targetTransport_)) {
-    memoryBuffer_ = boost::dynamic_pointer_cast<TMemoryBuffer>(boost::dynamic_pointer_cast<TPipedTransport>(targetTransport_)->getTargetTransport());
-  }
-
-  if (!memoryBuffer_) {
-    throw TException("Target transport must be a TMemoryBuffer or a TPipedTransport with TMemoryBuffer");
-  }
-}
-
-bool PeekProcessor::process(boost::shared_ptr<TProtocol> in,
-                            boost::shared_ptr<TProtocol> out) {
-
-  std::string fname;
-  TMessageType mtype;
-  int32_t seqid;
-  in->readMessageBegin(fname, mtype, seqid);
-
-  if (mtype != T_CALL) {
-    throw TException("Unexpected message type");
-  }
-
-  // Peek at the name
-  peekName(fname);
-
-  TType ftype;
-  int16_t fid;
-  while (true) {
-    in->readFieldBegin(fname, ftype, fid);
-    if (ftype == T_STOP) {
-      break;
-    }
-
-    // Peek at the variable
-    peek(in, ftype, fid);
-    in->readFieldEnd();
-  }
-  in->readMessageEnd();
-  in->getTransport()->readEnd();
-
-  //
-  // All the data is now in memoryBuffer_ and ready to be processed
-  //
-
-  // Let's first take a peek at the full data in memory
-  uint8_t* buffer;
-  uint32_t size;
-  memoryBuffer_->getBuffer(&buffer, &size);
-  peekBuffer(buffer, size);
-
-  // Done peeking at variables
-  peekEnd();
-
-  bool ret = actualProcessor_->process(pipedProtocol_, out);
-  memoryBuffer_->resetBuffer();
-  return ret;
-}
-
-void PeekProcessor::peekName(const std::string& fname) {
-}
-
-void PeekProcessor::peekBuffer(uint8_t* buffer, uint32_t size) {
-}
-
-void PeekProcessor::peek(boost::shared_ptr<TProtocol> in,
-                         TType ftype,
-                         int16_t fid) {
-  in->skip(ftype);
-}
-
-void PeekProcessor::peekEnd() {}
-
-}}}