import static com.google.common.base.Preconditions.checkNotNull;
import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.ModificationCache;
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<br> either from cache or by invoking specified {@link
* EntityDumpExecutor}
*/
-public final class DumpCacheManager<T extends JVppReplyDump, U> {
+public final class DumpCacheManager<T, U> {
private static final Logger LOG = LoggerFactory.getLogger(DumpCacheManager.class);
/**
* Returns {@link Optional<T>} of dump
*/
- public Optional<T> getDump(@Nonnull String entityKey, @Nonnull ModificationCache cache)
+ public Optional<T> getDump(@Nonnull String entityKey, @Nonnull ModificationCache cache, final U dumpParams)
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
+ // 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);
+ // binds and execute dump to be thread-save
+ dump = dumpExecutor.executeDump(dumpParams);
- dump = dumpExecutor.executeDump();
-
- //this is not a critical exception, so its only logged here
+ // this is not a critical exception, so its only logged here
try {
dumpNonEmptyCheck.assertNotEmpty(dump);
} catch (DumpCheckFailedException e) {
return Optional.absent();
}
- //no need to check if post processor active,if wasnt set,default no-op will be used
+ // no need to check if post processor active,if wasn't set,default no-op will be used
LOG.debug("Post-processing dump for KEY[{}]", entityKey);
dump = postProcessor.apply(dump);
}
}
- public static final class DumpCacheManagerBuilder<T extends JVppReplyDump, U> {
+ public static final class DumpCacheManagerBuilder<T, U> {
private EntityDumpExecutor<T, U> dumpExecutor;
private EntityDumpNonEmptyCheck<T> dumpNonEmptyCheck;
private EntityDumpPostProcessingFunction<T> postProcessingFunction;
public DumpCacheManagerBuilder() {
- //for cases when user does not set specific post-processor
+ // for cases when user does not set specific post-processor
postProcessingFunction = new NoopDumpPostProcessingFunction<T>();
}
package io.fd.honeycomb.translate.v3po.util.cache;
import io.fd.honeycomb.translate.v3po.util.cache.exceptions.execution.DumpExecutionFailedException;
-import org.openvpp.jvpp.dto.JVppReplyDump;
+import javax.annotation.concurrent.ThreadSafe;
/**
- * Generic interface for classes that return dumps for Data objects
+ * Generic interface for classes that return dumps for Data objects.
+ * Must be implemented in Thread-save fashion.
*/
-public interface EntityDumpExecutor<T extends JVppReplyDump, U> {
+@ThreadSafe
+public interface EntityDumpExecutor<T, U> {
/**
- * Performs dump on {link T} entity
+ * Performs dump on {@link T} entity
*
* @return dump of specified {@link T} entity
* @throws DumpExecutionFailedException when dump fails
*/
- public T executeDump() throws DumpExecutionFailedException;
-
- /**
- * Bind dumping params for executor
- */
- default public void bindDumpParams(U params) {
- throw new UnsupportedOperationException("You should override this method if you need to bind dumping params");
- }
+ T executeDump(final U params) throws DumpExecutionFailedException;
}
import io.fd.honeycomb.translate.v3po.util.cache.exceptions.check.DumpCheckFailedException;
import io.fd.honeycomb.translate.v3po.util.cache.exceptions.check.i.DumpEmptyException;
-import org.openvpp.jvpp.dto.JVppReplyDump;
/**
* Generic interface for classes that verifies if dump of data object is non-empty
*/
-public interface EntityDumpNonEmptyCheck<T extends JVppReplyDump> {
+public interface EntityDumpNonEmptyCheck<T> {
/**
* Verifies if data are non-empty,if not throws {@link DumpEmptyException}
- * @throws DumpEmptyException
*/
public void assertNotEmpty(T data) throws DumpCheckFailedException;
}
package io.fd.honeycomb.translate.v3po.util.cache;
import java.util.function.Function;
-import org.openvpp.jvpp.dto.JVppReplyDump;
/**
* Generic interface for class that are post-processing data dumped from vpp
*/
@FunctionalInterface
-public interface EntityDumpPostProcessingFunction<T extends JVppReplyDump> extends Function<T, T> {
+public interface EntityDumpPostProcessingFunction<T> extends Function<T, T> {
/**
package io.fd.honeycomb.translate.v3po.util.cache.noop;
import io.fd.honeycomb.translate.v3po.util.cache.EntityDumpPostProcessingFunction;
-import org.openvpp.jvpp.dto.JVppReplyDump;
import org.slf4j.Logger;
import org.slf4j.LoggerFactory;
-public class NoopDumpPostProcessingFunction<T extends JVppReplyDump> implements EntityDumpPostProcessingFunction<T> {
+public class NoopDumpPostProcessingFunction<T> implements EntityDumpPostProcessingFunction<T> {
private static final Logger LOG = LoggerFactory.getLogger(NoopDumpPostProcessingFunction.class);
import static org.mockito.Mockito.when;
import com.google.common.base.Optional;
+import io.fd.honeycomb.translate.ModificationCache;
import io.fd.honeycomb.translate.v3po.util.cache.exceptions.check.i.DumpEmptyException;
import io.fd.honeycomb.translate.v3po.util.cache.exceptions.execution.DumpExecutionFailedException;
-import io.fd.honeycomb.translate.ModificationCache;
import org.junit.Before;
import org.junit.Test;
import org.mockito.Mock;
public void testCaching() throws DumpExecutionFailedException {
- Optional<IpDetailsReplyDump> stage1Optional = managerNegative.getDump(KEY, cache);
+ Optional<IpDetailsReplyDump> stage1Optional = managerNegative.getDump(KEY, cache, null);
//this is first call so instance should be from executor
assertEquals(false, stage1Optional.isPresent());
//rebind executor with other data
IpDetailsReplyDump stage2LoadedDump = new IpDetailsReplyDump();
- when(executor.executeDump()).thenReturn(stage2LoadedDump);
+ when(executor.executeDump(null)).thenReturn(stage2LoadedDump);
- Optional<IpDetailsReplyDump> stage2Optional = managerPositive.getDump(KEY, cache);
+ Optional<IpDetailsReplyDump> stage2Optional = managerPositive.getDump(KEY, cache, null);
assertEquals(true, stage2Optional.isPresent());
assertEquals(stage2LoadedDump, stage2Optional.get());
//rebind executor with other data
IpDetailsReplyDump stage3LoadedDump = new IpDetailsReplyDump();
- when(executor.executeDump()).thenReturn(stage3LoadedDump);
+ when(executor.executeDump(null)).thenReturn(stage3LoadedDump);
- Optional<IpDetailsReplyDump> stage3Optional = managerPositive.getDump(KEY, cache);
+ Optional<IpDetailsReplyDump> stage3Optional = managerPositive.getDump(KEY, cache, null);
assertEquals(true, stage3Optional.isPresent());
//check if it returns instance cached from previous stage
assertEquals(stage2LoadedDump, stage3Optional.get());
details.swIfIndex = 2;
dump.ipDetails.add(details);
- when(executor.executeDump()).thenReturn(dump);
+ when(executor.executeDump(null)).thenReturn(dump);
- Optional<IpDetailsReplyDump> optionalDump = managerPositiveWithPostProcessing.getDump(KEY, cache);
+ Optional<IpDetailsReplyDump> optionalDump = managerPositiveWithPostProcessing.getDump(KEY, cache, null);
assertEquals(true, optionalDump.isPresent());
assertEquals(1, optionalDump.get().ipDetails.size());
Code Review / hc2vpp.git / commitdiff