Page Speed Optimization Libraries  1.9.32.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends Macros Pages
rewrite_driver_factory.h
Go to the documentation of this file.
1 /*
2  * Copyright 2010 Google Inc.
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  * http:///www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
18 
19 #ifndef NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
20 #define NET_INSTAWEB_REWRITER_PUBLIC_REWRITE_DRIVER_FACTORY_H_
21 
22 #include <set>
23 #include <vector>
24 
25 #include "pagespeed/kernel/base/basictypes.h"
26 #include "pagespeed/kernel/base/function.h"
27 #include "pagespeed/kernel/base/null_statistics.h"
28 #include "pagespeed/kernel/base/scoped_ptr.h"
29 #include "pagespeed/kernel/base/string.h"
30 #include "pagespeed/kernel/base/string_util.h"
31 
32 namespace pagespeed { namespace js { struct JsTokenizerPatterns; } }
33 
34 namespace net_instaweb {
35 
36 class AbstractMutex;
37 class CacheHtmlInfoFinder;
38 class CriticalCssFinder;
39 class CriticalImagesFinder;
40 class CriticalLineInfoFinder;
41 class CriticalSelectorFinder;
42 class FileSystem;
43 class FlushEarlyInfoFinder;
44 class ExperimentMatcher;
45 class Hasher;
46 class MessageHandler;
47 class NamedLockManager;
48 class NonceGenerator;
49 class ProcessContext;
50 class PropertyCache;
51 class QueuedWorkerPool;
52 class ServerContext;
53 class RewriteDriver;
54 class RewriteOptions;
55 class RewriteOptionsManager;
56 class RewriteStats;
57 class SHA1Signature;
58 class Scheduler;
59 class StaticAssetManager;
60 class Statistics;
61 class ThreadSystem;
62 class Timer;
63 class UrlAsyncFetcher;
64 class UrlNamer;
65 class UsageDataReporter;
66 class UserAgentMatcher;
67 class UserAgentNormalizer;
68 
74  public:
76  template<class T> class Deleter;
77 
79  kHtmlWorkers,
80  kRewriteWorkers,
81  kLowPriorityRewriteWorkers,
84  };
85 
87  RewriteDriverFactory(const ProcessContext& process_context,
88  ThreadSystem* thread_system);
89 
95 
96  virtual ~RewriteDriverFactory();
97 
102  void set_html_parse_message_handler(MessageHandler* message_handler);
103  void set_message_handler(MessageHandler* message_handler);
104  void set_file_system(FileSystem* file_system);
105  void set_hasher(Hasher* hasher);
106  void set_nonce_generator(NonceGenerator* nonce_generator);
107  void set_url_namer(UrlNamer* url_namer);
108  void set_signature(SHA1Signature* signature);
109  void set_timer(Timer* timer);
110  void set_usage_data_reporter(UsageDataReporter* reporter);
111 
121  void set_slurp_directory(const StringPiece& directory);
122  void set_slurp_read_only(bool read_only);
123  void set_slurp_print_urls(bool read_only);
124 
127  void set_force_caching(bool u) { force_caching_ = u; }
128 
137  void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher);
139  void set_base_distributed_async_fetcher(UrlAsyncFetcher* distributed_fetcher);
140  bool set_filename_prefix(StringPiece p);
141 
143  bool slurping_enabled() const { return !slurp_directory_.empty(); }
144 
145  MessageHandler* html_parse_message_handler();
146  MessageHandler* message_handler();
147  FileSystem* file_system();
148  NonceGenerator* nonce_generator();
151  Hasher* hasher();
152  UrlNamer* url_namer();
153  UserAgentMatcher* user_agent_matcher();
154  StaticAssetManager* static_asset_manager();
155  SHA1Signature* signature();
156  RewriteOptions* default_options() { return default_options_.get(); }
157  virtual RewriteOptionsManager* NewRewriteOptionsManager();
158 
163  Timer* timer();
164  NamedLockManager* lock_manager();
165  QueuedWorkerPool* WorkerPool(WorkerPoolCategory pool);
166  Scheduler* scheduler();
167  UsageDataReporter* usage_data_reporter();
168  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns() const {
169  return js_tokenizer_patterns_;
170  }
171  const std::vector<const UserAgentNormalizer*>& user_agent_normalizers();
172 
177  virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher();
178  virtual UrlAsyncFetcher* ComputeDistributedFetcher();
179 
186  ServerContext* CreateServerContext();
187 
191  void InitServerContext(ServerContext* server_context);
192 
197  virtual void SetupCaches(ServerContext* server_context) = 0;
198 
202  virtual bool UseBeaconResultsInFilters() const = 0;
203 
207  virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver);
208 
217  virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver);
218 
222  virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver);
223 
224  ThreadSystem* thread_system() { return thread_system_.get(); }
225 
228  const StringSet& created_directories() const {
229  return created_directories_;
230  }
231 
232  bool async_rewrites() { return true; }
233 
238  RewriteStats* rewrite_stats();
239 
242  Statistics* statistics() { return statistics_; }
243 
246  static void InitStats(Statistics* statistics);
247 
249  static void Initialize();
250  static void Terminate();
251 
253  void SetStatistics(Statistics* stats);
254 
258  virtual void ShutDown();
259 
261  void AddCreatedDirectory(const GoogleString& dir);
262 
268 
273 
275  const GoogleString& version_string() const { return version_string_; }
276  void set_version_string(const StringPiece& version_string) {
277  version_string.CopyToString(&version_string_);
278  }
279 
283  void defer_cleanup(Function* f) { deferred_cleanups_.push_back(f); }
284 
287  template<class T> void TakeOwnership(T* obj) {
289  }
290 
292  virtual bool IsDebugClient(const GoogleString& ip) const {
293  return false;
294  }
295 
299 
301  const std::vector<int>* preferred_webp_qualities() {
302  return &preferred_webp_qualities_;
303  }
304 
306  const std::vector<int>* preferred_jpeg_qualities() {
307  return &preferred_jpeg_qualities_;
308  }
309 
311  bool SetPreferredWebpQualities(const StringPiece& qualities);
312 
314  bool SetPreferredJpegQualities(const StringPiece& qualities);
315 
316  protected:
317  bool FetchersComputed() const;
318  virtual void StopCacheActivity();
319  StringPiece filename_prefix();
320 
324  bool TerminateServerContext(ServerContext* server_context);
325 
331  virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0;
332  virtual MessageHandler* DefaultMessageHandler() = 0;
333  virtual FileSystem* DefaultFileSystem() = 0;
334  virtual NonceGenerator* DefaultNonceGenerator();
335  virtual Timer* DefaultTimer();
336  virtual SHA1Signature* DefaultSignature();
337 
338  virtual Hasher* NewHasher() = 0;
339 
342  virtual ServerContext* NewServerContext() = 0;
343 
354 
355  virtual UrlAsyncFetcher* DefaultDistributedUrlFetcher() { return NULL; }
356 
357  virtual CriticalCssFinder* DefaultCriticalCssFinder();
358  virtual CriticalImagesFinder* DefaultCriticalImagesFinder(
359  ServerContext* server_context);
360  virtual CriticalSelectorFinder* DefaultCriticalSelectorFinder(
361  ServerContext* server_context);
362 
364  virtual CacheHtmlInfoFinder* DefaultCacheHtmlInfoFinder(
365  PropertyCache* cache, ServerContext* server_context);
366 
368  virtual FlushEarlyInfoFinder* DefaultFlushEarlyInfoFinder();
369 
371  virtual CriticalLineInfoFinder* DefaultCriticalLineInfoFinder(
372  ServerContext* server_context);
373 
376  virtual NamedLockManager* DefaultLockManager();
377 
380  virtual UrlNamer* DefaultUrlNamer();
381 
382  virtual UserAgentMatcher* DefaultUserAgentMatcher();
383  virtual UsageDataReporter* DefaultUsageDataReporter();
384 
392  std::vector<const UserAgentNormalizer*>* out);
393 
397  virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool,
398  StringPiece name);
399 
406  virtual int LowPriorityLoadSheddingThreshold() const;
407 
410  virtual Scheduler* CreateScheduler();
411 
413  virtual void FetcherSetupHooks();
414 
418  virtual StringPiece LockFilePrefix();
419 
422  StaticAssetManager* static_asset_manager) {}
423 
427 
429  void RebuildDecodingDriverForTests(ServerContext* server_context);
430 
431  private:
435  StaticAssetManager* DefaultStaticAssetManager();
436 
437  void SetupSlurpDirectories();
438  void Init();
439 
440  void InitDecodingDriver(ServerContext* server_context);
441 
442  scoped_ptr<MessageHandler> html_parse_message_handler_;
443  scoped_ptr<MessageHandler> message_handler_;
444  scoped_ptr<FileSystem> file_system_;
445  UrlAsyncFetcher* url_async_fetcher_;
446  UrlAsyncFetcher* distributed_async_fetcher_;
447  scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_;
448  scoped_ptr<UrlAsyncFetcher> base_distributed_async_fetcher_;
449  scoped_ptr<Hasher> hasher_;
450  scoped_ptr<NonceGenerator> nonce_generator_;
451  scoped_ptr<SHA1Signature> signature_;
452  scoped_ptr<UrlNamer> url_namer_;
453  scoped_ptr<UserAgentMatcher> user_agent_matcher_;
454 
458  std::vector<const UserAgentNormalizer*> user_agent_normalizers_;
459  scoped_ptr<StaticAssetManager> static_asset_manager_;
460  scoped_ptr<Timer> timer_;
461  scoped_ptr<Scheduler> scheduler_;
462  scoped_ptr<UsageDataReporter> usage_data_reporter_;
464  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns_;
465 
466  GoogleString filename_prefix_;
467  GoogleString slurp_directory_;
468  bool force_caching_;
469  bool slurp_read_only_;
470  bool slurp_print_urls_;
471 
473  typedef std::set<ServerContext*> ServerContextSet;
474  ServerContextSet server_contexts_;
475  scoped_ptr<AbstractMutex> server_context_mutex_;
476 
479  scoped_ptr<RewriteOptions> default_options_;
480 
488  scoped_ptr<ServerContext> decoding_server_context_;
489  scoped_ptr<RewriteDriver> decoding_driver_;
490 
492  scoped_ptr<NamedLockManager> lock_manager_;
493 
494  scoped_ptr<ThreadSystem> thread_system_;
495 
498  NullStatistics null_statistics_;
499  Statistics* statistics_;
500 
501  StringSet created_directories_;
502 
503  std::vector<QueuedWorkerPool*> worker_pools_;
504 
507  scoped_ptr<RewriteStats> rewrite_stats_;
508 
511  std::vector<Function*> deferred_cleanups_;
512 
515  GoogleString version_string_;
516 
518  GoogleString hostname_;
519 
524  std::vector<int> preferred_webp_qualities_;
525  std::vector<int> preferred_jpeg_qualities_;
526 
527  DISALLOW_COPY_AND_ASSIGN(RewriteDriverFactory);
528 };
529 
532 template<class T> class RewriteDriverFactory::Deleter : public Function {
533  public:
534  explicit Deleter(T* obj) : obj_(obj) {}
535  virtual void Run() { delete obj_; }
536  private:
537  T* obj_;
538  DISALLOW_COPY_AND_ASSIGN(Deleter);
539 };
540 
541 }
542 
543 #endif
Definition: url_namer.h:37
virtual RewriteOptions * NewRewriteOptions()
virtual CriticalLineInfoFinder * DefaultCriticalLineInfoFinder(ServerContext *server_context)
Default implementation returns a valid CriticalSelectorFinder.
virtual int LowPriorityLoadSheddingThreshold() const
bool slurping_enabled() const
Determines whether Slurping is enabled.
Definition: rewrite_driver_factory.h:143
virtual RewriteOptions * NewRewriteOptionsForQuery()
virtual void InitStaticAssetManager(StaticAssetManager *static_asset_manager)
Initializes the StaticAssetManager.
Definition: rewrite_driver_factory.h:421
virtual void SetupCaches(ServerContext *server_context)=0
virtual void AddPlatformSpecificDecodingPasses(RewriteDriver *driver)
Definition: experiment_matcher.h:38
virtual FlushEarlyInfoFinder * DefaultFlushEarlyInfoFinder()
Default implementation returns NULL.
void RebuildDecodingDriverForTests(ServerContext *server_context)
For use in tests.
Definition: static_asset_manager.h:44
const GoogleString & version_string() const
get/set the version placed into the X-[Mod-]Page(s|-S)peed header.
Definition: rewrite_driver_factory.h:275
const StringSet & created_directories() const
Definition: rewrite_driver_factory.h:228
bool TerminateServerContext(ServerContext *server_context)
virtual UrlNamer * DefaultUrlNamer()
void set_force_caching(bool u)
Definition: rewrite_driver_factory.h:127
WorkerPoolCategory
Definition: rewrite_driver_factory.h:78
void set_html_parse_message_handler(MessageHandler *message_handler)
virtual ServerContext * NewServerContext()=0
virtual NamedLockManager * DefaultLockManager()
virtual Scheduler * CreateScheduler()
const std::vector< int > * preferred_jpeg_qualities()
Returns the preferred jpeg image quality vector for client options.
Definition: rewrite_driver_factory.h:306
virtual ServerContext * NewDecodingServerContext()=0
void TakeOwnership(T *obj)
Definition: rewrite_driver_factory.h:287
void AddCreatedDirectory(const GoogleString &dir)
Registers the directory as having been created by us.
Make sure to insert new values above this line.
Definition: rewrite_driver_factory.h:83
void InitStubDecodingServerContext(ServerContext *context)
virtual ExperimentMatcher * NewExperimentMatcher()
void set_base_distributed_async_fetcher(UrlAsyncFetcher *distributed_fetcher)
Takes ownership of distributed_fetcher.
virtual UrlAsyncFetcher * ComputeUrlAsyncFetcher()
virtual void AddPlatformSpecificRewritePasses(RewriteDriver *driver)
const std::vector< int > * preferred_webp_qualities()
Returns the preferred webp image quality vector for client options.
Definition: rewrite_driver_factory.h:301
virtual void AddPlatformSpecificUserAgentNormalizers(std::vector< const UserAgentNormalizer * > *out)
virtual void FetcherSetupHooks()
Called before creating the url fetchers.
void defer_cleanup(Function *f)
Definition: rewrite_driver_factory.h:283
RewriteDriverFactory(const ProcessContext &process_context, ThreadSystem *thread_system)
Takes ownership of thread_system.
virtual UrlAsyncFetcher * DefaultAsyncUrlFetcher()=0
bool SetPreferredWebpQualities(const StringPiece &qualities)
Returns true if the correct number of WebP qualities are parsed and set.
ServerContext * CreateServerContext()
bool SetPreferredJpegQualities(const StringPiece &qualities)
Returns true if the correct number of JPEG qualities are parsed and set.
void set_base_url_async_fetcher(UrlAsyncFetcher *url_fetcher)
void InitServerContext(ServerContext *server_context)
Definition: server_context.h:101
static void Initialize()
Initializes static variables. Initialize/Terminate calls must be paired.
Definition: process_context.h:35
virtual QueuedWorkerPool * CreateWorkerPool(WorkerPoolCategory pool, StringPiece name)
Statistics * statistics()
Definition: rewrite_driver_factory.h:242
virtual StringPiece LockFilePrefix()
virtual void ApplyPlatformSpecificConfiguration(RewriteDriver *driver)
Definition: usage_data_reporter.h:35
void set_slurp_directory(const StringPiece &directory)
virtual CacheHtmlInfoFinder * DefaultCacheHtmlInfoFinder(PropertyCache *cache, ServerContext *server_context)
Default implementation returns NULL.
Helper for users of defer_cleanup; see below.
Definition: rewrite_driver_factory.h:76
void SetStatistics(Statistics *stats)
Does not take ownership of Statistics.
Definition: rewrite_options.h:83
virtual bool IsDebugClient(const GoogleString &ip) const
Base method that returns true if the given ip is a debug ip.
Definition: rewrite_driver_factory.h:292
Definition: url_async_fetcher.h:33
static void InitStats(Statistics *statistics)
virtual bool UseBeaconResultsInFilters() const =0
Definition: rewrite_driver_factory.h:73