Subversion Repositories SmartDukaan

//  Copyright (c) 2007-2008 Facebook

//

//  Licensed 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.

//

// See accompanying file LICENSE or visit the Scribe site at:

// http://developers.facebook.com/scribe/

//

// @author Bobby Johnson

// @author James Wang

// @author Jason Sobel

#ifndef SCRIBE_CONN_POOL_H

#define SCRIBE_CONN_POOL_H

#include "common.h"

class scribeConn {

 public:

  scribeConn(const std::string& host, unsigned long port, int timeout);

  scribeConn(const std::string &service, const server_vector_t &servers, int timeout);

  virtual ~scribeConn();

  void addRef();

  void releaseRef();

  unsigned getRef();

  void lock();

  void unlock();

  bool isOpen();

  bool open();

  void close();

  bool send(boost::shared_ptr<logentry_vector_t> messages);

 private:

  std::string connectionString();

 protected:

  boost::shared_ptr<apache::thrift::transport::TSocket> socket;

  boost::shared_ptr<apache::thrift::transport::TFramedTransport> framedTransport;

  boost::shared_ptr<apache::thrift::protocol::TBinaryProtocol> protocol;

  boost::shared_ptr<scribe::thrift::scribeClient> resendClient;

  unsigned refCount;

  bool smcBased;

  std::string smcService;

  server_vector_t serverList;

  std::string remoteHost;

  unsigned long remotePort;

  int timeout; // connection, send, and recv timeout

  pthread_mutex_t mutex;

};

// key is hostname:port or the smc_service

typedef std::map<std::string, boost::shared_ptr<scribeConn> > conn_map_t;

// Scribe class to manage connection pooling

// Maintains a map of (<host,port> or smc_service) to scribeConn class.

// used to ensure that there is only one connection from one particular

// scribe server to any host,port or smc_service.

// see the global g_connPool in store.cpp

class ConnPool {

 public:

  ConnPool();

  virtual ~ConnPool();

  bool open(const std::string& host, unsigned long port, int timeout);

  bool open(const std::string &service, const server_vector_t &servers, int timeout);

  void close(const std::string& host, unsigned long port);

  void close(const std::string &service);

  bool send(const std::string& host, unsigned long port,

            boost::shared_ptr<logentry_vector_t> messages);

  bool send(const std::string &service,

            boost::shared_ptr<logentry_vector_t> messages);

 private:

  bool openCommon(const std::string &key, boost::shared_ptr<scribeConn> conn);

  void closeCommon(const std::string &key);

  bool sendCommon(const std::string &key,

                  boost::shared_ptr<logentry_vector_t> messages);

 protected:

  std::string makeKey(const std::string& name, unsigned long port);

  pthread_mutex_t mapMutex;

  conn_map_t connMap;

};

#endif // !defined SCRIBE_CONN_POOL_H