introduce CachedValue to prevent overhead of repeated process exectuion (#1489)

Author: hohwille

cli/src/main/java/com/devonfw/tools/ide/cache/CachedValue.java

@@ -0,0 +1,62 @@
+package com.devonfw.tools.ide.cache;
+
+import java.util.function.Supplier;
+
+/**
+ * A cached value that allows a good balance between reducing computing overhead and still providing accuracy.
+ *
+ * @param <T> type of the {@link #get() value}.
+ */
+public class CachedValue<T> implements Supplier<T> {
+
+  private static final long DEFAULT_RETENTION = 20 * 1000; // 20 seconds
+
+  private final Supplier<T> supplier;
+
+  private final long retention;
+
+  private long timestamp;
+
+  private T value;
+
+  /**
+   * The constructor.
+   *
+   * @param supplier the {@link Supplier} function to compute the actual value.
+   */
+  public CachedValue(Supplier<T> supplier) {
+    this(supplier, DEFAULT_RETENTION);
+  }
+
+
+  /**
+   * The constructor.
+   *
+   * @param supplier the {@link Supplier} function to compute the actual value.
+   */
+  public CachedValue(Supplier<T> supplier, long retention) {
+    super();
+    this.supplier = supplier;
+    this.retention = retention;
+  }
+
+  @Override
+  public T get() {
+
+    long now = System.currentTimeMillis();
+    if ((now - this.timestamp) > retention) {
+      this.timestamp = now;
+      this.value = this.supplier.get();
+    }
+    return this.value;
+  }
+
+  /**
+   * Invalidates a potentially cached value.
+   */
+  public void invalidate() {
+
+    this.timestamp = 0;
+    this.value = null;
+  }
+}

cli/src/main/java/com/devonfw/tools/ide/tool/npm/NpmBasedCommandlet.java

@@ -4,6 +4,7 @@
 import java.util.List;
 import java.util.Set;
 
+import com.devonfw.tools.ide.cache.CachedValue;
 import com.devonfw.tools.ide.common.Tag;
 import com.devonfw.tools.ide.context.IdeContext;
 import com.devonfw.tools.ide.process.ProcessContext;
@@ -19,6 +20,8 @@
  */
 public abstract class NpmBasedCommandlet extends LocalToolCommandlet {
 
+  private final CachedValue<VersionIdentifier> installedVersion;
+
   /**
    * The constructor.
    *
@@ -29,6 +32,7 @@ public abstract class NpmBasedCommandlet extends LocalToolCommandlet {
   public NpmBasedCommandlet(IdeContext context, String tool, Set<Tag> tags) {
 
     super(context, tool, tags);
+    this.installedVersion = new CachedValue<>(() -> runNpmGetInstalledPackageVersion(getNpmPackage()));
   }
 
   @Override
@@ -76,7 +80,7 @@ protected VersionIdentifier runNpmGetInstalledPackageVersion(String npmPackage)
   @Override
   public VersionIdentifier getInstalledVersion() {
 
-    return runNpmGetInstalledPackageVersion(getNpmPackage());
+    return this.installedVersion.get();
   }
 
   @Override
@@ -94,12 +98,14 @@ protected void performToolInstallation(ToolRepository toolRepository, VersionIde
 
     // runNpmUninstall(getNpmPackage()); // first uninstall a previously installed version
     runNpmInstall(getNpmPackage() + "@" + resolvedVersion);
+    this.installedVersion.invalidate();
   }
 
   @Override
   protected void performUninstall(Path toolPath) {
 
     runNpmUninstall(getNpmPackage());
+    this.installedVersion.invalidate();
   }
 
   /**

cli/src/test/java/com/devonfw/tools/ide/cache/CachedValueTest.java

@@ -0,0 +1,51 @@
+package com.devonfw.tools.ide.cache;
+
+import java.util.function.Supplier;
+
+import org.assertj.core.api.Assertions;
+import org.junit.jupiter.api.Test;
+
+/**
+ * Test of {@link CachedValue}.
+ */
+public class CachedValueTest extends Assertions {
+
+  /**
+   * Test that {@link CachedValue#get()} updates only if retention expired or invalidated.
+   */
+  @Test
+  public void testFlow() throws Exception {
+
+    // arrange
+    Sequence sequence = new Sequence();
+    CachedValue<Integer> cachedValue = new CachedValue<>(sequence, 1000);
+    sequence.increment();
+    // act
+    assertThat(cachedValue.get()).isEqualTo(1);
+    assertThat(cachedValue.get()).isEqualTo(1);
+    sequence.increment();
+    assertThat(cachedValue.get()).isEqualTo(1);
+    Thread.sleep(2000);
+    assertThat(cachedValue.get()).isEqualTo(2);
+    sequence.increment();
+    assertThat(cachedValue.get()).isEqualTo(2);
+    cachedValue.invalidate();
+    assertThat(cachedValue.get()).isEqualTo(3);
+  }
+
+  private static class Sequence implements Supplier<Integer> {
+
+    private int value;
+
+    @Override
+    public Integer get() {
+
+      return this.value;
+    }
+
+    public void increment() {
+      this.value++;
+    }
+  }
+
+}