static_asset_manager.h

Go to the documentation of this file.

/*
 * Copyright 2012 Google Inc.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http:///www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */


#ifndef NET_INSTAWEB_REWRITER_PUBLIC_STATIC_ASSET_MANAGER_H_
#define NET_INSTAWEB_REWRITER_PUBLIC_STATIC_ASSET_MANAGER_H_

#include <map>
#include <vector>
#include <cstddef>                     

#include "net/instaweb/rewriter/static_asset_config.pb.h"
#include "pagespeed/kernel/base/abstract_mutex.h"
#include "pagespeed/kernel/base/basictypes.h"
#include "pagespeed/kernel/base/scoped_ptr.h"
#include "pagespeed/kernel/base/string.h"
#include "pagespeed/kernel/base/string_util.h"
#include "pagespeed/kernel/base/thread_annotations.h"
#include "pagespeed/kernel/base/thread_system.h"
#include "pagespeed/kernel/http/content_type.h"

namespace net_instaweb {

class Hasher;
class MessageHandler;
class RewriteOptions;

class StaticAssetManager {
 public:
  static const char kGStaticBase[];
  static const char kDefaultLibraryUrlPrefix[];

  enum ConfigurationMode {
    kInitialConfiguration,
    kUpdateConfiguration
  };

  StaticAssetManager(const GoogleString& static_asset_base,
                     ThreadSystem* threads,
                     Hasher* hasher,
                     MessageHandler* message_handler);

  ~StaticAssetManager();

  bool IsValidIndex(size_t i) const {
    lock_->Lock();
    bool valid = (i <= assets_.size()) && (assets_[i]->file_name != nullptr);
    lock_->Unlock();
    return valid;
  }

  const GoogleString& GetAssetUrl(StaticAssetEnum::StaticAsset module,
                                  const RewriteOptions* options) const;

  const char* GetAsset(StaticAssetEnum::StaticAsset module,
                       const RewriteOptions* options) const;

  bool GetAsset(StringPiece file_name, StringPiece* content,
                ContentType* content_type, StringPiece* cache_header) const;

  void SetGStaticHashForTest(StaticAssetEnum::StaticAsset module,
                             const GoogleString& hash);

  void ServeAssetsFromGStatic(StringPiece gstatic_base) {
    ScopedMutex write_lock(lock_.get());
    serve_assets_from_gstatic_ = true;
    gstatic_base.CopyToString(&gstatic_base_);
  }

  void DoNotServeAssetsFromGStatic() {
    ScopedMutex write_lock(lock_.get());
    serve_assets_from_gstatic_ = false;
    gstatic_base_.clear();
  }

  void ApplyGStaticConfiguration(const StaticAssetConfig& config,
                                 ConfigurationMode mode);

  void ResetGStaticConfiguration();

  void set_library_url_prefix(const StringPiece& url_prefix) {
    ScopedMutex write_lock(lock_.get());
    url_prefix.CopyToString(&library_url_prefix_);
    InitializeAssetUrls();
  }

  void set_static_asset_base(const StringPiece& x) {
    ScopedMutex write_lock(lock_.get());
    x.CopyToString(&static_asset_base_);
    InitializeAssetUrls();
  }

 private:
  struct Asset {
    const char* file_name;
    GoogleString js_optimized;
    GoogleString js_debug;
    GoogleString js_opt_hash;
    GoogleString js_debug_hash;
    GoogleString opt_url;
    GoogleString debug_url;
    GoogleString release_label;
    ContentType content_type;
  };

  typedef std::map<GoogleString, StaticAssetEnum::StaticAsset>
      FileNameToModuleMap;

  void InitializeAssetStrings();
  void InitializeAssetUrls() EXCLUSIVE_LOCKS_REQUIRED(lock_);


  void ApplyGStaticConfigurationImpl(const StaticAssetConfig& config,
                                     ConfigurationMode mode)
      EXCLUSIVE_LOCKS_REQUIRED(lock_);

  GoogleString static_asset_base_;
  Hasher* hasher_;
  MessageHandler* message_handler_;

  scoped_ptr<ThreadSystem::RWLock> lock_;
  std::vector<Asset*> assets_ GUARDED_BY(lock_);
  FileNameToModuleMap file_name_to_module_map_ GUARDED_BY(lock_);

  bool serve_assets_from_gstatic_ GUARDED_BY(lock_);
  GoogleString gstatic_base_ GUARDED_BY(lock_);
  scoped_ptr<StaticAssetConfig> initial_gstatic_config_ GUARDED_BY(lock_);
  GoogleString library_url_prefix_ GUARDED_BY(lock_);
  GoogleString cache_header_with_long_ttl_ GUARDED_BY(lock_);
  GoogleString cache_header_with_private_ttl_ GUARDED_BY(lock_);

  
};

}  

#endif