com.google.gerrit.server.cache.CacheProvider Maven / Gradle / Ivy

Show more of this group Show more artifacts with this name
Show all versions of gerrit-plugin-api Show documentation
API for Gerrit Plugins
There is a newer version: 3.10.0-rc4
// Copyright (C) 2012 The Android Open Source Project
//
// 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.

package com.google.gerrit.server.cache;

import static java.util.concurrent.TimeUnit.SECONDS;

import com.google.common.base.Preconditions;
import com.google.common.base.Strings;
import com.google.common.cache.Cache;
import com.google.common.cache.CacheLoader;
import com.google.common.cache.Weigher;
import com.google.gerrit.common.Nullable;
import com.google.gerrit.extensions.annotations.PluginName;
import com.google.inject.Inject;
import com.google.inject.Provider;
import com.google.inject.TypeLiteral;
import java.util.concurrent.TimeUnit;

class CacheProvider implements Provider>, CacheBinding {
  private final CacheModule module;
  final String name;
  private final TypeLiteral keyType;
  private final TypeLiteral valType;
  private boolean persist;
  private long maximumWeight;
  private long diskLimit;
  private Long expireAfterWrite;
  private Provider> loader;
  private Provider> weigher;

  private String plugin;
  private MemoryCacheFactory memoryCacheFactory;
  private PersistentCacheFactory persistentCacheFactory;
  private boolean frozen;

  CacheProvider(CacheModule module, String name, TypeLiteral keyType, TypeLiteral valType) {
    this.module = module;
    this.name = name;
    this.keyType = keyType;
    this.valType = valType;
  }

  @Inject(optional = true)
  void setPluginName(@PluginName String pluginName) {
    this.plugin = pluginName;
  }

  @Inject
  void setMemoryCacheFactory(MemoryCacheFactory factory) {
    this.memoryCacheFactory = factory;
  }

  @Inject(optional = true)
  void setPersistentCacheFactory(@Nullable PersistentCacheFactory factory) {
    this.persistentCacheFactory = factory;
  }

  CacheBinding persist(boolean p) {
    Preconditions.checkState(!frozen, "binding frozen, cannot be modified");
    persist = p;
    return this;
  }

  @Override
  public CacheBinding maximumWeight(long weight) {
    Preconditions.checkState(!frozen, "binding frozen, cannot be modified");
    maximumWeight = weight;
    return this;
  }

  @Override
  public CacheBinding diskLimit(long limit) {
    Preconditions.checkState(!frozen, "binding frozen, cannot be modified");
    Preconditions.checkState(persist, "diskLimit supported for persistent caches only");
    diskLimit = limit;
    return this;
  }

  @Override
  public CacheBinding expireAfterWrite(long duration, TimeUnit unit) {
    Preconditions.checkState(!frozen, "binding frozen, cannot be modified");
    expireAfterWrite = SECONDS.convert(duration, unit);
    return this;
  }

  @Override
  public CacheBinding loader(Class> impl) {
    Preconditions.checkState(!frozen, "binding frozen, cannot be modified");
    loader = module.bindCacheLoader(this, impl);
    return this;
  }

  @Override
  public CacheBinding weigher(Class> impl) {
    Preconditions.checkState(!frozen, "binding frozen, cannot be modified");
    weigher = module.bindWeigher(this, impl);
    return this;
  }

  @Override
  public String name() {
    if (!Strings.isNullOrEmpty(plugin)) {
      return plugin + "." + name;
    }
    return name;
  }

  @Override
  public TypeLiteral keyType() {
    return keyType;
  }

  @Override
  public TypeLiteral valueType() {
    return valType;
  }

  @Override
  public long maximumWeight() {
    return maximumWeight;
  }

  @Override
  public long diskLimit() {
    if (diskLimit > 0) {
      return diskLimit;
    }
    return 128 << 20;
  }

  @Override
  @Nullable
  public Long expireAfterWrite(TimeUnit unit) {
    return expireAfterWrite != null ? unit.convert(expireAfterWrite, SECONDS) : null;
  }

  @Override
  @Nullable
  public Weigher weigher() {
    return weigher != null ? weigher.get() : null;
  }

  @Override
  @Nullable
  public CacheLoader loader() {
    return loader != null ? loader.get() : null;
  }

  @Override
  public Cache get() {
    frozen = true;

    if (loader != null) {
      CacheLoader ldr = loader.get();
      if (persist && persistentCacheFactory != null) {
        return persistentCacheFactory.build(this, ldr);
      }
      return memoryCacheFactory.build(this, ldr);
    } else if (persist && persistentCacheFactory != null) {
      return persistentCacheFactory.build(this);
    } else {
      return memoryCacheFactory.build(this);
    }
  }
}