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

// @author Anthony Giardullo

#ifndef SCRIBE_STORE_QUEUE_H

#define SCRIBE_STORE_QUEUE_H

#include <string>

#include <queue>

#include <vector>

#include <pthread.h>

#include "src/gen-cpp/scribe.h"

#include "store.h"

/*

 * This class implements a queue and a thread for dispatching

 * events to a store. It creates a store object of the requested

 * type, which can in turn create and manage other store objects.

 */

class StoreQueue {

 public:

  StoreQueue(const std::string& type, const std::string& category,

             unsigned check_period, bool is_model=false, bool multi_category=false);

  StoreQueue(const boost::shared_ptr<StoreQueue> example,

             const std::string &category);

  virtual ~StoreQueue();

  void addMessage(logentry_ptr_t entry);

  void configureAndOpen(pStoreConf configuration); // closes first if already open

  void open();                                     // closes first if already open

  void stop();

  boost::shared_ptr<Store> copyStore(const std::string &category);

  std::string getStatus(); // An empty string means OK, anything else is an error

  std::string getBaseType();

  std::string getCategoryHandled();

  bool isModelStore() { return isModel;}

  // this needs to be public for the thread creation to get to it,

  // but no one else should ever call it.

  void threadMember();

  // WARNING: don't expect this to be exact, because it could change after you check.

  //          This is only for hueristics to decide when we're overloaded.

  unsigned long getSize();

 private:

  void storeInitCommon();

  void configureInline(pStoreConf configuration);

  void openInline();

  void processFailedMessages(boost::shared_ptr<logentry_vector_t> messages);

  // implementation of queues and thread

  enum store_command_t {

    CMD_CONFIGURE,

    CMD_OPEN,

    CMD_STOP

  };

  class StoreCommand {

  public:

    store_command_t command;

    pStoreConf configuration;

    StoreCommand(store_command_t cmd, pStoreConf config = pStoreConf())

      : command(cmd), configuration(config) {};

  };

  typedef std::queue<StoreCommand> cmd_queue_t;

  // messages and commands are in different queues to allow bulk

  // handling of messages. This means that order of commands with

  // respect to messages is not preserved.

  cmd_queue_t cmdQueue;

  boost::shared_ptr<logentry_vector_t> msgQueue;

  boost::shared_ptr<logentry_vector_t> failedMessages;

  unsigned long msgQueueSize;   // in bytes

  pthread_t storeThread;

  // Mutexes

  pthread_mutex_t cmdMutex;     // Must be held to read/modify cmdQueue

  pthread_mutex_t msgMutex;     // Must be held to read/modify msgQueue

  pthread_mutex_t hasWorkMutex; // Must be held to read/modify hasWork

  // If acquiring multiple mutexes, always acquire in this order:

  // {cmdMutex, msgMutex, hasWorkMutex}

  bool hasWork;  // whether there are messages or commands queued

  pthread_cond_t hasWorkCond; // cond variable to wait on for hasWork

  bool stopping;

  bool isModel;

  bool multiCategory; // Whether multiple categories are handled

  // configuration

  std::string   categoryHandled;  // what category this store is handling

  time_t        checkPeriod;      // how often to call periodicCheck in seconds

  unsigned long targetWriteSize;  // in bytes

  time_t        maxWriteInterval; // in seconds

  bool          mustSucceed;      // Always retry even if secondary fails

  // Store that will handle messages. This can contain other stores.

  boost::shared_ptr<Store> store;

};

#endif //!defined SCRIBE_STORE_QUEUE_H