Implement patch API for datasources

core/src/main/java/org/opensearch/sql/datasource/DataSourceService.java

@@ -5,6 +5,7 @@
 
 package org.opensearch.sql.datasource;
 
+import java.util.Map;
 import java.util.Set;
 import org.opensearch.sql.datasource.model.DataSource;
 import org.opensearch.sql.datasource.model.DataSourceMetadata;
@@ -56,12 +57,19 @@ public interface DataSourceService {
   void createDataSource(DataSourceMetadata metadata);
 
   /**
-   * Updates {@link DataSource} corresponding to dataSourceMetadata.
+   * Updates {@link DataSource} corresponding to dataSourceMetadata (all fields needed).
    *
    * @param dataSourceMetadata {@link DataSourceMetadata}.
    */
   void updateDataSource(DataSourceMetadata dataSourceMetadata);
 
+  /**
+   * Patches {@link DataSource} corresponding to the given name (only fields to be changed needed).
+   *
+   * @param dataSourceData
+   */
+  void patchDataSource(Map<String, Object> dataSourceData);
+
   /**
    * Deletes {@link DataSource} corresponding to the DataSource name.
    *

datasources/src/main/java/org/opensearch/sql/datasources/model/transport/PatchDataSourceActionRequest.java

@@ -0,0 +1,44 @@
+/*
+ *
+ *  * Copyright OpenSearch Contributors
+ *  * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+package org.opensearch.sql.datasources.model.transport;
+
+import static org.opensearch.sql.analysis.DataSourceSchemaIdentifierNameResolver.DEFAULT_DATASOURCE_NAME;
+import static org.opensearch.sql.datasources.utils.XContentParserUtils.NAME_FIELD;
+
+import java.io.IOException;
+import java.util.Map;
+import lombok.Getter;
+import org.opensearch.action.ActionRequest;
+import org.opensearch.action.ActionRequestValidationException;
+import org.opensearch.core.common.io.stream.StreamInput;
+
+public class PatchDataSourceActionRequest extends ActionRequest {
+
+  @Getter private Map<String, Object> dataSourceData;
+
+  /** Constructor of UpdateDataSourceActionRequest from StreamInput. */
+  public PatchDataSourceActionRequest(StreamInput in) throws IOException {
+    super(in);
+  }
+
+  public PatchDataSourceActionRequest(Map<String, Object> dataSourceData) {
+    this.dataSourceData = dataSourceData;
+  }
+
+  @Override
+  public ActionRequestValidationException validate() {
+    if (this.dataSourceData.get(NAME_FIELD).equals(DEFAULT_DATASOURCE_NAME)) {
+      ActionRequestValidationException exception = new ActionRequestValidationException();
+      exception.addValidationError(
+          "Not allowed to update datasource with name : " + DEFAULT_DATASOURCE_NAME);
+      return exception;
+    } else {
+      return null;
+    }
+  }
+}

datasources/src/main/java/org/opensearch/sql/datasources/model/transport/PatchDataSourceActionResponse.java

@@ -0,0 +1,31 @@
+/*
+ *
+ *  * Copyright OpenSearch Contributors
+ *  * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+package org.opensearch.sql.datasources.model.transport;
+
+import java.io.IOException;
+import lombok.Getter;
+import lombok.RequiredArgsConstructor;
+import org.opensearch.core.action.ActionResponse;
+import org.opensearch.core.common.io.stream.StreamInput;
+import org.opensearch.core.common.io.stream.StreamOutput;
+
+@RequiredArgsConstructor
+public class PatchDataSourceActionResponse extends ActionResponse {
+
+  @Getter private final String result;
+
+  public PatchDataSourceActionResponse(StreamInput in) throws IOException {
+    super(in);
+    result = in.readString();
+  }
+
+  @Override
+  public void writeTo(StreamOutput streamOutput) throws IOException {
+    streamOutput.writeString(result);
+  }
+}

datasources/src/main/java/org/opensearch/sql/datasources/rest/RestDataSourceQueryAction.java

@@ -10,15 +10,13 @@
 import static org.opensearch.core.rest.RestStatus.BAD_REQUEST;
 import static org.opensearch.core.rest.RestStatus.NOT_FOUND;
 import static org.opensearch.core.rest.RestStatus.SERVICE_UNAVAILABLE;
-import static org.opensearch.rest.RestRequest.Method.DELETE;
-import static org.opensearch.rest.RestRequest.Method.GET;
-import static org.opensearch.rest.RestRequest.Method.POST;
-import static org.opensearch.rest.RestRequest.Method.PUT;
+import static org.opensearch.rest.RestRequest.Method.*;
 
 import com.google.common.collect.ImmutableList;
 import java.io.IOException;
 import java.util.List;
 import java.util.Locale;
+import java.util.Map;
 import org.apache.logging.log4j.LogManager;
 import org.apache.logging.log4j.Logger;
 import org.opensearch.OpenSearchException;
@@ -32,18 +30,8 @@
 import org.opensearch.sql.datasource.model.DataSourceMetadata;
 import org.opensearch.sql.datasources.exceptions.DataSourceNotFoundException;
 import org.opensearch.sql.datasources.exceptions.ErrorMessage;
-import org.opensearch.sql.datasources.model.transport.CreateDataSourceActionRequest;
-import org.opensearch.sql.datasources.model.transport.CreateDataSourceActionResponse;
-import org.opensearch.sql.datasources.model.transport.DeleteDataSourceActionRequest;
-import org.opensearch.sql.datasources.model.transport.DeleteDataSourceActionResponse;
-import org.opensearch.sql.datasources.model.transport.GetDataSourceActionRequest;
-import org.opensearch.sql.datasources.model.transport.GetDataSourceActionResponse;
-import org.opensearch.sql.datasources.model.transport.UpdateDataSourceActionRequest;
-import org.opensearch.sql.datasources.model.transport.UpdateDataSourceActionResponse;
-import org.opensearch.sql.datasources.transport.TransportCreateDataSourceAction;
-import org.opensearch.sql.datasources.transport.TransportDeleteDataSourceAction;
-import org.opensearch.sql.datasources.transport.TransportGetDataSourceAction;
-import org.opensearch.sql.datasources.transport.TransportUpdateDataSourceAction;
+import org.opensearch.sql.datasources.model.transport.*;
+import org.opensearch.sql.datasources.transport.*;
 import org.opensearch.sql.datasources.utils.Scheduler;
 import org.opensearch.sql.datasources.utils.XContentParserUtils;
 
@@ -98,6 +86,17 @@ public List<Route> routes() {
          */
         new Route(PUT, BASE_DATASOURCE_ACTION_URL),
 
+        /*
+         * PATCH datasources
+         * Request body:
+         * Ref
+         * [org.opensearch.sql.plugin.transport.datasource.model.PatchDataSourceActionRequest]
+         * Response body:
+         * Ref
+         * [org.opensearch.sql.plugin.transport.datasource.model.PatchDataSourceActionResponse]
+         */
+        new Route(PATCH, BASE_DATASOURCE_ACTION_URL),
+
         /*
          * DELETE datasources
          * Request body: Ref
@@ -122,6 +121,8 @@ protected RestChannelConsumer prepareRequest(RestRequest restRequest, NodeClient
         return executeUpdateRequest(restRequest, nodeClient);
       case DELETE:
         return executeDeleteRequest(restRequest, nodeClient);
+      case PATCH:
+        return executePatchRequest(restRequest, nodeClient);
       default:
         return restChannel ->
             restChannel.sendResponse(
@@ -216,6 +217,34 @@ public void onFailure(Exception e) {
                     }));
   }
 
+  private RestChannelConsumer executePatchRequest(RestRequest restRequest, NodeClient nodeClient)
+      throws IOException {
+    Map<String, Object> dataSourceData = XContentParserUtils.toMap(restRequest.contentParser());
+    return restChannel ->
+        Scheduler.schedule(
+            nodeClient,
+            () ->
+                nodeClient.execute(
+                    TransportPatchDataSourceAction.ACTION_TYPE,
+                    new PatchDataSourceActionRequest(dataSourceData),
+                    new ActionListener<>() {
+                      @Override
+                      public void onResponse(
+                          PatchDataSourceActionResponse patchDataSourceActionResponse) {
+                        restChannel.sendResponse(
+                            new BytesRestResponse(
+                                RestStatus.OK,
+                                "application/json; charset=UTF-8",
+                                patchDataSourceActionResponse.getResult()));
+                      }
+
+                      @Override
+                      public void onFailure(Exception e) {
+                        handleException(e, restChannel);
+                      }
+                    }));
+  }
+
   private RestChannelConsumer executeDeleteRequest(RestRequest restRequest, NodeClient nodeClient) {
 
     String dataSourceName = restRequest.param("dataSourceName");

datasources/src/main/java/org/opensearch/sql/datasources/service/DataSourceServiceImpl.java

@@ -6,15 +6,11 @@
 package org.opensearch.sql.datasources.service;
 
 import static org.opensearch.sql.analysis.DataSourceSchemaIdentifierNameResolver.DEFAULT_DATASOURCE_NAME;
+import static org.opensearch.sql.datasources.utils.XContentParserUtils.*;
 
 import com.google.common.base.Preconditions;
 import com.google.common.base.Strings;
-import java.util.HashMap;
-import java.util.HashSet;
-import java.util.List;
-import java.util.Objects;
-import java.util.Optional;
-import java.util.Set;
+import java.util.*;
 import org.opensearch.sql.common.utils.StringUtils;
 import org.opensearch.sql.datasource.DataSourceService;
 import org.opensearch.sql.datasource.model.DataSource;
@@ -90,14 +86,27 @@ public void createDataSource(DataSourceMetadata metadata) {
   public void updateDataSource(DataSourceMetadata dataSourceMetadata) {
     validateDataSourceMetaData(dataSourceMetadata);
     if (!dataSourceMetadata.getName().equals(DEFAULT_DATASOURCE_NAME)) {
-      this.dataSourceLoaderCache.getOrLoadDataSource(dataSourceMetadata);
       this.dataSourceMetadataStorage.updateDataSourceMetadata(dataSourceMetadata);
     } else {
       throw new UnsupportedOperationException(
           "Not allowed to update default datasource :" + DEFAULT_DATASOURCE_NAME);
     }
   }
 
+  @Override
+  public void patchDataSource(Map<String, Object> dataSourceData) {
+    if (!dataSourceData.get(NAME_FIELD).equals(DEFAULT_DATASOURCE_NAME)) {
+      DataSourceMetadata dataSourceMetadata =
+          getRawDataSourceMetadata((String) dataSourceData.get(NAME_FIELD));
+      replaceOldDatasourceMetadata(dataSourceData, dataSourceMetadata);
+      updateDataSource(dataSourceMetadata);
+      this.dataSourceMetadataStorage.patchDataSourceMetadata(dataSourceData);
+    } else {
+      throw new UnsupportedOperationException(
+          "Not allowed to update default datasource :" + DEFAULT_DATASOURCE_NAME);
+    }
+  }
+
   @Override
   public void deleteDataSource(String dataSourceName) {
     if (dataSourceName.equals(DEFAULT_DATASOURCE_NAME)) {
@@ -134,6 +143,35 @@ private void validateDataSourceMetaData(DataSourceMetadata metadata) {
             + " Properties are required parameters.");
   }
 
+  /**
+   * Replaces the fields in the map of the given metadata.
+   *
+   * @param dataSourceData
+   * @param metadata {@link DataSourceMetadata}.
+   */
+  private void replaceOldDatasourceMetadata(
+      Map<String, Object> dataSourceData, DataSourceMetadata metadata) {
+
+    for (String key : dataSourceData.keySet()) {
+      switch (key) {
+          // Name and connector should not be modified
+        case DESCRIPTION_FIELD:
+          metadata.setDescription((String) dataSourceData.get(DESCRIPTION_FIELD));
+          break;
+        case ALLOWED_ROLES_FIELD:
+          metadata.setAllowedRoles((List<String>) dataSourceData.get(ALLOWED_ROLES_FIELD));
+          break;
+        case PROPERTIES_FIELD:
+          Map<String, String> properties = new HashMap<>(metadata.getProperties());
+          properties.putAll(((Map<String, String>) dataSourceData.get(PROPERTIES_FIELD)));
+          break;
+        case NAME_FIELD:
+        case CONNECTOR_FIELD:
+          break;
+      }
+    }
+  }
+
   @Override
   public DataSourceMetadata getRawDataSourceMetadata(String dataSourceName) {
     if (dataSourceName.equals(DEFAULT_DATASOURCE_NAME)) {

datasources/src/main/java/org/opensearch/sql/datasources/storage/OpenSearchDataSourceMetadataStorage.java

@@ -7,6 +7,8 @@
 
 package org.opensearch.sql.datasources.storage;
 
+import static org.opensearch.sql.datasources.utils.XContentParserUtils.PROPERTIES_FIELD;
+
 import java.io.IOException;
 import java.io.InputStream;
 import java.nio.charset.StandardCharsets;
@@ -263,6 +265,16 @@ private DataSourceMetadata encryptDecryptAuthenticationData(
     return dataSourceMetadata;
   }
 
+  // Encrypt and Decrypt irrespective of auth type.If properties name ends in username, password,
+  // secret_key and access_key.
+  private Map<String, Object> encryptDecryptAuthenticationData(
+      Map<String, Object> dataSourceData, Boolean isEncryption) {
+    Map<String, String> propertiesMap = (Map<String, String>) dataSourceData.get(PROPERTIES_FIELD);
+    handleBasicAuthPropertiesEncryptionDecryption(propertiesMap, isEncryption);
+    handleSigV4PropertiesEncryptionDecryption(propertiesMap, isEncryption);
+    return dataSourceData;
+  }
+
   private void handleBasicAuthPropertiesEncryptionDecryption(
       Map<String, String> propertiesMap, Boolean isEncryption) {
     ArrayList<String> list = new ArrayList<>();

datasources/src/main/java/org/opensearch/sql/datasources/transport/TransportPatchDataSourceAction.java

@@ -0,0 +1,74 @@
+/*
+ *
+ *  * Copyright OpenSearch Contributors
+ *  * SPDX-License-Identifier: Apache-2.0
+ *
+ */
+
+package org.opensearch.sql.datasources.transport;
+
+import static org.opensearch.sql.datasources.utils.XContentParserUtils.NAME_FIELD;
+import static org.opensearch.sql.protocol.response.format.JsonResponseFormatter.Style.PRETTY;
+
+import org.opensearch.action.ActionType;
+import org.opensearch.action.support.ActionFilters;
+import org.opensearch.action.support.HandledTransportAction;
+import org.opensearch.common.inject.Inject;
+import org.opensearch.core.action.ActionListener;
+import org.opensearch.sql.datasource.DataSourceService;
+import org.opensearch.sql.datasources.model.transport.PatchDataSourceActionRequest;
+import org.opensearch.sql.datasources.model.transport.PatchDataSourceActionResponse;
+import org.opensearch.sql.datasources.service.DataSourceServiceImpl;
+import org.opensearch.sql.protocol.response.format.JsonResponseFormatter;
+import org.opensearch.tasks.Task;
+import org.opensearch.transport.TransportService;
+
+public class TransportPatchDataSourceAction
+    extends HandledTransportAction<PatchDataSourceActionRequest, PatchDataSourceActionResponse> {
+
+  public static final String NAME = "cluster:admin/opensearch/ql/datasources/update";
+  public static final ActionType<PatchDataSourceActionResponse> ACTION_TYPE =
+      new ActionType<>(NAME, PatchDataSourceActionResponse::new);
+
+  private DataSourceService dataSourceService;
+
+  /**
+   * TransportUpdateDataSourceAction action for updating datasource.
+   *
+   * @param transportService transportService.
+   * @param actionFilters actionFilters.
+   * @param dataSourceService dataSourceService.
+   */
+  @Inject
+  public TransportPatchDataSourceAction(
+      TransportService transportService,
+      ActionFilters actionFilters,
+      DataSourceServiceImpl dataSourceService) {
+    super(
+        TransportPatchDataSourceAction.NAME,
+        transportService,
+        actionFilters,
+        PatchDataSourceActionRequest::new);
+    this.dataSourceService = dataSourceService;
+  }
+
+  @Override
+  protected void doExecute(
+      Task task,
+      PatchDataSourceActionRequest request,
+      ActionListener<PatchDataSourceActionResponse> actionListener) {
+    try {
+      dataSourceService.patchDataSource(request.getDataSourceData());
+      String responseContent =
+          new JsonResponseFormatter<String>(PRETTY) {
+            @Override
+            protected Object buildJsonObject(String response) {
+              return response;
+            }
+          }.format("Updated DataSource with name " + request.getDataSourceData().get(NAME_FIELD));
+      actionListener.onResponse(new PatchDataSourceActionResponse(responseContent));
+    } catch (Exception e) {
+      actionListener.onFailure(e);
+    }
+  }
+}