system_rewrite_driver_factory.h

Go to the documentation of this file.

// Copyright 2013 Google Inc.

#ifndef PAGESPEED_SYSTEM_SYSTEM_REWRITE_DRIVER_FACTORY_H_
#define PAGESPEED_SYSTEM_SYSTEM_REWRITE_DRIVER_FACTORY_H_

#include <map>
#include <memory>
#include <set>
#include <vector>

#include "net/instaweb/rewriter/public/rewrite_driver_factory.h"
#include "net/instaweb/rewriter/public/rewrite_options.h"
#include "pagespeed/controller/central_controller.h"
#include "pagespeed/controller/central_controller_rpc_client.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/hasher.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/statistics.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/thread/queued_worker_pool.h"

namespace net_instaweb {

class AbstractSharedMem;
class FileSystem;
class MessageHandler;
class NamedLockManager;
class NonceGenerator;
class ProcessContext;
class ServerContext;
class SharedCircularBuffer;
class SharedMemStatistics;
class StaticAssetManager;
class SystemCaches;
class SystemRewriteOptions;
class SystemServerContext;
class SystemThreadSystem;
class Timer;
class UrlAsyncFetcher;

class SystemRewriteDriverFactory : public RewriteDriverFactory {
 public:
  SystemRewriteDriverFactory(const ProcessContext& process_context,
                             SystemThreadSystem* thread_system,
                             AbstractSharedMem* shared_mem_runtime,
                             StringPiece hostname, int port);
  virtual ~SystemRewriteDriverFactory();
  void Init();

  static void InitApr();

  AbstractSharedMem* shared_mem_runtime() const {
    return shared_mem_runtime_.get();
  }

  SharedMemStatistics* AllocateAndInitSharedMemStatistics(
      bool local, const StringPiece& name, const SystemRewriteOptions& options);

  virtual void NonStaticInitStats(Statistics* statistics) = 0;

  NonceGenerator* DefaultNonceGenerator();

  bool is_root_process() const { return is_root_process_; }
  virtual void RootInit();
  virtual void ChildInit();

  virtual void ParentOrChildInit();

  void PostConfig(const std::vector<SystemServerContext*>& server_contexts,
                  GoogleString* error_message,
                  int* error_index,
                  Statistics** global_statistics);

  void SharedCircularBufferInit(bool is_root);

  virtual RewriteOptions::OptionSettingResult ParseAndSetOption1(
      StringPiece option,
      StringPiece arg,
      bool process_scope,
      GoogleString* msg,
      MessageHandler* handler);
  virtual RewriteOptions::OptionSettingResult ParseAndSetOption2(
      StringPiece option,
      StringPiece arg1,
      StringPiece arg2,
      bool process_scope,
      GoogleString* msg,
      MessageHandler* handler);

  virtual Hasher* NewHasher();
  virtual Timer* DefaultTimer();
  virtual ServerContext* NewServerContext();

  virtual bool enable_property_cache() const {
    return true;
  }

  GoogleString hostname_identifier() { return hostname_identifier_; }

  virtual void ShutDown();

  virtual void StopCacheActivity();

  SystemCaches* caches() { return caches_.get(); }

  virtual void set_message_buffer_size(int x) {
    message_buffer_size_ = x;
  }

  UrlAsyncFetcher* GetFetcher(SystemRewriteOptions* config);

  void set_track_original_content_length(bool x) {
    track_original_content_length_ = x;
  }
  bool track_original_content_length() const {
    return track_original_content_length_;
  }

  void list_outstanding_urls_on_error(bool x) {
    list_outstanding_urls_on_error_ = x;
  }

  virtual int max_queue_size() { return 500 * requests_per_host(); }
  virtual int queued_per_host() { return 500 * requests_per_host(); }
  virtual int requests_per_host(); 

  void set_static_asset_prefix(StringPiece s) {
    s.CopyToString(&static_asset_prefix_);
  }
  const GoogleString& static_asset_prefix() { return static_asset_prefix_; }

  int num_rewrite_threads() const { return num_rewrite_threads_; }
  void set_num_rewrite_threads(int x) { num_rewrite_threads_ = x; }
  int num_expensive_rewrite_threads() const {
    return num_expensive_rewrite_threads_;
  }
  void set_num_expensive_rewrite_threads(int x) {
    num_expensive_rewrite_threads_ = x;
  }
  bool use_per_vhost_statistics() const {
    return use_per_vhost_statistics_;
  }
  void set_use_per_vhost_statistics(bool x) {
    use_per_vhost_statistics_ = x;
  }
  bool install_crash_handler() const {
    return install_crash_handler_;
  }
  void set_install_crash_handler(bool x) {
    install_crash_handler_ = x;
  }

  virtual bool UseBeaconResultsInFilters() const {
    return true;
  }

  virtual bool IsServerThreaded() {
    return false; 
  }

  virtual int LookupThreadLimit() {
    return 1;
  }

  virtual void StartController(const SystemRewriteOptions& options);

  virtual void NameProcess(const char* name);

  virtual void PrepareForkedProcess(const char* name);

  virtual void PrepareControllerProcess();

 protected:
  static void InitStats(Statistics* statistics);

  virtual void InitStaticAssetManager(StaticAssetManager* static_asset_manager);

  virtual void SetupCaches(ServerContext* server_context);
  virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool,
                                             StringPiece name);

  virtual void SetupMessageHandlers() {}
  virtual void ShutDownMessageHandlers() {}
  virtual void SetCircularBuffer(SharedCircularBuffer* buffer) {}

  virtual void ShutDownFetchers() {}

  typedef std::set<SystemServerContext*> SystemServerContextSet;
  SystemServerContextSet uninitialized_server_contexts_;

  virtual UrlAsyncFetcher* AllocateFetcher(SystemRewriteOptions* config);

  virtual FileSystem* DefaultFileSystem();
  virtual NamedLockManager* DefaultLockManager();

  virtual void AutoDetectThreadCounts();

  bool thread_counts_finalized() { return thread_counts_finalized_; }

  std::shared_ptr<CentralController> GetCentralController(
      NamedLockManager* lock_manager) override;

 private:
  Statistics* SetUpGlobalSharedMemStatistics(
      const SystemRewriteOptions& options);

  GoogleString GetFetcherKey(bool include_slurping_config,
                             const SystemRewriteOptions* config);

  UrlAsyncFetcher* GetBaseFetcher(SystemRewriteOptions* config);

  virtual UrlAsyncFetcher* DefaultAsyncUrlFetcher();

  scoped_ptr<SharedMemStatistics> shared_mem_statistics_;
  StringVector local_shm_stats_segment_names_;
  scoped_ptr<AbstractSharedMem> shared_mem_runtime_;
  scoped_ptr<SharedCircularBuffer> shared_circular_buffer_;

  bool statistics_frozen_;
  bool is_root_process_;

  const GoogleString hostname_identifier_;

  int message_buffer_size_;

  scoped_ptr<SystemCaches> caches_;

  bool track_original_content_length_;
  bool list_outstanding_urls_on_error_;

  typedef std::map<GoogleString, UrlAsyncFetcher*> FetcherMap;
  FetcherMap base_fetcher_map_;
  FetcherMap fetcher_map_;

  GoogleString static_asset_prefix_;

  SystemThreadSystem* system_thread_system_;

  bool use_per_vhost_statistics_;

  bool install_crash_handler_;

  bool thread_counts_finalized_;

  int num_rewrite_threads_;
  int num_expensive_rewrite_threads_;

  std::shared_ptr<CentralControllerRpcClient> central_controller_;

  
};

}  

#endif