00001
00002
00003
00004
00005
00006
00007
00008
00009
00010
00011
00012
00013
00014
00015
00016
00019
00020 #ifndef NET_INSTAWEB_REWRITER_PUBLIC_RESOURCE_MANAGER_H_
00021 #define NET_INSTAWEB_REWRITER_PUBLIC_RESOURCE_MANAGER_H_
00022
00023 #include <cstddef>
00024 #include <set>
00025 #include <vector>
00026
00027 #include "base/scoped_ptr.h"
00028 #include "net/instaweb/http/public/http_cache.h"
00029 #include "net/instaweb/rewriter/public/output_resource.h"
00030 #include "net/instaweb/rewriter/public/resource.h"
00031 #include "net/instaweb/util/public/atomic_bool.h"
00032 #include "net/instaweb/util/public/basictypes.h"
00033 #include "net/instaweb/util/public/md5_hasher.h"
00034 #include "net/instaweb/util/public/queued_worker_pool.h"
00035 #include "net/instaweb/util/public/ref_counted_ptr.h"
00036 #include "net/instaweb/util/public/string.h"
00037 #include "net/instaweb/util/public/string_util.h"
00038
00039 namespace net_instaweb {
00040
00041 class AbstractMutex;
00042 class BlinkCriticalLineDataFinder;
00043 class CacheInterface;
00044 class ContentType;
00045 class CriticalImagesFinder;
00046 class FileSystem;
00047 class FilenameEncoder;
00048 class Function;
00049 class GoogleUrl;
00050 class Hasher;
00051 class MessageHandler;
00052 class NamedLock;
00053 class NamedLockManager;
00054 class PropertyCache;
00055 class ResponseHeaders;
00056 class RewriteDriver;
00057 class RewriteDriverFactory;
00058 class RewriteOptions;
00059 class RewriteStats;
00060 class Scheduler;
00061 class StaticJavascriptManager;
00062 class Statistics;
00063 class ThreadSynchronizer;
00064 class ThreadSystem;
00065 class Timer;
00066 class UrlAsyncFetcher;
00067 class UrlNamer;
00068 class UsageDataReporter;
00069 class UserAgentMatcher;
00070
00071 typedef RefCountedPtr<OutputResource> OutputResourcePtr;
00072 typedef std::vector<OutputResourcePtr> OutputResourceVector;
00073
00077 class ResourceManager {
00078 public:
00080 static const int64 kGeneratedMaxAgeMs;
00081
00085 static const char kResourceEtagValue[];
00086 static const char kCacheKeyResourceNamePrefix[];
00087
00089 static const char kStatisticsGroup[];
00090
00091 explicit ResourceManager(RewriteDriverFactory* factory);
00092 virtual ~ResourceManager();
00093
00099 void SetDefaultLongCacheHeaders(const ContentType* content_type,
00100 ResponseHeaders* header) const {
00101 SetDefaultLongCacheHeadersWithCharset(content_type, StringPiece(), header);
00102 }
00103
00106 void SetDefaultLongCacheHeadersWithCharset(
00107 const ContentType* content_type, StringPiece charset,
00108 ResponseHeaders* header) const;
00109
00111 void SetContentType(const ContentType* content_type, ResponseHeaders* header);
00112
00113 void set_filename_prefix(const StringPiece& file_prefix);
00114 void set_statistics(Statistics* x) { statistics_ = x; }
00115 void set_rewrite_stats(RewriteStats* x) { rewrite_stats_ = x; }
00116 void set_relative_path(bool x) { relative_path_ = x; }
00117 void set_lock_manager(NamedLockManager* x) { lock_manager_ = x; }
00118 void set_http_cache(HTTPCache* x) { http_cache_ = x; }
00119 void set_page_property_cache(PropertyCache* x) { page_property_cache_ = x; }
00120 void set_client_property_cache(PropertyCache* x) {
00121 client_property_cache_ = x;
00122 }
00123 void set_metadata_cache(CacheInterface* x) { metadata_cache_ = x; }
00124 void set_message_handler(MessageHandler* x) { message_handler_ = x; }
00125
00126 StringPiece filename_prefix() const { return file_prefix_; }
00127 Statistics* statistics() const { return statistics_; }
00128 NamedLockManager* lock_manager() const { return lock_manager_; }
00129 RewriteDriverFactory* factory() const { return factory_; }
00130 ThreadSynchronizer* thread_synchronizer() {
00131 return thread_synchronizer_.get();
00132 }
00133
00146 bool Write(const ResourceVector& inputs, const StringPiece& contents,
00147 const ContentType* content_type, StringPiece charset,
00148 OutputResource* output, MessageHandler* handler);
00149
00158 void ApplyInputCacheControl(const ResourceVector& inputs,
00159 ResponseHeaders* headers);
00160
00162 bool IsPagespeedResource(const GoogleUrl& url);
00163
00166 bool IsImminentlyExpiring(int64 start_date_ms, int64 expire_ms) const;
00167
00168 void ComputeSignature(RewriteOptions* rewrite_options);
00169
00171 Hasher* hasher() const { return hasher_; }
00172 const Hasher* lock_hasher() const { return &lock_hasher_; }
00173 const Hasher* contents_hasher() const { return &contents_hasher_; }
00174 FileSystem* file_system() { return file_system_; }
00175 void set_file_system(FileSystem* fs ) { file_system_ = fs; }
00176 FilenameEncoder* filename_encoder() const { return filename_encoder_; }
00177 void set_filename_encoder(FilenameEncoder* x) { filename_encoder_ = x; }
00178 UrlNamer* url_namer() const { return url_namer_; }
00179 void set_url_namer(UrlNamer* n) { url_namer_ = n; }
00180 StaticJavascriptManager* static_javascript_manager() const {
00181 return static_javascript_manager_;
00182 }
00183 void set_static_javascript_manager(StaticJavascriptManager* manager) {
00184 static_javascript_manager_ = manager;
00185 }
00186 Scheduler* scheduler() const { return scheduler_; }
00187 void set_scheduler(Scheduler* s) { scheduler_ = s; }
00188 bool has_default_system_fetcher() { return default_system_fetcher_ != NULL; }
00189
00192 UrlAsyncFetcher* DefaultSystemFetcher() { return default_system_fetcher_; }
00193
00194 Timer* timer() const { return http_cache_->timer(); }
00195 HTTPCache* http_cache() const { return http_cache_; }
00196 PropertyCache* page_property_cache() const { return page_property_cache_; }
00197 PropertyCache* client_property_cache() const {
00198 return client_property_cache_;
00199 }
00200 CriticalImagesFinder* critical_images_finder() const {
00201 return critical_images_finder_;
00202 }
00203 void set_critical_images_finder(CriticalImagesFinder* finder) {
00204 critical_images_finder_ = finder;
00205 }
00206 const UserAgentMatcher& user_agent_matcher() { return *user_agent_matcher_; }
00207 void set_user_agent_matcher(UserAgentMatcher* n) { user_agent_matcher_ = n; }
00208
00209 BlinkCriticalLineDataFinder* blink_critical_line_data_finder() const {
00210 return blink_critical_line_data_finder_;
00211 }
00212
00213 void set_blink_critical_line_data_finder(
00214 BlinkCriticalLineDataFinder* finder) {
00215 blink_critical_line_data_finder_ = finder;
00216 }
00217
00222 CacheInterface* metadata_cache() { return metadata_cache_; }
00223
00226 bool store_outputs_in_file_system() { return store_outputs_in_file_system_; }
00227 void set_store_outputs_in_file_system(bool store) {
00228 store_outputs_in_file_system_ = store;
00229 }
00230
00231 void RefreshIfImminentlyExpiring(Resource* resource,
00232 MessageHandler* handler) const;
00233
00234 RewriteStats* rewrite_stats() const { return rewrite_stats_; }
00235 MessageHandler* message_handler() const { return message_handler_; }
00236
00241 void ReadAsync(Resource::NotCacheablePolicy not_cacheable_policy,
00242 Resource::AsyncCallback* callback);
00243
00248 NamedLock* MakeCreationLock(const GoogleString& name);
00249
00251 bool TryLockForCreation(NamedLock* creation_lock);
00252
00256 void LockForCreation(NamedLock* creation_lock,
00257 QueuedWorkerPool::Sequence* worker, Function* callback);
00258
00260 void set_hasher(Hasher* hasher) { hasher_ = hasher; }
00261 void set_default_system_fetcher(UrlAsyncFetcher* fetcher) {
00262 default_system_fetcher_ = fetcher;
00263 }
00264
00269 bool HandleBeacon(const StringPiece& unparsed_url);
00270
00275 RewriteDriver* decoding_driver() const { return decoding_driver_.get(); }
00276
00282 RewriteOptions* global_options();
00283
00285 RewriteOptions* NewOptions();
00286
00295 RewriteDriver* NewRewriteDriver();
00296
00309 RewriteDriver* NewUnmanagedRewriteDriver(
00310 bool is_custom, RewriteOptions* options);
00311
00322 RewriteDriver* NewCustomRewriteDriver(RewriteOptions* custom_options);
00323
00336 void ReleaseRewriteDriver(RewriteDriver* rewrite_driver);
00337
00338 ThreadSystem* thread_system() { return thread_system_; }
00339 UsageDataReporter* usage_data_reporter() { return usage_data_reporter_; }
00340
00343 void set_metadata_cache_readonly() {
00344 metadata_cache_readonly_.set_value(true);
00345 }
00346
00347 bool metadata_cache_readonly() const {
00348 return metadata_cache_readonly_.value();
00349 }
00350
00360 void ShutDownDrivers();
00361
00382 void MergeNonCachingResponseHeaders(const ResourcePtr& input,
00383 const OutputResourcePtr& output) {
00384 MergeNonCachingResponseHeaders(*input->response_headers(),
00385 output->response_headers());
00386 }
00387
00389 void MergeNonCachingResponseHeaders(const ResponseHeaders& input_headers,
00390 ResponseHeaders* output_headers);
00391
00393 QueuedWorkerPool* html_workers() { return html_workers_; }
00394
00396 QueuedWorkerPool* rewrite_workers() { return rewrite_workers_; }
00397
00400 QueuedWorkerPool* low_priority_rewrite_workers() {
00401 return low_priority_rewrite_workers_;
00402 }
00403
00407 size_t num_active_rewrite_drivers();
00408
00412 void InitWorkersAndDecodingDriver();
00413
00416 static bool IsExcludedAttribute(const char* attribute);
00417
00425 bool response_headers_finalized() const {
00426 return response_headers_finalized_;
00427 }
00428 void set_response_headers_finalized(bool x) {
00429 response_headers_finalized_ = x;
00430 }
00431
00432 private:
00433 friend class ResourceManagerTest;
00434 typedef std::set<RewriteDriver*> RewriteDriverSet;
00435
00437 void ReleaseRewriteDriverImpl(RewriteDriver* rewrite_driver);
00438
00440 ThreadSystem* thread_system_;
00441 RewriteStats* rewrite_stats_;
00442 GoogleString file_prefix_;
00443 int resource_id_;
00444 FileSystem* file_system_;
00445 FilenameEncoder* filename_encoder_;
00446 UrlNamer* url_namer_;
00447 UserAgentMatcher* user_agent_matcher_;
00448 Scheduler* scheduler_;
00449 UrlAsyncFetcher* default_system_fetcher_;
00450 Hasher* hasher_;
00451 CriticalImagesFinder* critical_images_finder_;
00452 BlinkCriticalLineDataFinder* blink_critical_line_data_finder_;
00453
00457 MD5Hasher lock_hasher_;
00458
00461 MD5Hasher contents_hasher_;
00462
00463 Statistics* statistics_;
00464
00465 HTTPCache* http_cache_;
00466 PropertyCache* page_property_cache_;
00467 PropertyCache* client_property_cache_;
00468 CacheInterface* metadata_cache_;
00469
00470 bool relative_path_;
00471 bool store_outputs_in_file_system_;
00472 bool response_headers_finalized_;
00473
00474 NamedLockManager* lock_manager_;
00475 MessageHandler* message_handler_;
00476
00481 std::vector<RewriteDriver*> available_rewrite_drivers_;
00482
00488 RewriteDriverSet active_rewrite_drivers_;
00489
00497 bool trying_to_cleanup_rewrite_drivers_;
00498 RewriteDriverSet deferred_release_rewrite_drivers_;
00499
00502 RewriteDriverFactory* factory_;
00503
00504 scoped_ptr<AbstractMutex> rewrite_drivers_mutex_;
00505
00509 scoped_ptr<RewriteOptions> base_class_options_;
00510
00520 scoped_ptr<RewriteDriver> decoding_driver_;
00521
00522 QueuedWorkerPool* html_workers_;
00523 QueuedWorkerPool* rewrite_workers_;
00524 QueuedWorkerPool* low_priority_rewrite_workers_;
00525
00526 AtomicBool metadata_cache_readonly_;
00527
00529 StaticJavascriptManager* static_javascript_manager_;
00530
00533 scoped_ptr<ThreadSynchronizer> thread_synchronizer_;
00534
00535 UsageDataReporter* usage_data_reporter_;
00536
00537 DISALLOW_COPY_AND_ASSIGN(ResourceManager);
00538 };
00539
00540 }
00541
00542 #endif ///< NET_INSTAWEB_REWRITER_PUBLIC_RESOURCE_MANAGER_H_