rewrite_driver_factory.h

Go to the documentation of this file.

/*
 * Copyright 2010 Google Inc.
 *
 * 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.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_

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

#include "pagespeed/controller/central_controller.h"
#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/function.h"
#include "pagespeed/kernel/base/null_statistics.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/base/thread_system.h"
#include "pagespeed/kernel/thread/queued_worker_pool.h"

namespace pagespeed { namespace js { struct JsTokenizerPatterns; } }

namespace net_instaweb {

class CriticalImagesFinder;
class CriticalSelectorFinder;
class FileSystem;
class ExperimentMatcher;
class Hasher;
class MessageHandler;
class NamedLockManager;
class NonceGenerator;
class ProcessContext;
class ServerContext;
class RewriteDriver;
class RewriteOptions;
class RewriteOptionsManager;
class RewriteStats;
class SHA1Signature;
class Scheduler;
class StaticAssetManager;
class Timer;
class UrlAsyncFetcher;
class UrlNamer;
class UsageDataReporter;
class UserAgentMatcher;
class UserAgentNormalizer;

class RewriteDriverFactory {
 public:
  template<class T> class Deleter;

  enum WorkerPoolCategory {
    kHtmlWorkers,
    kRewriteWorkers,
    kLowPriorityRewriteWorkers,
    kNumWorkerPools
  };

  RewriteDriverFactory(const ProcessContext& process_context,
                       ThreadSystem* thread_system);

  void InitializeDefaultOptions();

  static void InitializeDefaultOptions(RewriteOptions* options);

  virtual ~RewriteDriverFactory();

  void set_html_parse_message_handler(MessageHandler* message_handler);
  void set_message_handler(MessageHandler* message_handler);
  void set_file_system(FileSystem* file_system);
  void set_hasher(Hasher* hasher);
  void set_nonce_generator(NonceGenerator* nonce_generator);
  void set_url_namer(UrlNamer* url_namer);
  void set_signature(SHA1Signature* signature);
  void set_timer(Timer* timer);
  void set_usage_data_reporter(UsageDataReporter* reporter);

  void set_slurp_directory(const StringPiece& directory);
  void set_slurp_read_only(bool read_only);
  void set_slurp_print_urls(bool read_only);

  void set_force_caching(bool u) { force_caching_ = u; }

  void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher);
  bool set_filename_prefix(StringPiece p);

  bool slurping_enabled() const { return !slurp_directory_.empty(); }

  MessageHandler* html_parse_message_handler();
  MessageHandler* message_handler();
  FileSystem* file_system();
  NonceGenerator* nonce_generator();
  Hasher* hasher();
  UrlNamer* url_namer();
  UserAgentMatcher* user_agent_matcher();
  StaticAssetManager* static_asset_manager();
  SHA1Signature* signature();
  RewriteOptions* default_options() { return default_options_.get(); }
  virtual RewriteOptionsManager* NewRewriteOptionsManager();

  Timer* timer();
  NamedLockManager* lock_manager();
  QueuedWorkerPool* WorkerPool(WorkerPoolCategory pool);
  Scheduler* scheduler();
  UsageDataReporter* usage_data_reporter();
  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns() const {
    return js_tokenizer_patterns_;
  }
  const std::vector<const UserAgentNormalizer*>& user_agent_normalizers();

  virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher();

  ServerContext* CreateServerContext();

  void InitServerContext(ServerContext* server_context);

  virtual void SetupCaches(ServerContext* server_context) = 0;

  virtual bool UseBeaconResultsInFilters() const = 0;

  virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver);

  virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver);

  virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver);

  ThreadSystem* thread_system() { return thread_system_.get(); }

  const StringSet& created_directories() const {
    return created_directories_;
  }

  bool async_rewrites() { return true; }

  RewriteStats* rewrite_stats();

  virtual bool HasWaveforms() const { return false; }

  Statistics* statistics() { return statistics_; }

  static void InitStats(Statistics* statistics);

  static void Initialize();
  static void Terminate();

  void SetStatistics(Statistics* stats);

  virtual void ShutDown();

  void AddCreatedDirectory(const GoogleString& dir);

  virtual RewriteOptions* NewRewriteOptions();

  virtual RewriteOptions* NewRewriteOptionsForQuery();

  const GoogleString& version_string() const { return version_string_; }
  void set_version_string(const StringPiece& version_string) {
    version_string.CopyToString(&version_string_);
  }

  void defer_cleanup(Function* f) { deferred_cleanups_.push_back(f); }

  template<class T> void TakeOwnership(T* obj) {
    defer_cleanup(new RewriteDriverFactory::Deleter<T>(obj));
  }

  virtual bool IsDebugClient(const GoogleString& ip) const {
    return false;
  }

  virtual ExperimentMatcher* NewExperimentMatcher();

 protected:
  bool FetchersComputed() const;
  virtual void StopCacheActivity();
  StringPiece filename_prefix();

  bool TerminateServerContext(ServerContext* server_context);

  virtual UrlAsyncFetcher* DefaultAsyncUrlFetcher() = 0;
  virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0;
  virtual MessageHandler* DefaultMessageHandler() = 0;
  virtual FileSystem* DefaultFileSystem() = 0;
  virtual NonceGenerator* DefaultNonceGenerator();
  virtual Timer* DefaultTimer();
  virtual SHA1Signature* DefaultSignature();

  virtual Hasher* NewHasher() = 0;

  virtual ServerContext* NewServerContext() = 0;

  virtual ServerContext* NewDecodingServerContext() = 0;

  virtual CriticalImagesFinder* DefaultCriticalImagesFinder(
      ServerContext* server_context);
  virtual CriticalSelectorFinder* DefaultCriticalSelectorFinder(
      ServerContext* server_context);

  virtual NamedLockManager* DefaultLockManager();

  virtual UrlNamer* DefaultUrlNamer();

  virtual UserAgentMatcher* DefaultUserAgentMatcher();
  virtual UsageDataReporter* DefaultUsageDataReporter();

  virtual void AddPlatformSpecificUserAgentNormalizers(
      std::vector<const UserAgentNormalizer*>* out);

  virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool,
                                             StringPiece name);

  virtual int LowPriorityLoadSheddingThreshold() const;

  virtual Scheduler* CreateScheduler();

  virtual void FetcherSetupHooks();

  virtual StringPiece LockFilePrefix();

  virtual void InitStaticAssetManager(
      StaticAssetManager* static_asset_manager) {}

  void InitStubDecodingServerContext(ServerContext* context);

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

  void RebuildDecodingDriverForTests(ServerContext* server_context);

  void reset_default_options(RewriteOptions* new_defaults);

 private:
  StaticAssetManager* DefaultStaticAssetManager();

  void SetupSlurpDirectories();

  void InitDecodingDriver(ServerContext* server_context);

  scoped_ptr<MessageHandler> html_parse_message_handler_;
  scoped_ptr<MessageHandler> message_handler_;
  scoped_ptr<FileSystem> file_system_;
  UrlAsyncFetcher* url_async_fetcher_;
  scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_;
  scoped_ptr<Hasher> hasher_;
  scoped_ptr<NonceGenerator> nonce_generator_;
  scoped_ptr<SHA1Signature> signature_;
  scoped_ptr<UrlNamer> url_namer_;
  scoped_ptr<UserAgentMatcher> user_agent_matcher_;

  std::vector<const UserAgentNormalizer*> user_agent_normalizers_;
  scoped_ptr<StaticAssetManager> static_asset_manager_;
  scoped_ptr<Timer> timer_;
  scoped_ptr<Scheduler> scheduler_;
  scoped_ptr<UsageDataReporter> usage_data_reporter_;
  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns_;

  GoogleString filename_prefix_;
  GoogleString slurp_directory_;
  bool force_caching_;
  bool slurp_read_only_;
  bool slurp_print_urls_;

  scoped_ptr<ThreadSystem> thread_system_;

  typedef std::set<ServerContext*> ServerContextSet;
  ServerContextSet server_contexts_;
  scoped_ptr<AbstractMutex> server_context_mutex_;

  scoped_ptr<RewriteOptions> default_options_;

  scoped_ptr<ServerContext> decoding_server_context_;
  scoped_ptr<RewriteDriver> decoding_driver_;

  scoped_ptr<NamedLockManager> lock_manager_;

  NullStatistics null_statistics_;
  Statistics* statistics_;

  StringSet created_directories_;

  std::vector<QueuedWorkerPool*> worker_pools_;

  scoped_ptr<RewriteStats> rewrite_stats_;

  std::vector<Function*> deferred_cleanups_;

  GoogleString version_string_;

  GoogleString hostname_;

  
};

template<class T> class RewriteDriverFactory::Deleter : public Function {
 public:
  explicit Deleter(T* obj) : obj_(obj) {}
  virtual void Run() { delete obj_; }
 private:
  T* obj_;
  
};

}  

#endif