#128 | Added environment validation to prevent cross environments config read

- Added environment configuration (int_env) to GoonjConfig and RwbConfig
- Changed default int_tasks from "all" to "none" in GoonjConfig and RWBConfig
- Added avni.int.env property to integrator-application.properties with documentation
- Implemented environment validation in IntegrationJobScheduler and AdhocTaskSchedulerService
- Enhanced startup logging to show active and skipped modules with detailed reasons

Author: himeshr

goonj/src/main/java/org/avni_integration_service/goonj/config/GoonjConfig.java

@@ -64,7 +64,7 @@ public boolean getAuthEnabled() {
     }
 
     public String getTasks() {
-        return getStringConfigValue("int_tasks", "all");
+        return getStringConfigValue("int_tasks", "none");
     }
 
     public boolean getDeleteAndRecreateDispatchReceipt() {
@@ -80,4 +80,13 @@ public boolean getBypassErrors() {
     public String getS3Url(){
         return getStringConfigValue("avni_s3_url_prefix","dummy");
     }
+
+    /**
+     * Gets the integration environment from DB config.
+     * This should match the environment where the integration service is running.
+     * @return environment string (e.g., "prod", "staging", "prerelease")
+     */
+    public String getEnvironment() {
+        return getStringConfigValue("int_env", null);
+    }
 }

integrator/src/main/java/org/avni_integration_service/scheduler/AdhocTaskSchedulerService.java

@@ -13,6 +13,7 @@
 import org.avni_integration_service.integration_data.repository.IntegrationSystemRepository;
 import org.avni_integration_service.integration_data.repository.config.IntegrationSystemConfigRepository;
 import org.springframework.beans.factory.annotation.Autowired;
+import org.springframework.beans.factory.annotation.Value;
 import org.springframework.scheduling.TaskScheduler;
 import org.springframework.scheduling.annotation.EnableScheduling;
 import org.springframework.stereotype.Service;
@@ -31,6 +32,9 @@ public class AdhocTaskSchedulerService {
     private final IntegrationSystemRepository integrationSystemRepository;
     private final AvniGoonjAdhocJob avniGoonjAdhocJob;
     private final GoonjAdhocTaskRepository goonjAdhocTaskRepository;
+    @Value("${avni.int.env:#{null}}")
+    private String currentEnvironment;
+
     @Autowired
     public AdhocTaskSchedulerService(TaskScheduler taskScheduler, IntegrationSystemConfigRepository integrationSystemConfigRepository, IntegrationSystemRepository integrationSystemRepository, AvniGoonjAdhocJob avniGoonjAdhocJob, GoonjAdhocTaskRepository goonjAdhocTaskRepository) {
         this.taskScheduler = taskScheduler;
@@ -40,15 +44,33 @@ public AdhocTaskSchedulerService(TaskScheduler taskScheduler, IntegrationSystemC
         this.goonjAdhocTaskRepository = goonjAdhocTaskRepository;
     }
 
-    public void schedule(GoonjAdhocTask goonjAdhocTask){
-        logger.info(String.format("scheduling start %s for %s",goonjAdhocTask.getIntegrationTask(),goonjAdhocTask.getUuid()));
+    public void schedule(GoonjAdhocTask goonjAdhocTask, IntegrationSystem integrationSystem) {
+        logger.info(String.format("scheduling start %s for %s (system: %s)", 
+                goonjAdhocTask.getIntegrationTask(), goonjAdhocTask.getUuid(), integrationSystem.getName()));
+        
+        // Validate that the provided integration system is of type Goonj
+        if (!IntegrationSystem.IntegrationSystemType.Goonj.equals(integrationSystem.getSystemType())) {
+            logger.error(String.format("Goonj adhoc task SKIPPED: Invalid system type. Expected: Goonj, Actual: %s", 
+                    integrationSystem.getSystemType()));
+            goonjAdhocTask.setGoonjAdhocTaskSatus(GoonjAdhocTaskSatus.ERROR);
+            goonjAdhocTaskRepository.save(goonjAdhocTask);
+            return;
+        }
+
+        GoonjConfig goonjConfig = getGoonjConfig(integrationSystem);
+
+        if (!isGoonjEnvironmentValid(goonjConfig)) {
+            goonjAdhocTask.setGoonjAdhocTaskSatus(GoonjAdhocTaskSatus.ERROR);
+            goonjAdhocTaskRepository.save(goonjAdhocTask);
+            return;
+        }
+
         IntegrationTask integrationTask = goonjAdhocTask.getIntegrationTask();
         Map<String, Object> taskConfig = goonjAdhocTask.getTaskConfig();
         Map<String, Object> filters = getFilters(goonjAdhocTask, taskConfig);
-        GoonjConfig goonjConfig = getGoonjConfig();
         taskScheduler.schedule(() -> {
             try {
-                logger.info(String.format("running start for  %s ", goonjAdhocTask));
+                logger.info(String.format("running start for  %s (system: %s)", goonjAdhocTask, integrationSystem.getName()));
                 avniGoonjAdhocJob.execute(goonjConfig, integrationTask, filters);
                 goonjAdhocTask.setGoonjAdhocTaskSatus(GoonjAdhocTaskSatus.COMPLETED);
             } catch (Exception e) {
@@ -60,11 +82,9 @@ public void schedule(GoonjAdhocTask goonjAdhocTask){
         }, goonjAdhocTask.getTriggerDateTime());
     }
 
-    private GoonjConfig getGoonjConfig() {
-        List<IntegrationSystem> goonjSystems = integrationSystemRepository.findAllBySystemType(IntegrationSystem.IntegrationSystemType.Goonj);
-        IntegrationSystem goonjSystem = goonjSystems.stream().findFirst().get();
-        IntegrationSystemConfigCollection integrationSystemConfigs = integrationSystemConfigRepository.getInstanceConfiguration(goonjSystem);
-        return new GoonjConfig(integrationSystemConfigs, goonjSystem);
+    private GoonjConfig getGoonjConfig(IntegrationSystem integrationSystem) {
+        IntegrationSystemConfigCollection integrationSystemConfigs = integrationSystemConfigRepository.getInstanceConfiguration(integrationSystem);
+        return new GoonjConfig(integrationSystemConfigs, integrationSystem);
     }
 
     private Map<String,Object> getFilters(GoonjAdhocTask goonjAdhocTask, Map<String, Object> taskConfig) {
@@ -76,4 +96,29 @@ private Map<String,Object> getFilters(GoonjAdhocTask goonjAdhocTask, Map<String,
         return filters;
     }
 
+    private boolean isGoonjEnvironmentValid(GoonjConfig goonjConfig) {
+        String dbEnvironment = goonjConfig.getEnvironment();
+
+        if (currentEnvironment == null || currentEnvironment.isBlank()) {
+            logger.warn("Goonj adhoc task SKIPPED: avni.int.env property not set. " +
+                    "Set this property to match the DB config int_env to enable Goonj integration.");
+            return false;
+        }
+
+        if (dbEnvironment == null || dbEnvironment.isBlank()) {
+            logger.warn("Goonj adhoc task SKIPPED: int_env not configured in DB. " +
+                    "Configure int_env in integration_system_config table to enable Goonj integration.");
+            return false;
+        }
+
+        if (!currentEnvironment.equals(dbEnvironment)) {
+            logger.error(String.format("Goonj adhoc task SKIPPED: Environment mismatch detected! " +
+                            "Current environment (from env): '%s', DB config environment: '%s'. " +
+                            "This likely indicates a non-prod environment using prod DB config.",
+                    currentEnvironment, dbEnvironment));
+            return false;
+        }
+
+        return true;
+    }
 }

integrator/src/main/java/org/avni_integration_service/scheduler/IntegrationJobScheduler.java

@@ -24,13 +24,18 @@
 import org.springframework.scheduling.support.CronTrigger;
 import org.springframework.stereotype.Component;
 
+import org.apache.log4j.Logger;
+
 import javax.annotation.PostConstruct;
+import java.util.ArrayList;
 import java.util.List;
 
 @Component
 @EnableScheduling
 @ConditionalOnProperty(value = "avni.int.auto.close", havingValue = "false")
 public class IntegrationJobScheduler {
+    private static final Logger logger = Logger.getLogger(IntegrationJobScheduler.class);
+
     private final AvniGoonjMainJob avniGoonjMainJob;
     private final AvniGoonjFullErrorJob avniGoonjFullErrorJob;
     private final AvniPowerMainJob avniPowerMainJob;
@@ -56,6 +61,8 @@ public class IntegrationJobScheduler {
     private String amritCron;
     @Value("${amrit.app.cron.full.error}")
     private String amritCronError;
+    @Value("${avni.int.env:#{null}}")
+    private String currentEnvironment;
 
     @Autowired
     public IntegrationJobScheduler(AvniGoonjMainJob avniGoonjMainJob, AvniGoonjFullErrorJob avniGoonjFullErrorJob,
@@ -80,55 +87,188 @@ public IntegrationJobScheduler(AvniGoonjMainJob avniGoonjMainJob, AvniGoonjFullE
 
     @PostConstruct
     public void scheduleAll() {
-        schedulePower();
-        scheduleLahi();
-        scheduleRwb();
-        scheduleAmrit();
-        scheduleGoonj();
+        logger.info("========== INTEGRATION SERVICE STARTUP - SCHEDULING JOBS ==========");
+        List<String> activeModules = new ArrayList<>();
+        List<String> skippedModules = new ArrayList<>();
+
+        if (schedulePower()) activeModules.add("Power"); else skippedModules.add("Power");
+        if (scheduleLahi()) activeModules.add("Lahi"); else skippedModules.add("Lahi");
+        if (scheduleRwb()) activeModules.add("RWB"); else skippedModules.add("RWB");
+        if (scheduleAmrit()) activeModules.add("Amrit"); else skippedModules.add("Amrit");
+        if (scheduleGoonj()) activeModules.add("Goonj"); else skippedModules.add("Goonj");
+
+        logStartupSummary(activeModules, skippedModules);
+    }
+
+    private void logStartupSummary(List<String> activeModules, List<String> skippedModules) {
+        logger.info("========== INTEGRATION SERVICE STARTUP SUMMARY ==========");
+        logger.info(String.format("Active modules (%d): %s", activeModules.size(),
+                activeModules.isEmpty() ? "NONE" : String.join(", ", activeModules)));
+        logger.info(String.format("Skipped modules (%d): %s", skippedModules.size(),
+                skippedModules.isEmpty() ? "NONE" : String.join(", ", skippedModules)));
+        logger.info("==========================================================");
     }
 
-    private void scheduleGoonj() {
+    private boolean scheduleGoonj() {
+        logger.info("--- Goonj Module ---");
         List<IntegrationSystem> goonjSystems = integrationSystemRepository.findAllBySystemType(IntegrationSystem.IntegrationSystemType.Goonj);
-        goonjSystems.forEach(goonjSystem -> {
+        if (goonjSystems.isEmpty()) {
+            logger.info("Goonj: No integration systems found in DB");
+            return false;
+        }
+
+        boolean anyScheduled = false;
+        for (IntegrationSystem goonjSystem : goonjSystems) {
             IntegrationSystemConfigCollection integrationSystemConfigs = integrationSystemConfigRepository.getInstanceConfiguration(goonjSystem);
             GoonjConfig goonjConfig = new GoonjConfig(integrationSystemConfigs, goonjSystem);
+
+            if (!validateEnvironment(goonjSystem.getName(), goonjConfig.getEnvironment())) {
+                continue;
+            }
+
             String mainScheduledJobCron = integrationSystemConfigs.getMainScheduledJobCron();
             String errorScheduledJobCron = integrationSystemConfigs.getErrorScheduledJobCron();
+            String tasks = goonjConfig.getTasks();
+
+            logger.info(String.format("Goonj [%s]: Scheduling jobs - mainCron: %s, errorCron: %s, tasks: %s",
+                    goonjSystem.getName(), mainScheduledJobCron, errorScheduledJobCron, tasks));
 
-            if (CronExpression.isValidExpression(mainScheduledJobCron))
+            if (CronExpression.isValidExpression(mainScheduledJobCron)) {
                 taskScheduler.schedule(() -> avniGoonjMainJob.execute(goonjConfig), new CronTrigger(mainScheduledJobCron));
+                logger.info(String.format("Goonj [%s]: Main job SCHEDULED with cron: %s", goonjSystem.getName(), mainScheduledJobCron));
+                anyScheduled = true;
+            } else {
+                logger.info(String.format("Goonj [%s]: Main job SKIPPED - invalid cron: %s", goonjSystem.getName(), mainScheduledJobCron));
+            }
 
-            if (CronExpression.isValidExpression(errorScheduledJobCron))
+            if (CronExpression.isValidExpression(errorScheduledJobCron)) {
                 taskScheduler.schedule(() -> avniGoonjFullErrorJob.execute(goonjConfig), new CronTrigger(errorScheduledJobCron));
-        });
+                logger.info(String.format("Goonj [%s]: Error job SCHEDULED with cron: %s", goonjSystem.getName(), errorScheduledJobCron));
+                anyScheduled = true;
+            } else {
+                logger.info(String.format("Goonj [%s]: Error job SKIPPED - invalid cron: %s", goonjSystem.getName(), errorScheduledJobCron));
+            }
+        }
+        return anyScheduled;
     }
 
-    private void scheduleAmrit() {
-        if (CronExpression.isValidExpression(amritCron)) taskScheduler.schedule(avniAmritMainJob::execute, new CronTrigger(amritCron));
-        if (CronExpression.isValidExpression(amritCronError)) taskScheduler.schedule(avniAmritFullErrorJob::execute, new CronTrigger(amritCronError));
+    private boolean validateEnvironment(String systemName, String dbEnv) {
+        if (currentEnvironment == null || currentEnvironment.isBlank()) {
+            logger.warn(String.format("%s integration SKIPPED: avni.int.env property not set. " +
+                    "Set this property to match the DB config int_env to enable integration.", systemName));
+            return false;
+        }
+
+        if (dbEnv == null || dbEnv.isBlank()) {
+            logger.warn(String.format("%s integration SKIPPED: int_env not configured in DB. " +
+                    "Configure int_env in integration_system_config table to enable integration.", systemName));
+            return false;
+        }
+
+        if (!currentEnvironment.equals(dbEnv)) {
+            logger.error(String.format("%s integration SKIPPED: Environment mismatch detected! " +
+                            "Current environment (from env): '%s', DB config environment: '%s'. " +
+                            "This likely indicates a non-prod environment using prod DB config. " +
+                            "Either update the avni.int.env property or clean up the DB integration config.",
+                    systemName, currentEnvironment, dbEnv));
+            return false;
+        }
+
+        logger.info(String.format("%s environment validation passed. Environment: %s", systemName, currentEnvironment));
+        return true;
     }
 
-    private void scheduleLahi() {
-        if (CronExpression.isValidExpression(lahiCron)) taskScheduler.schedule(avniLahiMainJob::execute, new CronTrigger(lahiCron));
-        if (CronExpression.isValidExpression(lahiCronError)) taskScheduler.schedule(avniLahiFullErrorJob::execute, new CronTrigger(lahiCronError));
+    private boolean isRwbEnvironmentValid(RwbConfig rwbConfig) {
+        return validateEnvironment(rwbConfig.getIntegrationSystem().getName(), rwbConfig.getEnvironment());
     }
 
-    private void schedulePower() {
-        if (CronExpression.isValidExpression(powerCron)) taskScheduler.schedule(avniPowerMainJob::execute, new CronTrigger(powerCron));
-        if (CronExpression.isValidExpression(powerCronError)) taskScheduler.schedule(avniPowerFullErrorJob::execute, new CronTrigger(powerCronError));
+    private boolean scheduleAmrit() {
+        logger.info("--- Amrit Module ---");
+        boolean scheduled = false;
+        if (CronExpression.isValidExpression(amritCron)) {
+            taskScheduler.schedule(avniAmritMainJob::execute, new CronTrigger(amritCron));
+            logger.info(String.format("Amrit: Main job SCHEDULED with cron: %s", amritCron));
+            scheduled = true;
+        } else {
+            logger.info(String.format("Amrit: Main job SKIPPED - invalid cron: %s", amritCron));
+        }
+        if (CronExpression.isValidExpression(amritCronError)) {
+            taskScheduler.schedule(avniAmritFullErrorJob::execute, new CronTrigger(amritCronError));
+            logger.info(String.format("Amrit: Error job SCHEDULED with cron: %s", amritCronError));
+            scheduled = true;
+        } else {
+            logger.info(String.format("Amrit: Error job SKIPPED - invalid cron: %s", amritCronError));
+        }
+        return scheduled;
     }
 
+    private boolean scheduleLahi() {
+        logger.info("--- Lahi Module ---");
+        boolean scheduled = false;
+        if (CronExpression.isValidExpression(lahiCron)) {
+            taskScheduler.schedule(avniLahiMainJob::execute, new CronTrigger(lahiCron));
+            logger.info(String.format("Lahi: Main job SCHEDULED with cron: %s", lahiCron));
+            scheduled = true;
+        } else {
+            logger.info(String.format("Lahi: Main job SKIPPED - invalid cron: %s", lahiCron));
+        }
+        if (CronExpression.isValidExpression(lahiCronError)) {
+            taskScheduler.schedule(avniLahiFullErrorJob::execute, new CronTrigger(lahiCronError));
+            logger.info(String.format("Lahi: Error job SCHEDULED with cron: %s", lahiCronError));
+            scheduled = true;
+        } else {
+            logger.info(String.format("Lahi: Error job SKIPPED - invalid cron: %s", lahiCronError));
+        }
+        return scheduled;
+    }
 
-    private void scheduleRwb() {
+    private boolean schedulePower() {
+        logger.info("--- Power Module ---");
+        boolean scheduled = false;
+        if (CronExpression.isValidExpression(powerCron)) {
+            taskScheduler.schedule(avniPowerMainJob::execute, new CronTrigger(powerCron));
+            logger.info(String.format("Power: Main job SCHEDULED with cron: %s", powerCron));
+            scheduled = true;
+        } else {
+            logger.info(String.format("Power: Main job SKIPPED - invalid cron: %s", powerCron));
+        }
+        if (CronExpression.isValidExpression(powerCronError)) {
+            taskScheduler.schedule(avniPowerFullErrorJob::execute, new CronTrigger(powerCronError));
+            logger.info(String.format("Power: Error job SCHEDULED with cron: %s", powerCronError));
+            scheduled = true;
+        } else {
+            logger.info(String.format("Power: Error job SKIPPED - invalid cron: %s", powerCronError));
+        }
+        return scheduled;
+    }
+
+    private boolean scheduleRwb() {
+        logger.info("--- RWB Module ---");
         List<IntegrationSystem> rwbSystems = integrationSystemRepository.findAllBySystemType(IntegrationSystem.IntegrationSystemType.rwb);
-        rwbSystems.forEach(rwbSystem -> {
+        if (rwbSystems.isEmpty()) {
+            logger.info("RWB: No integration systems found in DB");
+            return false;
+        }
+
+        boolean anyScheduled = false;
+        for (IntegrationSystem rwbSystem : rwbSystems) {
             IntegrationSystemConfigCollection integrationSystemConfigs = integrationSystemConfigRepository.getInstanceConfiguration(rwbSystem);
             RwbConfig rwbConfig = new RwbConfig(integrationSystemConfigs, rwbSystem);
+
+            if (!isRwbEnvironmentValid(rwbConfig)) {
+                continue;
+            }
+
             String rwbCron = integrationSystemConfigs.getMainScheduledJobCron();
 
             if (CronExpression.isValidExpression(rwbCron)) {
                 taskScheduler.schedule(() -> avniRwbMainJob.execute(rwbConfig), new CronTrigger(rwbCron));
+                logger.info(String.format("RWB [%s]: Main job SCHEDULED with cron: %s", rwbSystem.getName(), rwbCron));
+                anyScheduled = true;
+            } else {
+                logger.info(String.format("RWB [%s]: Main job SKIPPED - invalid cron: %s", rwbSystem.getName(), rwbCron));
             }
-        });
+        }
+        return anyScheduled;
     }
 }