Page Speed Optimization Libraries  1.7.30.1
net/instaweb/rewriter/public/rewrite_driver_factory.h
Go to the documentation of this file.
00001 /*
00002  * Copyright 2010 Google Inc.
00003  *
00004  * Licensed under the Apache License, Version 2.0 (the "License");
00005  * you may not use this file except in compliance with the License.
00006  * You may obtain a copy of the License at
00007  *
00008  *      http:///www.apache.org/licenses/LICENSE-2.0
00009  *
00010  * Unless required by applicable law or agreed to in writing, software
00011  * distributed under the License is distributed on an "AS IS" BASIS,
00012  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
00013  * See the License for the specific language governing permissions and
00014  * limitations under the License.
00015  */
00016 
00018 
00019 #ifndef NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
00020 #define NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
00021 
00022 #include <set>
00023 #include <vector>
00024 
00025 #include "net/instaweb/util/public/basictypes.h"
00026 #include "net/instaweb/util/public/function.h"
00027 #include "net/instaweb/util/public/null_statistics.h"
00028 #include "net/instaweb/util/public/scoped_ptr.h"
00029 #include "net/instaweb/util/public/string.h"
00030 #include "net/instaweb/util/public/string_util.h"
00031 
00032 namespace net_instaweb {
00033 
00034 class AbstractMutex;
00035 class CacheHtmlInfoFinder;
00036 class CriticalCssFinder;
00037 class CriticalImagesFinder;
00038 class CriticalLineInfoFinder;
00039 class CriticalSelectorFinder;
00040 class FileSystem;
00041 class FilenameEncoder;
00042 class FlushEarlyInfoFinder;
00043 class ExperimentMatcher;
00044 class Hasher;
00045 class MessageHandler;
00046 class NamedLockManager;
00047 class NonceGenerator;
00048 class PropertyCache;
00049 class QueuedWorkerPool;
00050 class ServerContext;
00051 class RewriteDriver;
00052 class RewriteOptions;
00053 class RewriteOptionsManager;
00054 class RewriteStats;
00055 class Scheduler;
00056 class StaticAssetManager;
00057 class Statistics;
00058 class ThreadSystem;
00059 class Timer;
00060 class UrlAsyncFetcher;
00061 class UrlNamer;
00062 class UsageDataReporter;
00063 class UserAgentMatcher;
00064 class UserAgentNormalizer;
00065 
00070 class RewriteDriverFactory {
00071  public:
00073   template<class T> class Deleter;
00074 
00075   enum WorkerPoolCategory {
00076     kHtmlWorkers,
00077     kRewriteWorkers,
00078     kLowPriorityRewriteWorkers,
00080     kNumWorkerPools
00081   };
00082 
00084   explicit RewriteDriverFactory(ThreadSystem* thread_system);
00085 
00090   void InitializeDefaultOptions();
00091 
00092   virtual ~RewriteDriverFactory();
00093 
00098   void set_html_parse_message_handler(MessageHandler* message_handler);
00099   void set_message_handler(MessageHandler* message_handler);
00100   void set_file_system(FileSystem* file_system);
00101   void set_hasher(Hasher* hasher);
00102   void set_filename_encoder(FilenameEncoder* filename_encoder);
00103   void set_nonce_generator(NonceGenerator* nonce_generator);
00104   void set_url_namer(UrlNamer* url_namer);
00105   void set_timer(Timer* timer);
00106   void set_usage_data_reporter(UsageDataReporter* reporter);
00107 
00117   void set_slurp_directory(const StringPiece& directory);
00118   void set_slurp_read_only(bool read_only);
00119   void set_slurp_print_urls(bool read_only);
00120 
00123   void set_force_caching(bool u) { force_caching_ = u; }
00124 
00133   void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher);
00135   void set_base_distributed_async_fetcher(UrlAsyncFetcher* distributed_fetcher);
00136   bool set_filename_prefix(StringPiece p);
00137 
00139   bool slurping_enabled() const { return !slurp_directory_.empty(); }
00140 
00141   MessageHandler* html_parse_message_handler();
00142   MessageHandler* message_handler();
00143   FileSystem* file_system();
00144   NonceGenerator* nonce_generator();
00147   Hasher* hasher();
00148   FilenameEncoder* filename_encoder() { return filename_encoder_.get(); }
00149   UrlNamer* url_namer();
00150   UserAgentMatcher* user_agent_matcher();
00151   StaticAssetManager* static_asset_manager();
00152   RewriteOptions* default_options() { return default_options_.get(); }
00153   virtual RewriteOptionsManager* NewRewriteOptionsManager();
00154 
00159   Timer* timer();
00160   NamedLockManager* lock_manager();
00161   QueuedWorkerPool* WorkerPool(WorkerPoolCategory pool);
00162   Scheduler* scheduler();
00163   UsageDataReporter* usage_data_reporter();
00164   const std::vector<const UserAgentNormalizer*>& user_agent_normalizers();
00165 
00170   virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher();
00171   virtual UrlAsyncFetcher* ComputeDistributedFetcher();
00172 
00179   ServerContext* CreateServerContext();
00180 
00184   void InitServerContext(ServerContext* server_context);
00185 
00190   virtual void SetupCaches(ServerContext* server_context) = 0;
00191 
00195   virtual bool UseBeaconResultsInFilters() const = 0;
00196 
00200   virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver);
00201 
00208   virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver);
00209 
00213   virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver);
00214 
00215   ThreadSystem* thread_system() { return thread_system_.get(); }
00216 
00219   const StringSet& created_directories() const {
00220     return created_directories_;
00221   }
00222 
00223   bool async_rewrites() { return true; }
00224 
00229   RewriteStats* rewrite_stats();
00230 
00233   Statistics* statistics() { return statistics_; }
00234 
00237   static void InitStats(Statistics* statistics);
00238 
00240   static void Initialize();
00241   static void Terminate();
00242 
00244   void SetStatistics(Statistics* stats);
00245 
00249   virtual void ShutDown();
00250 
00252   void AddCreatedDirectory(const GoogleString& dir);
00253 
00258   virtual RewriteOptions* NewRewriteOptions();
00259 
00263   virtual RewriteOptions* NewRewriteOptionsForQuery();
00264 
00266   const GoogleString& version_string() const { return version_string_; }
00267   void set_version_string(const StringPiece& version_string) {
00268     version_string.CopyToString(&version_string_);
00269   }
00270 
00274   void defer_cleanup(Function* f) { deferred_cleanups_.push_back(f); }
00275 
00278   template<class T> void TakeOwnership(T* obj) {
00279     defer_cleanup(new RewriteDriverFactory::Deleter<T>(obj));
00280   }
00281 
00283   virtual bool IsDebugClient(const GoogleString& ip) const {
00284     return false;
00285   }
00286 
00289   virtual ExperimentMatcher* NewExperimentMatcher();
00290 
00292   const std::vector<int>* preferred_webp_qualities() {
00293     return &preferred_webp_qualities_;
00294   }
00295 
00297   const std::vector<int>* preferred_jpeg_qualities() {
00298     return &preferred_jpeg_qualities_;
00299   }
00300 
00302   bool SetPreferredWebpQualities(const StringPiece& qualities);
00303 
00305   bool SetPreferredJpegQualities(const StringPiece& qualities);
00306 
00307  protected:
00308   bool FetchersComputed() const;
00309   virtual void StopCacheActivity();
00310   StringPiece filename_prefix();
00311 
00315   bool TerminateServerContext(ServerContext* server_context);
00316 
00321   virtual UrlAsyncFetcher* DefaultAsyncUrlFetcher() = 0;
00322   virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0;
00323   virtual MessageHandler* DefaultMessageHandler() = 0;
00324   virtual FileSystem* DefaultFileSystem() = 0;
00325   virtual NonceGenerator* DefaultNonceGenerator();
00326   virtual Timer* DefaultTimer();
00327 
00328   virtual Hasher* NewHasher() = 0;
00329 
00332   virtual ServerContext* NewServerContext() = 0;
00333 
00334   virtual UrlAsyncFetcher* DefaultDistributedUrlFetcher() { return NULL; }
00335 
00336   virtual CriticalCssFinder* DefaultCriticalCssFinder();
00337   virtual CriticalImagesFinder* DefaultCriticalImagesFinder(
00338       ServerContext* server_context);
00339   virtual CriticalSelectorFinder* DefaultCriticalSelectorFinder(
00340       ServerContext* server_context);
00341 
00343   virtual CacheHtmlInfoFinder* DefaultCacheHtmlInfoFinder(
00344       PropertyCache* cache, ServerContext* server_context);
00345 
00347   virtual FlushEarlyInfoFinder* DefaultFlushEarlyInfoFinder();
00348 
00350   virtual CriticalLineInfoFinder* DefaultCriticalLineInfoFinder(
00351       ServerContext* server_context);
00352 
00355   virtual NamedLockManager* DefaultLockManager();
00356 
00359   virtual UrlNamer* DefaultUrlNamer();
00360 
00361   virtual UserAgentMatcher* DefaultUserAgentMatcher();
00362   virtual UsageDataReporter* DefaultUsageDataReporter();
00363 
00370   virtual void AddPlatformSpecificUserAgentNormalizers(
00371       std::vector<const UserAgentNormalizer*>* out);
00372 
00376   virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool,
00377                                              StringPiece name);
00378 
00385   virtual int LowPriorityLoadSheddingThreshold() const;
00386 
00389   virtual Scheduler* CreateScheduler();
00390 
00392   virtual void FetcherSetupHooks();
00393 
00397   virtual StringPiece LockFilePrefix();
00398 
00400   virtual void InitStaticAssetManager(
00401       StaticAssetManager* static_asset_manager) {}
00402 
00403  private:
00407   StaticAssetManager* DefaultStaticAssetManager();
00408 
00409   void SetupSlurpDirectories();
00410   void Init(); 
00411 
00412   scoped_ptr<MessageHandler> html_parse_message_handler_;
00413   scoped_ptr<MessageHandler> message_handler_;
00414   scoped_ptr<FileSystem> file_system_;
00415   UrlAsyncFetcher* url_async_fetcher_;
00416   UrlAsyncFetcher* distributed_async_fetcher_;
00417   scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_;
00418   scoped_ptr<UrlAsyncFetcher> base_distributed_async_fetcher_;
00419   scoped_ptr<Hasher> hasher_;
00420   scoped_ptr<FilenameEncoder> filename_encoder_;
00421   scoped_ptr<NonceGenerator> nonce_generator_;
00422   scoped_ptr<UrlNamer> url_namer_;
00423   scoped_ptr<UserAgentMatcher> user_agent_matcher_;
00424 
00428   std::vector<const UserAgentNormalizer*> user_agent_normalizers_;
00429   scoped_ptr<StaticAssetManager> static_asset_manager_;
00430   scoped_ptr<Timer> timer_;
00431   scoped_ptr<Scheduler> scheduler_;
00432   scoped_ptr<UsageDataReporter> usage_data_reporter_;
00433 
00434   GoogleString filename_prefix_;
00435   GoogleString slurp_directory_;
00436   bool force_caching_;
00437   bool slurp_read_only_;
00438   bool slurp_print_urls_;
00439 
00441   typedef std::set<ServerContext*> ServerContextSet;
00442   ServerContextSet server_contexts_;
00443   scoped_ptr<AbstractMutex> server_context_mutex_;
00444 
00447   scoped_ptr<RewriteOptions> default_options_;
00448 
00450   scoped_ptr<NamedLockManager> lock_manager_;
00451 
00452   scoped_ptr<ThreadSystem> thread_system_;
00453 
00456   NullStatistics null_statistics_;
00457   Statistics* statistics_;
00458 
00459   StringSet created_directories_;
00460 
00461   std::vector<QueuedWorkerPool*> worker_pools_;
00462 
00465   scoped_ptr<RewriteStats> rewrite_stats_;
00466 
00469   std::vector<Function*> deferred_cleanups_;
00470 
00473   GoogleString version_string_;
00474 
00476   GoogleString hostname_;
00477 
00482   std::vector<int> preferred_webp_qualities_;
00483   std::vector<int> preferred_jpeg_qualities_;
00484 
00485   DISALLOW_COPY_AND_ASSIGN(RewriteDriverFactory);
00486 };
00487 
00490 template<class T> class RewriteDriverFactory::Deleter : public Function {
00491  public:
00492   explicit Deleter(T* obj) : obj_(obj) {}
00493   virtual void Run() { delete obj_; }
00494  private:
00495   T* obj_;
00496   DISALLOW_COPY_AND_ASSIGN(Deleter);
00497 };
00498 
00499 }  
00500 
00501 #endif  ///< NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines