/*
* Copyright (c) 2016 Cisco and/or its affiliates.
*
* 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 io.fd.honeycomb.translate.v3po.util.cache;
import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.Optional;
import io.fd.honeycomb.translate.v3po.util.cache.exceptions.check.DumpCheckFailedException;
import io.fd.honeycomb.translate.v3po.util.cache.exceptions.execution.DumpExecutionFailedException;
import io.fd.honeycomb.translate.v3po.util.cache.noop.NoopDumpPostProcessingFunction;
import io.fd.honeycomb.translate.ModificationCache;
import javax.annotation.Nonnull;
import org.openvpp.jvpp.dto.JVppReplyDump;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
/**
* Manager responsible for returning Data object dumps
either from cache or by invoking specified {@link
* EntityDumpExecutor}
*/
public final class DumpCacheManager {
private static final Logger LOG = LoggerFactory.getLogger(DumpCacheManager.class);
private final EntityDumpExecutor dumpExecutor;
private final EntityDumpNonEmptyCheck dumpNonEmptyCheck;
private final EntityDumpPostProcessingFunction postProcessor;
private DumpCacheManager(DumpCacheManagerBuilder builder) {
this.dumpExecutor = builder.dumpExecutor;
this.dumpNonEmptyCheck = builder.dumpNonEmptyCheck;
this.postProcessor = builder.postProcessingFunction;
}
/**
* Returns {@link Optional} of dump
*/
public Optional getDump(@Nonnull String entityKey, @Nonnull ModificationCache cache)
throws DumpExecutionFailedException {
//this key binding to every log has its logic ,because every customizer have its own cache manager and if
//there is need for debugging/fixing some complex call with a lot of data,you can get lost in those logs
LOG.debug("Loading dump for KEY[{}]", entityKey);
T dump = (T) cache.get(entityKey);
if (dump == null) {
LOG.debug("Dump for KEY[{}] not present in cache,invoking dump executor", entityKey);
dump = dumpExecutor.executeDump();
//this is not a critical exception, so its only logged here
try {
dumpNonEmptyCheck.assertNotEmpty(dump);
} catch (DumpCheckFailedException e) {
LOG.warn("Dump for KEY[{}] has been resolved as empty", entityKey, e);
return Optional.absent();
}
//no need to check if post processor active,if wasnt set,default no-op will be used
LOG.debug("Post-processing dump for KEY[{}]", entityKey);
dump = postProcessor.apply(dump);
LOG.debug("Caching dump for KEY[{}]", entityKey);
cache.put(entityKey, dump);
return Optional.of(dump);
} else {
return Optional.of(dump);
}
}
public static final class DumpCacheManagerBuilder {
private EntityDumpExecutor dumpExecutor;
private EntityDumpNonEmptyCheck dumpNonEmptyCheck;
private EntityDumpPostProcessingFunction postProcessingFunction;
public DumpCacheManagerBuilder() {
//for cases when user does not set specific post-processor
postProcessingFunction = new NoopDumpPostProcessingFunction();
}
public DumpCacheManagerBuilder withExecutor(@Nonnull EntityDumpExecutor executor) {
this.dumpExecutor = executor;
return this;
}
public DumpCacheManagerBuilder withNonEmptyPredicate(@Nonnull EntityDumpNonEmptyCheck check) {
this.dumpNonEmptyCheck = check;
return this;
}
public DumpCacheManagerBuilder withPostProcessingFunction(
EntityDumpPostProcessingFunction postProcessingFunction) {
this.postProcessingFunction = postProcessingFunction;
return this;
}
public DumpCacheManager build() {
checkNotNull(dumpExecutor, "Dump executor cannot be null");
checkNotNull(dumpNonEmptyCheck, "Dump verifier cannot be null");
checkNotNull(postProcessingFunction,
"Dump post-processor cannot be null cannot be null, default implementation is used if its not set");
return new DumpCacheManager<>(this);
}
}
}