Page Speed Optimization Libraries  1.4.26.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 AbstractClientState;
00035 class AbstractMutex;
00036 class BlinkCriticalLineDataFinder;
00037 class CacheHtmlInfoFinder;
00038 class CriticalCssFinder;
00039 class CriticalImagesFinder;
00040 class CriticalSelectorFinder;
00041 class FileSystem;
00042 class FilenameEncoder;
00043 class FlushEarlyInfoFinder;
00044 class FuriousMatcher;
00045 class Hasher;
00046 class MessageHandler;
00047 class NamedLockManager;
00048 class PropertyCache;
00049 class QueuedWorkerPool;
00050 class ServerContext;
00051 class RewriteDriver;
00052 class RewriteOptions;
00053 class RewriteStats;
00054 class Scheduler;
00055 class StaticAssetManager;
00056 class Statistics;
00057 class ThreadSystem;
00058 class Timer;
00059 class UrlAsyncFetcher;
00060 class UrlFetcher;
00061 class UrlNamer;
00062 class UsageDataReporter;
00063 class UserAgentMatcher;
00064 
00069 class RewriteDriverFactory {
00070  public:
00072   template<class T> class Deleter;
00073 
00074   enum WorkerPoolCategory {
00075     kHtmlWorkers,
00076     kRewriteWorkers,
00077     kLowPriorityRewriteWorkers,
00079     kNumWorkerPools
00080   };
00081 
00083   explicit RewriteDriverFactory(ThreadSystem* thread_system);
00084 
00086   RewriteDriverFactory();
00087 
00092   void InitializeDefaultOptions();
00093 
00094   virtual ~RewriteDriverFactory();
00095 
00100   void set_html_parse_message_handler(MessageHandler* message_handler);
00101   void set_message_handler(MessageHandler* message_handler);
00102   void set_file_system(FileSystem* file_system);
00103   void set_hasher(Hasher* hasher);
00104   void set_filename_encoder(FilenameEncoder* filename_encoder);
00105   void set_url_namer(UrlNamer* url_namer);
00106   void set_timer(Timer* timer);
00107   void set_usage_data_reporter(UsageDataReporter* reporter);
00108 
00119   void set_slurp_directory(const StringPiece& directory);
00120   void set_slurp_read_only(bool read_only);
00121   void set_slurp_print_urls(bool read_only);
00122 
00125   void set_force_caching(bool u) { force_caching_ = u; }
00126 
00138   void set_base_url_fetcher(UrlFetcher* url_fetcher);
00139   void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher);
00141   void set_base_distributed_async_fetcher(UrlAsyncFetcher* distributed_fetcher);
00142   bool set_filename_prefix(StringPiece p);
00143 
00145   bool slurping_enabled() const { return !slurp_directory_.empty(); }
00146 
00147   MessageHandler* html_parse_message_handler();
00148   MessageHandler* message_handler();
00149   FileSystem* file_system();
00152   Hasher* hasher();
00153   FilenameEncoder* filename_encoder() { return filename_encoder_.get(); }
00154   UrlNamer* url_namer();
00155   UserAgentMatcher* user_agent_matcher();
00156   StaticAssetManager* static_asset_manager();
00157   RewriteOptions* default_options() { return default_options_.get(); }
00158 
00161   Timer* timer();
00162   NamedLockManager* lock_manager();
00163   QueuedWorkerPool* WorkerPool(WorkerPoolCategory pool);
00164   Scheduler* scheduler();
00165   UsageDataReporter* usage_data_reporter();
00166 
00171   virtual UrlFetcher* ComputeUrlFetcher();
00172   virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher();
00173   virtual UrlAsyncFetcher* ComputeDistributedFetcher();
00174 
00181   ServerContext* CreateServerContext();
00182 
00186   void InitServerContext(ServerContext* server_context);
00187 
00192   virtual void SetupCaches(ServerContext* server_context) = 0;
00193 
00197   virtual bool UseBeaconResultsInFilters() const = 0;
00198 
00202   virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver);
00203 
00210   virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver);
00211 
00215   virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver);
00216 
00217   ThreadSystem* thread_system() { return thread_system_.get(); }
00218 
00221   const StringSet& created_directories() const {
00222     return created_directories_;
00223   }
00224 
00225   bool async_rewrites() { return true; }
00226 
00231   RewriteStats* rewrite_stats();
00232 
00235   Statistics* statistics() { return statistics_; }
00236 
00239   static void InitStats(Statistics* statistics);
00240 
00242   static void Initialize();
00243   static void Terminate();
00244 
00246   void SetStatistics(Statistics* stats);
00247 
00251   virtual void ShutDown();
00252 
00254   void AddCreatedDirectory(const GoogleString& dir);
00255 
00260   virtual RewriteOptions* NewRewriteOptions();
00261 
00265   virtual RewriteOptions* NewRewriteOptionsForQuery();
00266 
00268   const GoogleString& version_string() const { return version_string_; }
00269   void set_version_string(const StringPiece& version_string) {
00270     version_string.CopyToString(&version_string_);
00271   }
00272 
00276   void defer_cleanup(Function* f) { deferred_cleanups_.push_back(f); }
00277 
00279   virtual bool IsDebugClient(const GoogleString& ip) const {
00280     return false;
00281   }
00282 
00286   virtual AbstractClientState* NewClientState();
00287 
00290   virtual FuriousMatcher* NewFuriousMatcher();
00291 
00292  protected:
00293   bool FetchersComputed() const;
00294   virtual void StopCacheActivity();
00295   StringPiece filename_prefix();
00296 
00300   bool TerminateServerContext(ServerContext* rm);
00301 
00305   virtual UrlFetcher* DefaultUrlFetcher() = 0;
00306   virtual UrlAsyncFetcher* DefaultAsyncUrlFetcher() = 0;
00307   virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0;
00308   virtual MessageHandler* DefaultMessageHandler() = 0;
00309   virtual FileSystem* DefaultFileSystem() = 0;
00310   virtual Timer* DefaultTimer() = 0;
00311 
00312   virtual Hasher* NewHasher() = 0;
00313 
00316   virtual ServerContext* NewServerContext() = 0;
00317 
00318   virtual UrlAsyncFetcher* DefaultDistributedUrlFetcher() { return NULL; }
00319 
00320   virtual CriticalCssFinder* DefaultCriticalCssFinder();
00321   virtual CriticalImagesFinder* DefaultCriticalImagesFinder();
00322   virtual CriticalSelectorFinder* DefaultCriticalSelectorFinder();
00323 
00325   virtual BlinkCriticalLineDataFinder* DefaultBlinkCriticalLineDataFinder(
00326       PropertyCache* cache);
00327 
00329   virtual CacheHtmlInfoFinder* DefaultCacheHtmlInfoFinder(
00330       PropertyCache* cache);
00331 
00333   virtual FlushEarlyInfoFinder* DefaultFlushEarlyInfoFinder();
00334 
00337   virtual NamedLockManager* DefaultLockManager();
00338 
00341   virtual UrlNamer* DefaultUrlNamer();
00342 
00343   virtual UserAgentMatcher* DefaultUserAgentMatcher();
00344   virtual UsageDataReporter* DefaultUsageDataReporter();
00345 
00349   virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool,
00350                                              StringPiece name);
00351 
00358   virtual int LowPriorityLoadSheddingThreshold() const;
00359 
00362   virtual Scheduler* CreateScheduler();
00363 
00365   virtual void FetcherSetupHooks();
00366 
00370   virtual StringPiece LockFilePrefix();
00371 
00373   virtual void InitStaticAssetManager(
00374       StaticAssetManager* static_asset_manager) {}
00375 
00376  private:
00380   StaticAssetManager* DefaultStaticAssetManager();
00381 
00382   void SetupSlurpDirectories();
00383   void Init(); 
00384 
00385   scoped_ptr<MessageHandler> html_parse_message_handler_;
00386   scoped_ptr<MessageHandler> message_handler_;
00387   scoped_ptr<FileSystem> file_system_;
00388   UrlFetcher* url_fetcher_;
00389   UrlAsyncFetcher* url_async_fetcher_;
00390   UrlAsyncFetcher* distributed_async_fetcher_;
00391   scoped_ptr<UrlFetcher> base_url_fetcher_;
00392   scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_;
00393   scoped_ptr<UrlAsyncFetcher> base_distributed_async_fetcher_;
00394   scoped_ptr<Hasher> hasher_;
00395   scoped_ptr<FilenameEncoder> filename_encoder_;
00396   scoped_ptr<UrlNamer> url_namer_;
00397   scoped_ptr<UserAgentMatcher> user_agent_matcher_;
00398   scoped_ptr<StaticAssetManager> static_asset_manager_;
00399   scoped_ptr<Timer> timer_;
00400   scoped_ptr<Scheduler> scheduler_;
00401   scoped_ptr<UsageDataReporter> usage_data_reporter_;
00402 
00403   GoogleString filename_prefix_;
00404   GoogleString slurp_directory_;
00405   bool force_caching_;
00406   bool slurp_read_only_;
00407   bool slurp_print_urls_;
00408 
00410   typedef std::set<ServerContext*> ServerContextSet;
00411   ServerContextSet server_contexts_;
00412   scoped_ptr<AbstractMutex> server_context_mutex_;
00413 
00416   scoped_ptr<RewriteOptions> default_options_;
00417 
00419   scoped_ptr<NamedLockManager> lock_manager_;
00420 
00421   scoped_ptr<ThreadSystem> thread_system_;
00422 
00425   NullStatistics null_statistics_;
00426   Statistics* statistics_;
00427 
00428   StringSet created_directories_;
00429 
00430   std::vector<QueuedWorkerPool*> worker_pools_;
00431 
00434   scoped_ptr<RewriteStats> rewrite_stats_;
00435 
00438   std::vector<Function*> deferred_cleanups_;
00439 
00442   GoogleString version_string_;
00443 
00445   GoogleString hostname_;
00446 
00447   DISALLOW_COPY_AND_ASSIGN(RewriteDriverFactory);
00448 };
00449 
00452 template<class T> class RewriteDriverFactory::Deleter : public Function {
00453  public:
00454   explicit Deleter(T* obj) : obj_(obj) {}
00455   virtual void Run() { delete obj_; }
00456  private:
00457   T* obj_;
00458   DISALLOW_COPY_AND_ASSIGN(Deleter);
00459 };
00460 
00461 }  
00462 
00463 #endif  ///< NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Defines