You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@airavata.apache.org by di...@apache.org on 2018/06/27 21:14:35 UTC

[airavata] branch staging updated: Improving batch queue validator logic

This is an automated email from the ASF dual-hosted git repository.

dimuthuupe pushed a commit to branch staging
in repository https://gitbox.apache.org/repos/asf/airavata.git


The following commit(s) were added to refs/heads/staging by this push:
     new a645e51  Improving batch queue validator logic
a645e51 is described below

commit a645e5120bbdc4c1fef8466b362cdf9e47a4d549
Author: dimuthu <di...@gmail.com>
AuthorDate: Wed Jun 27 17:14:24 2018 -0400

    Improving batch queue validator logic
---
 .../core/validator/impl/BatchQueueValidator.java   | 178 +++++++++++----------
 1 file changed, 96 insertions(+), 82 deletions(-)

diff --git a/modules/orchestrator/orchestrator-core/src/main/java/org/apache/airavata/orchestrator/core/validator/impl/BatchQueueValidator.java b/modules/orchestrator/orchestrator-core/src/main/java/org/apache/airavata/orchestrator/core/validator/impl/BatchQueueValidator.java
index c1768b1..50651c9 100644
--- a/modules/orchestrator/orchestrator-core/src/main/java/org/apache/airavata/orchestrator/core/validator/impl/BatchQueueValidator.java
+++ b/modules/orchestrator/orchestrator-core/src/main/java/org/apache/airavata/orchestrator/core/validator/impl/BatchQueueValidator.java
@@ -81,111 +81,125 @@ public class BatchQueueValidator implements JobMetadataValidator {
                 computeResource = registryClient.getComputeResource(experiment.getUserConfigurationData().getComputationalResourceScheduling().getResourceHostId());
             } else {
                 computeResource = registryClient.getComputeResource(processModel.getProcessResourceSchedule().getResourceHostId());
-
             }
+
             List<BatchQueue> batchQueues = computeResource.getBatchQueues();
 
+            if (computationalResourceScheduling == null) {
+                ValidatorResult queueNameResult = new ValidatorResult();
+                queueNameResult.setResult(false);
+                queueNameResult.setErrorDetails("No compute resource scheduling for experiment " + experiment.getExperimentId());
+                validatorResultList.add(queueNameResult);
+                return validatorResultList;
+            }
+
+            if (computationalResourceScheduling.getQueueName() == null) {
+                ValidatorResult queueNameResult = new ValidatorResult();
+                queueNameResult.setResult(false);
+                queueNameResult.setErrorDetails("No queue name for experiment " + experiment.getExperimentId());
+                validatorResultList.add(queueNameResult);
+                return validatorResultList;
+            }
+
             if (batchQueues != null && !batchQueues.isEmpty()) {
-                if (computationalResourceScheduling != null) {
-                    String experimentQueueName = computationalResourceScheduling.getQueueName().trim();
-                    int experimentWallTimeLimit = computationalResourceScheduling.getWallTimeLimit();
-                    int experimentNodeCount = computationalResourceScheduling.getNodeCount();
-                    int experimentCPUCount = computationalResourceScheduling.getTotalCPUCount();
-                    ValidatorResult queueNameResult = new ValidatorResult();
+                String experimentQueueName = computationalResourceScheduling.getQueueName().trim();
+                int experimentWallTimeLimit = computationalResourceScheduling.getWallTimeLimit();
+                int experimentNodeCount = computationalResourceScheduling.getNodeCount();
+                int experimentCPUCount = computationalResourceScheduling.getTotalCPUCount();
+                ValidatorResult queueNameResult = new ValidatorResult();
 
-                    //Set the validation to false. Once all the queue's are looped, if nothing matches, then this gets passed.
-                    queueNameResult.setResult(false);
-                    queueNameResult.setErrorDetails("The specified queue " + experimentQueueName +
-                            " does not exist. If you believe this is an error, contact the administrator to verify App-Catalog Configurations");
-                    for (BatchQueue queue : batchQueues) {
-                        String resourceQueueName = queue.getQueueName();
-                        int maxQueueRunTime = queue.getMaxRunTime();
-                        int maxNodeCount = queue.getMaxNodes();
-                        int maxcpuCount = queue.getMaxProcessors();
-                        if (resourceQueueName != null && resourceQueueName.equals(experimentQueueName)) {
-                            queueNameResult.setResult(true);
-                            queueNameResult.setErrorDetails("");
+                //Set the validation to false. Once all the queue's are looped, if nothing matches, then this gets passed.
+                queueNameResult.setResult(false);
+                queueNameResult.setErrorDetails("The specified queue " + experimentQueueName +
+                        " does not exist. If you believe this is an error, contact the administrator to verify App-Catalog Configurations");
+                for (BatchQueue queue : batchQueues) {
+                    String resourceQueueName = queue.getQueueName();
+                    int maxQueueRunTime = queue.getMaxRunTime();
+                    int maxNodeCount = queue.getMaxNodes();
+                    int maxcpuCount = queue.getMaxProcessors();
+                    if (resourceQueueName != null && resourceQueueName.equals(experimentQueueName)) {
+                        queueNameResult.setResult(true);
+                        queueNameResult.setErrorDetails("");
 
-                            //Validate if the specified wall time is within allowable limit
-                            ValidatorResult wallTimeResult = new ValidatorResult();
-                            if (experimentWallTimeLimit == 0) {
-                                wallTimeResult.setResult(false);
-                                wallTimeResult.setErrorDetails("Walltime cannot be zero for queue " + resourceQueueName);
+                        //Validate if the specified wall time is within allowable limit
+                        ValidatorResult wallTimeResult = new ValidatorResult();
+                        if (experimentWallTimeLimit == 0) {
+                            wallTimeResult.setResult(false);
+                            wallTimeResult.setErrorDetails("Walltime cannot be zero for queue " + resourceQueueName);
+                        } else {
+                            if (maxQueueRunTime == 0) {
+                                wallTimeResult.setResult(true);
+                                wallTimeResult.setErrorDetails("Maximum wall time is not configured for the queue," +
+                                        "Validation is being skipped");
+                                logger.info("Maximum wall time is not configured for the queue" +
+                                        "Validation is being skipped");
                             } else {
-                                if (maxQueueRunTime == 0) {
-                                    wallTimeResult.setResult(true);
-                                    wallTimeResult.setErrorDetails("Maximum wall time is not configured for the queue," +
-                                            "Validation is being skipped");
-                                    logger.info("Maximum wall time is not configured for the queue" +
-                                            "Validation is being skipped");
+                                if (maxQueueRunTime < experimentWallTimeLimit) {
+                                    wallTimeResult.setResult(false);
+                                    wallTimeResult.setErrorDetails("Job Execution walltime " + experimentWallTimeLimit +
+                                            "exceeds the allowable walltime" + maxQueueRunTime +
+                                            "for queue " + resourceQueueName);
                                 } else {
-                                    if (maxQueueRunTime < experimentWallTimeLimit) {
-                                        wallTimeResult.setResult(false);
-                                        wallTimeResult.setErrorDetails("Job Execution walltime " + experimentWallTimeLimit +
-                                                "exceeds the allowable walltime" + maxQueueRunTime +
-                                                "for queue " + resourceQueueName);
-                                    } else {
-                                        wallTimeResult.setResult(true);
-                                        wallTimeResult.setErrorDetails("");
-                                    }
+                                    wallTimeResult.setResult(true);
+                                    wallTimeResult.setErrorDetails("");
                                 }
                             }
-                            //validate max node count
-                            ValidatorResult nodeCountResult = new ValidatorResult();
-                            if (maxNodeCount == 0) {
-                                nodeCountResult.setResult(true);
-                                nodeCountResult.setErrorDetails("Max node count is not configured for the queue," +
-                                        "Validation is being skipped");
-                                logger.info("Max node count is not configured for the queue" +
-                                        "Validation is being skipped");
+                        }
+                        //validate max node count
+                        ValidatorResult nodeCountResult = new ValidatorResult();
+                        if (maxNodeCount == 0) {
+                            nodeCountResult.setResult(true);
+                            nodeCountResult.setErrorDetails("Max node count is not configured for the queue," +
+                                    "Validation is being skipped");
+                            logger.info("Max node count is not configured for the queue" +
+                                    "Validation is being skipped");
+                        } else {
+                            if (experimentNodeCount == 0) {
+                                nodeCountResult.setResult(false);
+                                nodeCountResult.setErrorDetails("Job Execution node count cannot be zero for queue " + resourceQueueName);
                             } else {
-                                if (experimentNodeCount == 0) {
+                                if (maxNodeCount < experimentNodeCount) {
                                     nodeCountResult.setResult(false);
-                                    nodeCountResult.setErrorDetails("Job Execution node count cannot be zero for queue " + resourceQueueName);
+                                    nodeCountResult.setErrorDetails("Job Execution node count " + experimentNodeCount +
+                                            "exceeds the allowable node count" + maxNodeCount +
+                                            "for queue " + resourceQueueName);
                                 } else {
-                                    if (maxNodeCount < experimentNodeCount) {
-                                        nodeCountResult.setResult(false);
-                                        nodeCountResult.setErrorDetails("Job Execution node count " + experimentNodeCount +
-                                                "exceeds the allowable node count" + maxNodeCount +
-                                                "for queue " + resourceQueueName);
-                                    } else {
-                                        nodeCountResult.setResult(true);
-                                        nodeCountResult.setErrorDetails("");
-                                    }
+                                    nodeCountResult.setResult(true);
+                                    nodeCountResult.setErrorDetails("");
                                 }
                             }
-                            // validate cpu count
-                            ValidatorResult cpuCountResult = new ValidatorResult();
-                            if (maxcpuCount == 0) {
-                                cpuCountResult.setResult(true);
-                                cpuCountResult.setErrorDetails("Max cpu count is not configured for the queue," +
-                                        "Validation is being skipped");
-                                logger.info("Max cpu count is not configured for the queue" +
-                                        "Validation is being skipped");
+                        }
+                        // validate cpu count
+                        ValidatorResult cpuCountResult = new ValidatorResult();
+                        if (maxcpuCount == 0) {
+                            cpuCountResult.setResult(true);
+                            cpuCountResult.setErrorDetails("Max cpu count is not configured for the queue," +
+                                    "Validation is being skipped");
+                            logger.info("Max cpu count is not configured for the queue" +
+                                    "Validation is being skipped");
+                        } else {
+                            if (experimentCPUCount == 0) {
+                                cpuCountResult.setResult(false);
+                                cpuCountResult.setErrorDetails("Job Execution cpu count cannot be zero for queue " + resourceQueueName);
                             } else {
-                                if (experimentCPUCount == 0) {
+                                if (maxcpuCount < experimentCPUCount) {
                                     cpuCountResult.setResult(false);
-                                    cpuCountResult.setErrorDetails("Job Execution cpu count cannot be zero for queue " + resourceQueueName);
+                                    cpuCountResult.setErrorDetails("Job Execution cpu count " + experimentCPUCount +
+                                            "exceeds the allowable cpu count" + maxcpuCount +
+                                            "for queue " + resourceQueueName);
                                 } else {
-                                    if (maxcpuCount < experimentCPUCount) {
-                                        cpuCountResult.setResult(false);
-                                        cpuCountResult.setErrorDetails("Job Execution cpu count " + experimentCPUCount +
-                                                "exceeds the allowable cpu count" + maxcpuCount +
-                                                "for queue " + resourceQueueName);
-                                    } else {
-                                        cpuCountResult.setResult(true);
-                                        cpuCountResult.setErrorDetails("");
-                                    }
+                                    cpuCountResult.setResult(true);
+                                    cpuCountResult.setErrorDetails("");
                                 }
                             }
-                            validatorResultList.add(wallTimeResult);
-                            validatorResultList.add(nodeCountResult);
-                            validatorResultList.add(cpuCountResult);
                         }
+                        validatorResultList.add(wallTimeResult);
+                        validatorResultList.add(nodeCountResult);
+                        validatorResultList.add(cpuCountResult);
                     }
-                    validatorResultList.add(queueNameResult);
-
                 }
+                validatorResultList.add(queueNameResult);
+
             } else {
                 // for some compute resources, you dnt need to specify queue names
                 ValidatorResult result = new ValidatorResult();