Page Speed Optimization Libraries  1.11.33.2
 All Classes Namespaces Files Functions Variables Typedefs Enumerations Enumerator Friends 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/controller/central_controller.h"
26 #include "pagespeed/kernel/base/abstract_mutex.h"
27 #include "pagespeed/kernel/base/basictypes.h"
28 #include "pagespeed/kernel/base/function.h"
29 #include "pagespeed/kernel/base/null_statistics.h"
30 #include "pagespeed/kernel/base/scoped_ptr.h"
31 #include "pagespeed/kernel/base/statistics.h"
32 #include "pagespeed/kernel/base/string.h"
33 #include "pagespeed/kernel/base/string_util.h"
34 #include "pagespeed/kernel/base/thread_system.h"
35 #include "pagespeed/kernel/thread/queued_worker_pool.h"
36 
37 namespace pagespeed { namespace js { struct JsTokenizerPatterns; } }
38 
39 namespace net_instaweb {
40 
41 class CriticalImagesFinder;
42 class CriticalSelectorFinder;
43 class FileSystem;
44 class FlushEarlyInfoFinder;
45 class ExperimentMatcher;
46 class Hasher;
47 class MessageHandler;
48 class NamedLockManager;
49 class NonceGenerator;
50 class ProcessContext;
51 class ServerContext;
52 class RewriteDriver;
53 class RewriteOptions;
54 class RewriteOptionsManager;
55 class RewriteStats;
56 class SHA1Signature;
57 class Scheduler;
58 class StaticAssetManager;
59 class Timer;
60 class UrlAsyncFetcher;
61 class UrlNamer;
62 class UsageDataReporter;
63 class UserAgentMatcher;
64 class UserAgentNormalizer;
65 
71  public:
73  template<class T> class Deleter;
74 
76  kHtmlWorkers,
77  kRewriteWorkers,
78  kLowPriorityRewriteWorkers,
81  };
82 
84  RewriteDriverFactory(const ProcessContext& process_context,
85  ThreadSystem* thread_system);
86 
92 
95  static void InitializeDefaultOptions(RewriteOptions* options);
96 
97  virtual ~RewriteDriverFactory();
98 
103  void set_html_parse_message_handler(MessageHandler* message_handler);
104  void set_message_handler(MessageHandler* message_handler);
105  void set_file_system(FileSystem* file_system);
106  void set_hasher(Hasher* hasher);
107  void set_nonce_generator(NonceGenerator* nonce_generator);
108  void set_url_namer(UrlNamer* url_namer);
109  void set_signature(SHA1Signature* signature);
110  void set_timer(Timer* timer);
111  void set_usage_data_reporter(UsageDataReporter* reporter);
112 
122  void set_slurp_directory(const StringPiece& directory);
123  void set_slurp_read_only(bool read_only);
124  void set_slurp_print_urls(bool read_only);
125 
128  void set_force_caching(bool u) { force_caching_ = u; }
129 
138  void set_base_url_async_fetcher(UrlAsyncFetcher* url_fetcher);
140  void set_base_distributed_async_fetcher(UrlAsyncFetcher* distributed_fetcher);
141  bool set_filename_prefix(StringPiece p);
142 
144  bool slurping_enabled() const { return !slurp_directory_.empty(); }
145 
146  MessageHandler* html_parse_message_handler();
147  MessageHandler* message_handler();
148  FileSystem* file_system();
149  NonceGenerator* nonce_generator();
152  Hasher* hasher();
153  UrlNamer* url_namer();
154  UserAgentMatcher* user_agent_matcher();
155  StaticAssetManager* static_asset_manager();
156  SHA1Signature* signature();
157  RewriteOptions* default_options() { return default_options_.get(); }
158  virtual RewriteOptionsManager* NewRewriteOptionsManager();
159 
164  Timer* timer();
165  NamedLockManager* lock_manager();
166  QueuedWorkerPool* WorkerPool(WorkerPoolCategory pool);
167  Scheduler* scheduler();
168  UsageDataReporter* usage_data_reporter();
169  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns() const {
170  return js_tokenizer_patterns_;
171  }
172  const std::vector<const UserAgentNormalizer*>& user_agent_normalizers();
173 
178  virtual UrlAsyncFetcher* ComputeUrlAsyncFetcher();
179  virtual UrlAsyncFetcher* ComputeDistributedFetcher();
180 
191  ServerContext* CreateServerContext();
192 
196  void InitServerContext(ServerContext* server_context);
197 
202  virtual void SetupCaches(ServerContext* server_context) = 0;
203 
207  virtual bool UseBeaconResultsInFilters() const = 0;
208 
212  virtual void AddPlatformSpecificRewritePasses(RewriteDriver* driver);
213 
222  virtual void AddPlatformSpecificDecodingPasses(RewriteDriver* driver);
223 
227  virtual void ApplyPlatformSpecificConfiguration(RewriteDriver* driver);
228 
229  ThreadSystem* thread_system() { return thread_system_.get(); }
230 
233  const StringSet& created_directories() const {
234  return created_directories_;
235  }
236 
237  bool async_rewrites() { return true; }
238 
243  RewriteStats* rewrite_stats();
244 
246  virtual bool HasWaveforms() const { return false; }
247 
250  Statistics* statistics() { return statistics_; }
251 
254  static void InitStats(Statistics* statistics);
255 
257  static void Initialize();
258  static void Terminate();
259 
261  void SetStatistics(Statistics* stats);
262 
266  virtual void ShutDown();
267 
269  void AddCreatedDirectory(const GoogleString& dir);
270 
276 
281 
283  const GoogleString& version_string() const { return version_string_; }
284  void set_version_string(const StringPiece& version_string) {
285  version_string.CopyToString(&version_string_);
286  }
287 
291  void defer_cleanup(Function* f) { deferred_cleanups_.push_back(f); }
292 
295  template<class T> void TakeOwnership(T* obj) {
297  }
298 
300  virtual bool IsDebugClient(const GoogleString& ip) const {
301  return false;
302  }
303 
307 
308  protected:
309  bool FetchersComputed() const;
310  virtual void StopCacheActivity();
311  StringPiece filename_prefix();
312 
316  bool TerminateServerContext(ServerContext* server_context);
317 
323  virtual MessageHandler* DefaultHtmlParseMessageHandler() = 0;
324  virtual MessageHandler* DefaultMessageHandler() = 0;
325  virtual FileSystem* DefaultFileSystem() = 0;
326  virtual NonceGenerator* DefaultNonceGenerator();
327  virtual Timer* DefaultTimer();
328  virtual SHA1Signature* DefaultSignature();
329 
330  virtual Hasher* NewHasher() = 0;
331 
334  virtual ServerContext* NewServerContext() = 0;
335 
346 
347  virtual UrlAsyncFetcher* DefaultDistributedUrlFetcher() { return NULL; }
348 
349  virtual CriticalImagesFinder* DefaultCriticalImagesFinder(
350  ServerContext* server_context);
351  virtual CriticalSelectorFinder* DefaultCriticalSelectorFinder(
352  ServerContext* server_context);
353 
355  virtual FlushEarlyInfoFinder* DefaultFlushEarlyInfoFinder();
356 
359  virtual NamedLockManager* DefaultLockManager();
360 
363  virtual UrlNamer* DefaultUrlNamer();
364 
365  virtual UserAgentMatcher* DefaultUserAgentMatcher();
366  virtual UsageDataReporter* DefaultUsageDataReporter();
367 
375  std::vector<const UserAgentNormalizer*>* out);
376 
380  virtual QueuedWorkerPool* CreateWorkerPool(WorkerPoolCategory pool,
381  StringPiece name);
382 
389  virtual int LowPriorityLoadSheddingThreshold() const;
390 
393  virtual Scheduler* CreateScheduler();
394 
396  virtual void FetcherSetupHooks();
397 
401  virtual StringPiece LockFilePrefix();
402 
405  StaticAssetManager* static_asset_manager) {}
406 
410 
418  virtual CentralController* CreateCentralController(
419  NamedLockManager* lock_manager);
420 
422  void RebuildDecodingDriverForTests(ServerContext* server_context);
423 
424  void reset_default_options(RewriteOptions* new_defaults);
425 
426  private:
430  StaticAssetManager* DefaultStaticAssetManager();
431 
432  void SetupSlurpDirectories();
433 
434  void InitDecodingDriver(ServerContext* server_context);
435 
436  scoped_ptr<MessageHandler> html_parse_message_handler_;
437  scoped_ptr<MessageHandler> message_handler_;
438  scoped_ptr<FileSystem> file_system_;
439  UrlAsyncFetcher* url_async_fetcher_;
440  UrlAsyncFetcher* distributed_async_fetcher_;
441  scoped_ptr<UrlAsyncFetcher> base_url_async_fetcher_;
442  scoped_ptr<UrlAsyncFetcher> base_distributed_async_fetcher_;
443  scoped_ptr<Hasher> hasher_;
444  scoped_ptr<NonceGenerator> nonce_generator_;
445  scoped_ptr<SHA1Signature> signature_;
446  scoped_ptr<UrlNamer> url_namer_;
447  scoped_ptr<UserAgentMatcher> user_agent_matcher_;
448 
452  std::vector<const UserAgentNormalizer*> user_agent_normalizers_;
453  scoped_ptr<StaticAssetManager> static_asset_manager_;
454  scoped_ptr<Timer> timer_;
455  scoped_ptr<Scheduler> scheduler_;
456  scoped_ptr<UsageDataReporter> usage_data_reporter_;
458  const pagespeed::js::JsTokenizerPatterns* js_tokenizer_patterns_;
459 
460  GoogleString filename_prefix_;
461  GoogleString slurp_directory_;
462  bool force_caching_;
463  bool slurp_read_only_;
464  bool slurp_print_urls_;
465 
466  scoped_ptr<ThreadSystem> thread_system_;
467 
469  typedef std::set<ServerContext*> ServerContextSet;
470  ServerContextSet server_contexts_;
471  scoped_ptr<AbstractMutex> server_context_mutex_;
472 
475  scoped_ptr<RewriteOptions> default_options_;
476 
484  scoped_ptr<ServerContext> decoding_server_context_;
485  scoped_ptr<RewriteDriver> decoding_driver_;
486 
488  scoped_ptr<NamedLockManager> lock_manager_;
489 
492  NullStatistics null_statistics_;
493  Statistics* statistics_;
494 
495  StringSet created_directories_;
496 
497  std::vector<QueuedWorkerPool*> worker_pools_;
498 
501  scoped_ptr<RewriteStats> rewrite_stats_;
502 
505  std::vector<Function*> deferred_cleanups_;
506 
509  GoogleString version_string_;
510 
512  GoogleString hostname_;
513 
514 
515 };
516 
519 template<class T> class RewriteDriverFactory::Deleter : public Function {
520  public:
521  explicit Deleter(T* obj) : obj_(obj) {}
522  virtual void Run() { delete obj_; }
523  private:
524  T* obj_;
525 
526 };
527 
528 }
529 
530 #endif
Definition: url_namer.h:38
virtual RewriteOptions * NewRewriteOptions()
virtual int LowPriorityLoadSheddingThreshold() const
bool slurping_enabled() const
Determines whether Slurping is enabled.
Definition: rewrite_driver_factory.h:144
virtual RewriteOptions * NewRewriteOptionsForQuery()
virtual void InitStaticAssetManager(StaticAssetManager *static_asset_manager)
Initializes the StaticAssetManager.
Definition: rewrite_driver_factory.h:404
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:47
const GoogleString & version_string() const
get/set the version placed into the X-[Mod-]Page(s|-S)peed header.
Definition: rewrite_driver_factory.h:283
const StringSet & created_directories() const
Definition: rewrite_driver_factory.h:233
bool TerminateServerContext(ServerContext *server_context)
virtual UrlNamer * DefaultUrlNamer()
void set_force_caching(bool u)
Definition: rewrite_driver_factory.h:128
WorkerPoolCategory
Definition: rewrite_driver_factory.h:75
void set_html_parse_message_handler(MessageHandler *message_handler)
virtual ServerContext * NewServerContext()=0
virtual NamedLockManager * DefaultLockManager()
virtual Scheduler * CreateScheduler()
virtual ServerContext * NewDecodingServerContext()=0
void TakeOwnership(T *obj)
Definition: rewrite_driver_factory.h:295
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:80
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)
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:291
virtual CentralController * CreateCentralController(NamedLockManager *lock_manager)
RewriteDriverFactory(const ProcessContext &process_context, ThreadSystem *thread_system)
Takes ownership of thread_system.
virtual UrlAsyncFetcher * DefaultAsyncUrlFetcher()=0
ServerContext * CreateServerContext()
void set_base_url_async_fetcher(UrlAsyncFetcher *url_fetcher)
void InitServerContext(ServerContext *server_context)
Definition: server_context.h:100
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:250
virtual StringPiece LockFilePrefix()
virtual void ApplyPlatformSpecificConfiguration(RewriteDriver *driver)
Definition: usage_data_reporter.h:35
void set_slurp_directory(const StringPiece &directory)
Helper for users of defer_cleanup; see below.
Definition: rewrite_driver_factory.h:73
void SetStatistics(Statistics *stats)
Does not take ownership of Statistics.
Definition: rewrite_options.h:84
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:300
Definition: url_async_fetcher.h:33
static void InitStats(Statistics *statistics)
virtual bool UseBeaconResultsInFilters() const =0
Definition: rewrite_driver_factory.h:70
virtual bool HasWaveforms() const
Returns true if the server supports waveforms in its status page.
Definition: rewrite_driver_factory.h:246