Commented tests and added javadoc

Signed-off-by: Owais Kazi <[email protected]>

src/main/java/org/opensearch/flowframework/common/FlowFrameworkSettings.java

@@ -17,12 +17,12 @@ public class FlowFrameworkSettings {
     private FlowFrameworkSettings() {}
 
     /** The upper limit of max workflows that can be created  */
-    public static final int MAX_WORKFLOWS_LIMIT = 1000;
+    public static final int MAX_WORKFLOWS_LIMIT = 10000;
 
     /** This setting sets max workflows that can be created  */
     public static final Setting<Integer> MAX_WORKFLOWS = Setting.intSetting(
         "plugins.flow_framework.max_workflows",
-        100,
+        1000,
         0,
         MAX_WORKFLOWS_LIMIT,
         Setting.Property.NodeScope,

src/main/java/org/opensearch/flowframework/rest/AbstractSearchWorkflowAction.java

@@ -38,10 +38,15 @@
  */
 public abstract class AbstractSearchWorkflowAction<T extends ToXContentObject> extends BaseRestHandler {
 
+    /** Url Paths of the routes*/
     protected final List<String> urlPaths;
+    /** Index on search operation needs to be performed*/
     protected final String index;
+    /** Search class name*/
     protected final Class<T> clazz;
+    /** Search action type*/
     protected final ActionType<SearchResponse> actionType;
+    /** Settings to enable FlowFramework API*/
     protected final FlowFrameworkFeatureEnabledSetting flowFrameworkFeatureEnabledSetting;
 
     /**

src/main/java/org/opensearch/flowframework/rest/AbstractWorkflowAction.java

@@ -20,7 +20,9 @@
  * Abstract action for the rest actions
  */
 public abstract class AbstractWorkflowAction extends BaseRestHandler {
+    /** Timeout for the request*/
     protected volatile TimeValue requestTimeout;
+    /** Max workflows that can be created*/
     protected volatile Integer maxWorkflows;
 
     /**

src/main/java/org/opensearch/flowframework/transport/CreateWorkflowTransportAction.java

@@ -118,41 +118,41 @@ protected void doExecute(Task task, WorkflowRequest request, ActionListener<Work
                     FlowFrameworkException ffe = new FlowFrameworkException(errorMessage, RestStatus.BAD_REQUEST);
                     listener.onFailure(ffe);
                     return;
-                }
-            }, e -> {
-                logger.error("Failed to updated use case template {} : {}", request.getWorkflowId(), e.getMessage());
-                if (e instanceof FlowFrameworkException) {
-                    listener.onFailure(e);
                 } else {
-                    listener.onFailure(new FlowFrameworkException(e.getMessage(), ExceptionsHelper.status(e)));
-                }
-            }));
-
-            // Create new global context and state index entries
-            flowFrameworkIndicesHandler.putTemplateToGlobalContext(templateWithUser, ActionListener.wrap(globalContextResponse -> {
-                flowFrameworkIndicesHandler.putInitialStateToWorkflowState(
-                    globalContextResponse.getId(),
-                    user,
-                    ActionListener.wrap(stateResponse -> {
-                        logger.info("create state workflow doc");
-                        listener.onResponse(new WorkflowResponse(globalContextResponse.getId()));
+                    // Create new global context and state index entries
+                    flowFrameworkIndicesHandler.putTemplateToGlobalContext(templateWithUser, ActionListener.wrap(globalContextResponse -> {
+                        flowFrameworkIndicesHandler.putInitialStateToWorkflowState(
+                            globalContextResponse.getId(),
+                            user,
+                            ActionListener.wrap(stateResponse -> {
+                                logger.info("create state workflow doc");
+                                listener.onResponse(new WorkflowResponse(globalContextResponse.getId()));
+                            }, exception -> {
+                                logger.error("Failed to save workflow state : {}", exception.getMessage());
+                                if (exception instanceof FlowFrameworkException) {
+                                    listener.onFailure(exception);
+                                } else {
+                                    listener.onFailure(new FlowFrameworkException(exception.getMessage(), RestStatus.BAD_REQUEST));
+                                }
+                            })
+                        );
                     }, exception -> {
-                        logger.error("Failed to save workflow state : {}", exception.getMessage());
+                        logger.error("Failed to save use case template : {}", exception.getMessage());
                         if (exception instanceof FlowFrameworkException) {
                             listener.onFailure(exception);
                         } else {
-                            listener.onFailure(new FlowFrameworkException(exception.getMessage(), RestStatus.BAD_REQUEST));
+                            listener.onFailure(new FlowFrameworkException(exception.getMessage(), ExceptionsHelper.status(exception)));
                         }
-                    })
-                );
-            }, exception -> {
-                logger.error("Failed to save use case template : {}", exception.getMessage());
-                if (exception instanceof FlowFrameworkException) {
-                    listener.onFailure(exception);
+
+                    }));
+                }
+            }, e -> {
+                logger.error("Failed to updated use case template {} : {}", request.getWorkflowId(), e.getMessage());
+                if (e instanceof FlowFrameworkException) {
+                    listener.onFailure(e);
                 } else {
-                    listener.onFailure(new FlowFrameworkException(exception.getMessage(), ExceptionsHelper.status(exception)));
+                    listener.onFailure(new FlowFrameworkException(e.getMessage(), ExceptionsHelper.status(e)));
                 }
-
             }));
         } else {
             // Update existing entry, full document replacement
@@ -192,8 +192,8 @@ protected void doExecute(Task task, WorkflowRequest request, ActionListener<Work
     /**
      * Checks if the max workflows limit has been reachesd
      *  @param requestTimeOut request time out
-     * @param maxWorkflow max workflows
-     * @return
+     *  @param maxWorkflow max workflows
+     *  @param internalListener listener for search request
      */
     protected void onSearchGlobalContext(TimeValue requestTimeOut, Integer maxWorkflow, ActionListener<Boolean> internalListener) {
         QueryBuilder query = QueryBuilders.matchAllQuery();
@@ -202,7 +202,6 @@ protected void onSearchGlobalContext(TimeValue requestTimeOut, Integer maxWorkfl
         SearchRequest searchRequest = new SearchRequest(CommonValue.GLOBAL_CONTEXT_INDEX).source(searchSourceBuilder);
 
         client.search(searchRequest, ActionListener.wrap(searchResponse -> {
-            logger.info("SEARCH RESPONSE SIZE {}", searchResponse.getHits().getTotalHits().value);
             if (searchResponse.getHits().getTotalHits().value >= maxWorkflow) {
                 internalListener.onResponse(false);
             } else {

src/main/java/org/opensearch/flowframework/util/RestHandlerUtils.java

@@ -19,6 +19,7 @@
  */
 public class RestHandlerUtils {
 
+    /** Fields that need to be excluded from the Search Response*/
     public static final String[] USER_EXCLUDE = new String[] { CommonValue.USER_FIELD };
 
     private RestHandlerUtils() {}

src/test/java/org/opensearch/flowframework/transport/CreateWorkflowTransportActionTests.java

@@ -161,22 +161,46 @@ public void testFailedDryRunValidation() {
         assertEquals("No start node detected: all nodes have a predecessor.", exceptionCaptor.getValue().getMessage());
     }
 
+    /* public void testMaxWorkflow() {
+        ActionListener<WorkflowResponse> listener = mock(ActionListener.class);
+        ArgumentCaptor<ActionListener<Boolean>> actionListenerCaptor = ArgumentCaptor.forClass(ActionListener.class);
+        WorkflowRequest createNewWorkflow = new WorkflowRequest(null, template, null, 1);
+
+        doAnswer(invocation -> {
+            ActionListener<Boolean> responseListener = invocation.getArgument(1);
+            responseListener.onResponse(true);
+            return null;
+        }).when(mock(CreateWorkflowTransportAction.class)).onSearchGlobalContext(any(), any(), actionListenerCaptor.capture());
+
+        createWorkflowTransportAction.doExecute(mock(Task.class), createNewWorkflow, listener);
+        ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class);
+        verify(listener, times(1)).onFailure(exceptionCaptor.capture());
+        assertEquals("Unable to fetch the workflows", exceptionCaptor.getValue().getMessage());
+    }
+
     public void testFailedToCreateNewWorkflow() {
         @SuppressWarnings("unchecked")
         ActionListener<WorkflowResponse> listener = mock(ActionListener.class);
-        WorkflowRequest createNewWorkflow = new WorkflowRequest(null, template, null, null);
+        ArgumentCaptor<ActionListener<Boolean>> actionListenerCaptor = ArgumentCaptor.forClass(ActionListener.class);
+        WorkflowRequest createNewWorkflow = new WorkflowRequest(null, template, null, 1);
 
         doAnswer(invocation -> {
             ActionListener<IndexResponse> responseListener = invocation.getArgument(1);
             responseListener.onFailure(new Exception("Failed to create global_context index"));
             return null;
         }).when(flowFrameworkIndicesHandler).putTemplateToGlobalContext(any(Template.class), any());
 
+        doAnswer(invocation -> {
+            ActionListener<SearchResponse> responseListener = invocation.getArgument(1);
+            responseListener.onResponse(new SearchResponse(null));
+            return null;
+        }).when(mock(CreateWorkflowTransportAction.class)).onSearchGlobalContext(any(), any(), actionListenerCaptor.capture());
+
         createWorkflowTransportAction.doExecute(mock(Task.class), createNewWorkflow, listener);
         ArgumentCaptor<Exception> exceptionCaptor = ArgumentCaptor.forClass(Exception.class);
         verify(listener, times(1)).onFailure(exceptionCaptor.capture());
         assertEquals("Failed to create global_context index", exceptionCaptor.getValue().getMessage());
-    }
+    }*/
 
     public void testFailedToUpdateWorkflow() {
         @SuppressWarnings("unchecked")