Page Speed Optimization Libraries  1.7.30.4
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 pagespeed { namespace js { struct JsTokenizerPatterns; } }
00033 
00034 namespace net_instaweb {
00035 
00036 class AbstractMutex;
00037 class CacheHtmlInfoFinder;
00038 class CriticalCssFinder;
00039 class CriticalImagesFinder;
00040 class CriticalLineInfoFinder;
00041 class CriticalSelectorFinder;
00042 class FileSystem;
00043 class FilenameEncoder;
00044 class FlushEarlyInfoFinder;
00045 class ExperimentMatcher;
00046 class Hasher;
00047 class MessageHandler;
00048 class NamedLockManager;
00049 class NonceGenerator;
00050 class ProcessContext;
00051 class PropertyCache;
00052 class QueuedWorkerPool;
00053 class ServerContext;
00054 class RewriteDriver;
00055 class RewriteOptions;
00056 class RewriteOptionsManager;
00057 class RewriteStats;
00058 class Scheduler;
00059 class StaticAssetManager;
00060 class Statistics;
00061 class ThreadSystem;
00062 class Timer;
00063 class UrlAsyncFetcher;
00064 class UrlNamer;
00065 class UsageDataReporter;
00066 class UserAgentMatcher;
00067 class UserAgentNormalizer;
00068 
00073 class RewriteDriverFactory {
00074  public:
00076   template<class T> class Deleter;
00077 
00078   enum WorkerPoolCategory {
00079     kHtmlWorkers,
00080     kRewriteWorkers,
00081     kLowPriorityRewriteWorkers,
00083     kNumWorkerPools
00084   };
00085 
00087   RewriteDriverFactory(const ProcessContext& process_context,
00088                        ThreadSystem* thread_system);
00089 
00094   void InitializeDefaultOptions();
00095 
00096   virtual ~RewriteDriverFactory();
00097 
00102   void set_html_parse_message_handler(MessageHandler* message_handler);
00103   void set_message_handler(MessageHandler* message_handler);
00104   void set_file_system(FileSystem* file_system);
00105   void set_hasher(Hasher* hasher);
00106   void set_filename_encoder(FilenameEncoder* filename_encoder);
00107   void set_nonce_generator(NonceGenerator* nonce_generator);
00108   void set_url_namer(UrlNamer* url_namer);
00109   void set_timer(Timer* timer);
00110   void set_usage_data_reporter(UsageDataReporter* reporter);
00111 
00121   void set_slurp_directory(const StringPiece& directory);
00122   void set_slurp_read_only(bool read_only);
00123   void set_slurp_print_urls(bool read_only);
00124 
00127   void set_force_caching(bool u) { force_caching_ = u; }
00128 
00137   void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher);
00139   void set_base_distributed_async_fetcher(UrlAsyncFetcher* distributed_fetcher);
00140   bool set_filename_prefix(StringPiece p);
00141 
00143   bool slurping_enabled() const { return !slurp_directory_.empty(); }
00144 
00145   MessageHandler* html_parse_message_handler();
00146   MessageHandler* message_handler();
00147   FileSystem* file_system();
00148   NonceGenerator* nonce_generator();
00151   Hasher* hasher();
00152   FilenameEncoder* filename_encoder() { return filename_encoder_.get(); }
00153   UrlNamer* url_namer();
00154   UserAgentMatcher* user_agent_matcher();
00155   StaticAssetManager* static_asset_manager();
00156   RewriteOptions* default_options() { return default_options_.get(); }
00157   virtual RewriteOptionsManager* NewRewriteOptionsManager();
00158 
00163   Timer* timer();
00164   NamedLockManager* lock_manager();
00165   QueuedWorkerPool* WorkerPool(WorkerPoolCategory pool);
00166   Scheduler* scheduler();
00167   UsageDataReporter* usage_data_reporter();
00168   const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns() const {
00169     return js_tokenizer_patterns_;
00170   }
00171   const std::vector<const UserAgentNormalizer*>& user_agent_normalizers();
00172 
00177   virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher();
00178   virtual UrlAsyncFetcher* ComputeDistributedFetcher();
00179 
00186   ServerContext* CreateServerContext();
00187 
00191   void InitServerContext(ServerContext* server_context);
00192 
00197   virtual void SetupCaches(ServerContext* server_context) = 0;
00198 
00202   virtual bool UseBeaconResultsInFilters() const = 0;
00203 
00207   virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver);
00208 
00217   virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver);
00218 
00222   virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver);
00223 
00224   ThreadSystem* thread_system() { return thread_system_.get(); }
00225 
00228   const StringSet& created_directories() const {
00229     return created_directories_;
00230   }
00231 
00232   bool async_rewrites() { return true; }
00233 
00238   RewriteStats* rewrite_stats();
00239 
00242   Statistics* statistics() { return statistics_; }
00243 
00246   static void InitStats(Statistics* statistics);
00247 
00249   static void Initialize();
00250   static void Terminate();
00251 
00253   void SetStatistics(Statistics* stats);
00254 
00258   virtual void ShutDown();
00259 
00261   void AddCreatedDirectory(const GoogleString& dir);
00262 
00267   virtual RewriteOptions* NewRewriteOptions();
00268 
00272   virtual RewriteOptions* NewRewriteOptionsForQuery();
00273 
00275   const GoogleString& version_string() const { return version_string_; }
00276   void set_version_string(const StringPiece& version_string) {
00277     version_string.CopyToString(&version_string_);
00278   }
00279 
00283   void defer_cleanup(Function* f) { deferred_cleanups_.push_back(f); }
00284 
00287   template<class T> void TakeOwnership(T* obj) {
00288     defer_cleanup(new RewriteDriverFactory::Deleter<T>(obj));
00289   }
00290 
00292   virtual bool IsDebugClient(const GoogleString& ip) const {
00293     return false;
00294   }
00295 
00298   virtual ExperimentMatcher* NewExperimentMatcher();
00299 
00301   const std::vector<int>* preferred_webp_qualities() {
00302     return &preferred_webp_qualities_;
00303   }
00304 
00306   const std::vector<int>* preferred_jpeg_qualities() {
00307     return &preferred_jpeg_qualities_;
00308   }
00309 
00311   bool SetPreferredWebpQualities(const StringPiece& qualities);
00312 
00314   bool SetPreferredJpegQualities(const StringPiece& qualities);
00315 
00316  protected:
00317   bool FetchersComputed() const;
00318   virtual void StopCacheActivity();
00319   StringPiece filename_prefix();
00320 
00324   bool TerminateServerContext(ServerContext* server_context);
00325 
00330   virtual UrlAsyncFetcher* DefaultAsyncUrlFetcher() = 0;
00331   virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0;
00332   virtual MessageHandler* DefaultMessageHandler() = 0;
00333   virtual FileSystem* DefaultFileSystem() = 0;
00334   virtual NonceGenerator* DefaultNonceGenerator();
00335   virtual Timer* DefaultTimer();
00336 
00337   virtual Hasher* NewHasher() = 0;
00338 
00341   virtual ServerContext* NewServerContext() = 0;
00342 
00352   virtual ServerContext* NewDecodingServerContext() = 0;
00353 
00354   virtual UrlAsyncFetcher* DefaultDistributedUrlFetcher() { return NULL; }
00355 
00356   virtual CriticalCssFinder* DefaultCriticalCssFinder();
00357   virtual CriticalImagesFinder* DefaultCriticalImagesFinder(
00358       ServerContext* server_context);
00359   virtual CriticalSelectorFinder* DefaultCriticalSelectorFinder(
00360       ServerContext* server_context);
00361 
00363   virtual CacheHtmlInfoFinder* DefaultCacheHtmlInfoFinder(
00364       PropertyCache* cache, ServerContext* server_context);
00365 
00367   virtual FlushEarlyInfoFinder* DefaultFlushEarlyInfoFinder();
00368 
00370   virtual CriticalLineInfoFinder* DefaultCriticalLineInfoFinder(
00371       ServerContext* server_context);
00372 
00375   virtual NamedLockManager* DefaultLockManager();
00376 
00379   virtual UrlNamer* DefaultUrlNamer();
00380 
00381   virtual UserAgentMatcher* DefaultUserAgentMatcher();
00382   virtual UsageDataReporter* DefaultUsageDataReporter();
00383 
00390   virtual void AddPlatformSpecificUserAgentNormalizers(
00391       std::vector<const UserAgentNormalizer*>* out);
00392 
00396   virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool,
00397                                              StringPiece name);
00398 
00405   virtual int LowPriorityLoadSheddingThreshold() const;
00406 
00409   virtual Scheduler* CreateScheduler();
00410 
00412   virtual void FetcherSetupHooks();
00413 
00417   virtual StringPiece LockFilePrefix();
00418 
00420   virtual void InitStaticAssetManager(
00421       StaticAssetManager* static_asset_manager) {}
00422 
00425   void InitStubDecodingServerContext(ServerContext* context);
00426 
00428   void RebuildDecodingDriverForTests(ServerContext* server_context);
00429 
00430  private:
00434   StaticAssetManager* DefaultStaticAssetManager();
00435 
00436   void SetupSlurpDirectories();
00437   void Init(); 
00438 
00439   void InitDecodingDriver(ServerContext* server_context);
00440 
00441   scoped_ptr<MessageHandler> html_parse_message_handler_;
00442   scoped_ptr<MessageHandler> message_handler_;
00443   scoped_ptr<FileSystem> file_system_;
00444   UrlAsyncFetcher* url_async_fetcher_;
00445   UrlAsyncFetcher* distributed_async_fetcher_;
00446   scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_;
00447   scoped_ptr<UrlAsyncFetcher> base_distributed_async_fetcher_;
00448   scoped_ptr<Hasher> hasher_;
00449   scoped_ptr<FilenameEncoder> filename_encoder_;
00450   scoped_ptr<NonceGenerator> nonce_generator_;
00451   scoped_ptr<UrlNamer> url_namer_;
00452   scoped_ptr<UserAgentMatcher> user_agent_matcher_;
00453 
00457   std::vector<const UserAgentNormalizer*> user_agent_normalizers_;
00458   scoped_ptr<StaticAssetManager> static_asset_manager_;
00459   scoped_ptr<Timer> timer_;
00460   scoped_ptr<Scheduler> scheduler_;
00461   scoped_ptr<UsageDataReporter> usage_data_reporter_;
00463   const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns_;
00464 
00465   GoogleString filename_prefix_;
00466   GoogleString slurp_directory_;
00467   bool force_caching_;
00468   bool slurp_read_only_;
00469   bool slurp_print_urls_;
00470 
00472   typedef std::set<ServerContext*> ServerContextSet;
00473   ServerContextSet server_contexts_;
00474   scoped_ptr<AbstractMutex> server_context_mutex_;
00475 
00478   scoped_ptr<RewriteOptions> default_options_;
00479 
00487   scoped_ptr<ServerContext> decoding_server_context_;
00488   scoped_ptr<RewriteDriver> decoding_driver_;
00489 
00491   scoped_ptr<NamedLockManager> lock_manager_;
00492 
00493   scoped_ptr<ThreadSystem> thread_system_;
00494 
00497   NullStatistics null_statistics_;
00498   Statistics* statistics_;
00499 
00500   StringSet created_directories_;
00501 
00502   std::vector<QueuedWorkerPool*> worker_pools_;
00503 
00506   scoped_ptr<RewriteStats> rewrite_stats_;
00507 
00510   std::vector<Function*> deferred_cleanups_;
00511 
00514   GoogleString version_string_;
00515 
00517   GoogleString hostname_;
00518 
00523   std::vector<int> preferred_webp_qualities_;
00524   std::vector<int> preferred_jpeg_qualities_;
00525 
00526   DISALLOW_COPY_AND_ASSIGN(RewriteDriverFactory);
00527 };
00528 
00531 template<class T> class RewriteDriverFactory::Deleter : public Function {
00532  public:
00533   explicit Deleter(T* obj) : obj_(obj) {}
00534   virtual void Run() { delete obj_; }
00535  private:
00536   T* obj_;
00537   DISALLOW_COPY_AND_ASSIGN(Deleter);
00538 };
00539 
00540 }  
00541 
00542 #endif  ///< NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines