1. import java.util.HashMap;
  2. import java.util.Map;
  3. import java.util.concurrent.ConcurrentHashMap;
  4. import java.util.concurrent.Executors;
  5. import java.util.concurrent.ScheduledExecutorService;
  6. import java.util.concurrent.TimeUnit;
  8. public class EnvVariableThrottler {
  10. private final Map<String, String> envVariables; // Store environment variables and their validation status.
  11. private final Map<String, Long> lastAccessTime; // Last time an environment variable was accessed.
  12. private final Map<String, String> defaultValues; // Default values for environment variables.
  13. private final long throttleIntervalMillis; // Time interval for throttling (e.g., 1000 milliseconds = 1 second).
  14. private final ScheduledExecutorService scheduler; // Executor service for scheduling throttling tasks.
  16. public EnvVariableThrottler(long throttleIntervalMillis, Map<String, String> defaultValues) {
  17. this.envVariables = new ConcurrentHashMap<>();
  18. this.lastAccessTime = new ConcurrentHashMap<>();
  19. this.defaultValues = defaultValues;
  20. this.throttleIntervalMillis = throttleIntervalMillis;
  21. this.scheduler = Executors.newSingleThreadScheduledExecutor();
  22. }
  24. public String getOrDefault(String envVarName) {
  25. // Get the environment variable value.
  26. String envValue = System.getenv(envVarName);
  28. // If the environment variable is not set or is null, use the default value.
  29. if (envValue == null || envValue.isEmpty()) {
  30. return defaultValues.getOrDefault(envVarName, ""); // Return default value if not set.
  31. }
  33. // Check if the environment variable has been accessed within the throttle interval.
  34. long currentTime = System.currentTimeMillis();
  35. if (!lastAccessTime.containsKey(envVarName) || (currentTime - lastAccessTime.get(envVarName)) > throttleIntervalMillis) {
  36. // Validate the environment variable (e.g., check if it's a valid format).
  37. validateEnvVar(envVarName, envValue);
  38. lastAccessTime.put(envVarName, currentTime);
  39. }
  40. return envValue;
  41. }
  43. private void validateEnvVar(String envVarName, String envValue) {
  44. // Perform validation checks on the environment variable.
  45. // Example: Check if the value is a valid number.
  46. if (envVarName.equals("PORT")) {
  47. try {
  48. Integer.parseInt(envValue);
  49. } catch (NumberFormatException e) {
  50. System.err.println("Invalid PORT value. Using default: " + defaultValues.getOrDefault(envVarName, ""));
  51. envVariables.put(envVarName, defaultValues.getOrDefault(envVarName, ""));
  52. }
  53. }
  54. // Add more validation checks as needed.
  55. else {
  56. envVariables.put(envVarName, envValue); // Store env variable value after validation
  57. }
  58. }
  61. public void start() {
  62. scheduler.scheduleAtFixedRate(() -> {
  63. // Periodically check and reset the access time for all environment variables.
  64. for (String envVar : envVariables.keySet()) {
  65. lastAccessTime.remove(envVar);
  66. }
  67. }, throttleIntervalMillis, throttleIntervalMillis, TimeUnit.MILLISECONDS);
  68. }
  70. public void stop() {
  71. scheduler.shutdown();
  72. try {
  73. scheduler.awaitTermination(5, TimeUnit.SECONDS);
  74. } catch (InterruptedException e) {
  75. Thread.currentThread().interrupt();
  76. }
  77. }
  79. public static void main(String[] args) throws InterruptedException {
  80. // Example usage
  81. Map<String, String> defaults = new HashMap<>();
  82. defaults.put("PORT", "8080");
  83. defaults.put("DEBUG", "false");
  84. EnvVariableThrottler throttler = new EnvVariableThrottler(1000, defaults); // Throttle every 1 second.
  86. throttler.start();
  88. System.out.println("PORT: " + throttler.getOrDefault("PORT"));
  89. System.out.println("DEBUG: " + throttler.getOrDefault("DEBUG"));
  90. System.out.println("NON_EXISTENT_VAR: " + throttler.getOrDefault("NON_EXISTENT_VAR"));
  92. Thread.sleep(2000);
  94. System.out.println("PORT: " + throttler.getOrDefault("PORT")); // Should use the

Add your comment