concord-tasks: add createApiKey action (#1194)

Author: ibodrov

it/runtime-v2/src/test/java/com/walmartlabs/concord/it/runtime/v2/ConcordTaskIT.java

@@ -28,9 +28,11 @@
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.RegisterExtension;
 
+import java.util.List;
+import java.util.UUID;
+
 import static com.walmartlabs.concord.it.common.ITUtils.randomString;
-import static org.junit.jupiter.api.Assertions.assertEquals;
-import static org.junit.jupiter.api.Assertions.assertNotNull;
+import static org.junit.jupiter.api.Assertions.*;
 
 public class ConcordTaskIT extends AbstractTest {
 
@@ -213,4 +215,32 @@ public void testDryRunForChildProcess() throws Exception {
         // ---
         proc.assertLog(".*Done!.*");
     }
+
+
+    @Test
+    public void testCreateApiKey() throws Exception {
+        String apiKeyName = "test_" + randomString();
+
+        Payload payload = new Payload()
+                .archive(resource("concord/createApiKey"))
+                .arg("apiKeyName", apiKeyName);
+
+        // ---
+
+        ConcordProcess proc = concord.processes().start(payload);
+        expectStatus(proc, ProcessEntry.StatusEnum.FINISHED);
+
+        // ---
+
+        proc.assertLog(".*result1=.*");
+        proc.assertNoLog(".*result2=.*");
+        proc.assertLog(".*error=.*");
+        proc.assertLog(".*result3=.*");
+
+        // ---
+
+        ApiKeysApi apiKeysApi = new ApiKeysApi(concord.apiClient());
+        List<ApiKeyEntry> apiKeys = apiKeysApi.listUserApiKeys(UUID.fromString("230c5c9c-d9a7-11e6-bcfd-bb681c07b26c"));// admin
+        assertTrue(apiKeys.stream().anyMatch(k -> k.getName().equals(apiKeyName)));
+    }
 }

it/runtime-v2/src/test/resources/com/walmartlabs/concord/it/runtime/v2/concord/createApiKey/concord.yml

@@ -0,0 +1,34 @@
+configuration:
+  runtime: "concord-v2"
+
+flows:
+  default:
+    # create a new API key
+    - task: concord
+      in:
+        action: createApiKey
+        username: admin
+        name: ${apiKeyName}
+      out: result1
+    - log: "result1=${result1}"
+
+    # try creating a new API key with the same name
+    - try:
+        - task: concord
+          in:
+            action: createApiKey
+            username: admin
+            name: ${apiKeyName}
+        - log: "result2=${result2}"
+      error:
+        - log: "error=${lastError}"
+
+    # try creating a new API key with the same name but ignore existings
+    - task: concord
+      in:
+        action: createApiKey
+        username: admin
+        name: ${apiKeyName}
+        ignoreExisting: true
+      out: result3
+    - log: "result3=${result3}"

plugins/tasks/concord/src/main/java/com/walmartlabs/concord/client/ConcordTaskCommon.java

@@ -37,6 +37,7 @@
 import java.nio.file.Files;
 import java.nio.file.Path;
 import java.nio.file.Paths;
+import java.time.OffsetDateTime;
 import java.util.*;
 import java.util.concurrent.*;
 import java.util.function.Function;
@@ -84,23 +85,16 @@ public ConcordTaskCommon(String sessionToken, ApiClientFactory apiClientFactory,
 
     public TaskResult execute(ConcordTaskParams in) throws Exception {
         Action action = in.action();
-        switch (action) {
-            case START: {
-                return startChildProcess((StartParams) in);
-            }
-            case STARTEXTERNAL: {
-                return startExternalProcess((StartExternalParams) in);
-            }
-            case FORK: {
-                return fork((ForkParams) in);
-            }
-            case KILL: {
+        return switch (action) {
+            case START -> startChildProcess((StartParams) in);
+            case STARTEXTERNAL -> startExternalProcess((StartExternalParams) in);
+            case FORK -> fork((ForkParams) in);
+            case KILL -> {
                 kill((KillParams) in);
-                return TaskResult.success();
+                yield TaskResult.success();
             }
-            default:
-                throw new IllegalArgumentException("Unsupported action type: " + action);
-        }
+            case CREATEAPIKEY -> createApiKey((CreateApiKeyParams) in);
+        };
     }
 
     public List<ProcessEntry> listSubProcesses(ListSubProcesses in) throws Exception {
@@ -185,6 +179,55 @@ public void kill(KillParams in) throws Exception {
         }
     }
 
+    public TaskResult createApiKey(CreateApiKeyParams in) throws Exception {
+        return withClient(in.baseUrl(), in.apiKey(), client -> {
+            log.info("Creating a new API key in {}", client.getBaseUri());
+            UUID userId = in.userId();
+            if (userId == null) {
+                String username = in.username();
+                if (username == null) {
+                    throw new IllegalArgumentException("User ID or user name is required");
+                }
+
+                UsersApi usersApi = new UsersApi(client);
+                UserEntry user = usersApi.findByUsername(username);
+                if (user == null) {
+                    throw new IllegalArgumentException("User '" + username + "' not found.");
+                }
+                userId = user.getId();
+            }
+
+            String keyName = in.name();
+            if (keyName != null) {
+                ApiKeysApi api = new ApiKeysApi(client);
+                List<ApiKeyEntry> existingKeys = api.listUserApiKeys(userId);
+                Optional<ApiKeyEntry> maybeExistingKey = existingKeys.stream().filter(k -> k.getName().equals(keyName)).findFirst();
+                if (maybeExistingKey.isPresent()) {
+                    if (in.ignoreExisting()) {
+                        log.info("API key '{}' already exists, nothing to do.", keyName);
+                        ApiKeyEntry existingKey = maybeExistingKey.get();
+                        return TaskResult.success()
+                                .value("id", existingKey.getId())
+                                .value("expiredAt", Optional.ofNullable(existingKey.getExpiredAt()).map(OffsetDateTime::toString).orElse(null));
+                    } else {
+                        throw new IllegalArgumentException("API key '" + keyName + "' already exists.");
+                    }
+                }
+            }
+
+            ApiKeysApi apiKeysApi = new ApiKeysApi(client);
+            CreateApiKeyResponse response = apiKeysApi.createUserApiKey(new CreateApiKeyRequest()
+                    .name(keyName)
+                    .userId(userId)
+                    .userDomain(in.userDomain())
+                    .userType(in.userType()));
+
+            return TaskResult.success()
+                    .value("id", response.getId())
+                    .value("key", response.getKey());
+        });
+    }
+
     public Map<String, Map<String, Object>> getOutVars(String baseUrl, String apiKey, List<UUID> ids, long timeout) {
         return waitForCompletion(ids, timeout, p -> {
             try {

plugins/tasks/concord/src/main/java/com/walmartlabs/concord/client/ConcordTaskParams.java

@@ -20,6 +20,7 @@
  * =====
  */
 
+import com.walmartlabs.concord.client2.CreateApiKeyRequest;
 import com.walmartlabs.concord.runtime.v2.sdk.MapBackedVariables;
 import com.walmartlabs.concord.runtime.v2.sdk.Variables;
 
@@ -36,23 +37,13 @@ public static ConcordTaskParams of(Variables input, Map<String, Object> defaults
         Variables variables = new MapBackedVariables(variablesMap);
 
         ConcordTaskParams p = new ConcordTaskParams(variables);
-        switch (p.action()) {
-            case START: {
-                return new StartParams(variables);
-            }
-            case STARTEXTERNAL: {
-                return new StartExternalParams(variables);
-            }
-            case FORK: {
-                return new ForkParams(variables);
-            }
-            case KILL: {
-                return new KillParams(variables);
-            }
-            default: {
-                throw new IllegalArgumentException("Unsupported action type: " + p.action());
-            }
-        }
+        return switch (p.action()) {
+            case START -> new StartParams(variables);
+            case STARTEXTERNAL -> new StartExternalParams(variables);
+            case FORK -> new ForkParams(variables);
+            case KILL -> new KillParams(variables);
+            case CREATEAPIKEY -> new CreateApiKeyParams(variables);
+        };
     }
 
     protected final Variables variables;
@@ -437,6 +428,72 @@ public boolean sync() {
         }
     }
 
+    public static class CreateApiKeyParams extends ConcordTaskParams {
+
+        private static final String BASE_URL_KEY = "baseUrl";
+        private static final String API_KEY = "apiKey";
+        private static final String USER_ID_KEY = "userId";
+        private static final String USERNAME_KEY = "username";
+        private static final String USER_DOMAIN_KEY = "userDomain";
+        private static final String USER_TYPE_KEY = "userType";
+        private static final String NAME_KEY = "name";
+        private static final String IGNORE_EXISTING_KEY = "ignoreExisting";
+
+        CreateApiKeyParams(Variables variables) {
+            super(variables);
+        }
+
+        public String baseUrl() {
+            return variables.getString(BASE_URL_KEY);
+        }
+
+        public String apiKey() {
+            return variables.getString(API_KEY);
+        }
+
+        public UUID userId() {
+            String value = variables.getString(USER_ID_KEY);
+            if (value == null) {
+                return null;
+            }
+            try {
+                return UUID.fromString(value);
+            } catch (IllegalArgumentException e) {
+                throw new IllegalArgumentException("Expected a user ID, got: " + value);
+            }
+        }
+
+        public String username() {
+            return variables.getString(USERNAME_KEY);
+        }
+
+        public String userDomain() {
+            return variables.getString(USER_DOMAIN_KEY);
+        }
+
+        public CreateApiKeyRequest.UserTypeEnum userType() {
+            String value = variables.getString(USER_TYPE_KEY);
+            if (value == null) {
+                return null;
+            }
+            try {
+                return CreateApiKeyRequest.UserTypeEnum.valueOf(value.toUpperCase());
+            } catch (IllegalArgumentException e) {
+                String validTypes = Arrays.stream(CreateApiKeyRequest.UserTypeEnum.values())
+                        .map(CreateApiKeyRequest.UserTypeEnum::toString).collect(Collectors.joining(", "));
+                throw new IllegalArgumentException("Invalid user type. Expected one of " + validTypes + ", got: " + value);
+            }
+        }
+
+        public String name() {
+            return variables.getString(NAME_KEY);
+        }
+
+        public boolean ignoreExisting() {
+            return variables.getBoolean(IGNORE_EXISTING_KEY, false);
+        }
+    }
+
     private static UUID toUUID(Object v) {
         if (v instanceof String) {
             return UUID.fromString(v.toString());
@@ -472,7 +529,8 @@ public enum Action {
         START,
         STARTEXTERNAL,
         FORK,
-        KILL
+        KILL,
+        CREATEAPIKEY
     }
 
     private static class DelegateVariables implements Variables {