wip

Author: Haarolean

api/src/main/java/io/kafbat/ui/config/auth/RoleBasedAccessControlProperties.java

@@ -10,6 +10,8 @@
 public class RoleBasedAccessControlProperties {
 
   private final List<Role> roles = new ArrayList<>();
+//  private String haha;
+
 
   @PostConstruct
   public void init() {

api/src/main/java/io/kafbat/ui/service/app/ConfigReloadService.java

@@ -1,22 +1,35 @@
 package io.kafbat.ui.service.app;
 
+import io.kafbat.ui.config.auth.RoleBasedAccessControlProperties;
+import io.kafbat.ui.service.rbac.AccessControlService;
 import io.kafbat.ui.util.MultiFileWatcher;
 import jakarta.annotation.PostConstruct;
 import jakarta.annotation.PreDestroy;
 import java.io.IOException;
+import java.io.InputStream;
+import java.nio.file.Files;
 import java.nio.file.Paths;
 import java.util.LinkedHashSet;
 import java.util.Objects;
+import java.util.Properties;
 import java.util.stream.Collectors;
 import java.util.stream.Stream;
 import java.util.stream.StreamSupport;
+import lombok.Cleanup;
 import lombok.RequiredArgsConstructor;
 import lombok.extern.slf4j.Slf4j;
+import org.springframework.beans.factory.ObjectProvider;
+import org.springframework.beans.factory.support.DefaultSingletonBeanRegistry;
+import org.springframework.boot.context.properties.bind.Binder;
 import org.springframework.boot.env.OriginTrackedMapPropertySource;
 import org.springframework.boot.origin.Origin;
 import org.springframework.boot.origin.OriginTrackedValue;
 import org.springframework.boot.origin.TextResourceOrigin;
+import org.springframework.context.ApplicationContext;
 import org.springframework.core.env.ConfigurableEnvironment;
+import org.springframework.core.env.MutablePropertySources;
+import org.springframework.core.env.PropertiesPropertySource;
+import org.springframework.core.env.PropertySource;
 import org.springframework.core.io.Resource;
 import org.springframework.stereotype.Service;
 
@@ -29,10 +42,14 @@ public class ConfigReloadService {
   private static final String THREAD_NAME = "config-watcher-thread";
 
   private final ConfigurableEnvironment environment;
+  private final ApplicationContext appContext;
 
   private Thread watcherThread;
   private MultiFileWatcher multiFileWatcher;
 
+  private final ObjectProvider<AccessControlService> accessControlService;
+  private final ObjectProvider<RoleBasedAccessControlProperties> roleBasedAccessControlProperties;
+
   @PostConstruct
   public void init() {
     var propertySourcePaths = StreamSupport.stream(environment.getPropertySources().spliterator(), false)
@@ -69,7 +86,28 @@ public void init() {
     log.debug("Auto reload is enabled, will watch for config changes");
 
     try {
-      this.multiFileWatcher = new MultiFileWatcher(propertySourcePaths, this::reload);
+      this.multiFileWatcher = new MultiFileWatcher(propertySourcePaths, path -> {
+        System.out.println(path);
+        var propertySources = environment.getPropertySources();
+
+
+
+        Properties properties = new Properties();
+        try {
+          @Cleanup InputStream inputStream = Files.newInputStream(Paths.get("/tmp/kek.yaml"));
+          properties.load(inputStream);
+        } catch (IOException e) {
+          throw new RuntimeException(e);
+        }
+
+        PropertySource<?> origin =
+            propertySources.stream().filter(ps -> ps.getName().contains("tmp/kek")).findFirst().get();
+        environment.getPropertySources().replace(origin.getName(), new PropertiesPropertySource(origin.getName(), properties));
+
+        System.out.println();
+        var kekw = appContext.getBean(AccessControlService.class);
+        return null;
+      });
       this.watcherThread = new Thread(multiFileWatcher::watchLoop, THREAD_NAME);
       this.watcherThread.start();
     } catch (IOException e) {
@@ -91,6 +129,19 @@ public void shutdown() {
   }
 
   private void reload() {
+    var registry = (DefaultSingletonBeanRegistry) appContext.getAutowireCapableBeanFactory();
+
+    registry.destroySingleton("AccessControlService");
+
+    Binder.get(environment)
+        .bind("rbac", RoleBasedAccessControlProperties.class)
+        .orElseThrow(() -> new IllegalStateException("no rbac config"));
+
+    var newProps = appContext.getBean(AccessControlService.class);
+    newProps.init();
+//    accessControlService.init();
+    System.out.println();
+
 
   }
 

api/src/main/java/io/kafbat/ui/util/MultiFileWatcher.java

@@ -11,6 +11,7 @@
 import java.nio.file.FileSystems;
 import java.nio.file.Files;
 import java.nio.file.Path;
+import java.nio.file.Paths;
 import java.nio.file.WatchKey;
 import java.nio.file.WatchService;
 import java.time.Duration;
@@ -19,8 +20,11 @@
 import java.util.Map;
 import java.util.Optional;
 import java.util.Set;
+import java.util.concurrent.Callable;
 import java.util.concurrent.ConcurrentHashMap;
+import java.util.function.Function;
 import lombok.extern.slf4j.Slf4j;
+import org.jetbrains.annotations.NotNull;
 import org.springframework.util.Assert;
 
 @Slf4j
@@ -31,11 +35,11 @@ public final class MultiFileWatcher implements AutoCloseable {
   private final WatchService watchService = FileSystems.getDefault().newWatchService();
   private final Set<Path> watchedFiles = ConcurrentHashMap.newKeySet();
   private final Map<WatchKey, Path> watchDirsByKey = new HashMap<>();
-  private final Runnable reloader;
+  private final Function<Path, Void> reloader;
 
   private long lastTriggerAt = 0;
 
-  public MultiFileWatcher(Collection<Path> filesToWatch, Runnable reloader) throws IOException {
+  public MultiFileWatcher(Collection<Path> filesToWatch, Function<Path, Void> reloader) throws IOException {
     Assert.notNull(reloader, "reloader must not be null");
     this.reloader = reloader;
 
@@ -62,28 +66,28 @@ public MultiFileWatcher(Collection<Path> filesToWatch, Runnable reloader) throws
     log.trace("Watching files: {}", watchedFiles.stream().map(Path::toString).toList());
 
     watchedFiles.stream()
-        .map(p -> Optional.ofNullable(p.getParent()).orElse(Path.of(".")))
+//        .map(getParentPath())
         .distinct()
-        .forEach(dir -> {
+        .forEach(file -> {
           try {
-            var key = dir.register(watchService,
+            var key = getParentPath().apply(file).register(watchService,
                 ENTRY_MODIFY,
                 ENTRY_CREATE, ENTRY_DELETE // watch these for atomic replacements
             );
-            watchDirsByKey.put(key, dir);
+            watchDirsByKey.put(key, file);
           } catch (IOException e) {
             throw new UncheckedIOException(e);
           }
         });
 
-    log.trace("Watching directories: {}", watchDirsByKey.values().stream().map(Path::toString).toList());
+    log.trace("Watching directories: {}", watchDirsByKey.values().stream().map(a -> getParentPath().apply(a)).map(Path::toString).toList());
   }
 
   public void watchLoop() {
     while (true) {
       try {
         var key = watchService.take();
-        var dir = watchDirsByKey.get(key);
+        var dir = getParentPath().apply(watchDirsByKey.get(key));
         if (dir == null) {
           continue;
         }
@@ -95,7 +99,8 @@ public void watchLoop() {
             .anyMatch(this::matchesTarget);
 
         if (hit && shouldTrigger()) {
-          reloader.run();
+          var filePath = watchDirsByKey.get(key); // TODO
+          reloader.apply(filePath);
         }
 
         if (!key.reset()) {
@@ -144,5 +149,10 @@ private boolean shouldTrigger() {
   public void close() throws IOException {
     watchService.close();
   }
+
+  @NotNull
+  private static Function<Path, Path> getParentPath() {
+    return p -> Optional.ofNullable(p.getParent()).orElse(Path.of("."));
+  }
 }