feat: [CI-4981]: Added manager validation for Artifactory and Docker Registry

Author: devkimittal

260-delegate/src/main/java/io/harness/delegate/app/modules/DelegateModule.java

@@ -66,8 +66,10 @@
 import io.harness.connector.service.git.NGGitServiceImpl;
 import io.harness.connector.service.scm.ScmDelegateClient;
 import io.harness.connector.task.ConnectorValidationHandler;
+import io.harness.connector.task.artifactory.ArtifactoryValidationHandler;
 import io.harness.connector.task.aws.AwsValidationHandler;
 import io.harness.connector.task.azure.AzureValidationHandler;
+import io.harness.connector.task.docker.DockerValidationHandler;
 import io.harness.connector.task.gcp.GcpValidationTaskHandler;
 import io.harness.connector.task.git.GitValidationHandler;
 import io.harness.cvng.CVNGDataCollectionDelegateServiceImpl;
@@ -143,7 +145,6 @@
 import io.harness.delegate.task.PagerDutySenderDelegateTask;
 import io.harness.delegate.task.SlackSenderDelegateTask;
 import io.harness.delegate.task.artifactory.ArtifactoryDelegateTask;
-import io.harness.delegate.task.artifactory.ArtifactoryValidationHandler;
 import io.harness.delegate.task.artifacts.ArtifactSourceDelegateRequest;
 import io.harness.delegate.task.artifacts.DelegateArtifactTaskHandler;
 import io.harness.delegate.task.artifacts.artifactory.ArtifactoryArtifactDelegateRequest;
@@ -204,7 +205,6 @@
 import io.harness.delegate.task.cloudformation.handlers.CloudformationDeleteStackTaskHandler;
 import io.harness.delegate.task.cvng.CVConnectorValidationHandler;
 import io.harness.delegate.task.docker.DockerTestConnectionDelegateTask;
-import io.harness.delegate.task.docker.DockerValidationHandler;
 import io.harness.delegate.task.executioncapability.BatchCapabilityCheckTask;
 import io.harness.delegate.task.gcp.GcpTask;
 import io.harness.delegate.task.gcp.GcpTaskType;

440-connector-nextgen/src/main/java/io/harness/connector/ConnectorModule.java

@@ -11,6 +11,8 @@
 import static io.harness.annotations.dev.HarnessTeam.DX;
 
 import io.harness.annotations.dev.OwnedBy;
+import io.harness.artifacts.docker.client.DockerRestClientFactory;
+import io.harness.artifacts.docker.client.DockerRestClientFactoryImpl;
 import io.harness.aws.AwsClient;
 import io.harness.aws.AwsClientImpl;
 import io.harness.azure.client.AzureAuthorizationClient;
@@ -120,6 +122,7 @@ protected void configure() {
     bind(GcpClient.class).to(GcpClientImpl.class);
     bind(AzureAuthorizationClient.class).to(AzureAuthorizationClientImpl.class);
     bind(NGGitService.class).to(NGGitServiceImpl.class);
+    bind(DockerRestClientFactory.class).to(DockerRestClientFactoryImpl.class);
     bind(GitClientV2.class).to(GitClientV2Impl.class);
     bind(ScmDelegateClient.class).to(ScmDelegateClientImpl.class);
     bind(NGConnectorSecretManagerService.class).to(NGConnectorSecretManagerServiceImpl.class);

440-connector-nextgen/src/main/java/io/harness/connector/ConnectorRegistryFactory.java

@@ -114,8 +114,10 @@
 import io.harness.connector.mappers.sumologicmapper.SumoLogicEntityToDTO;
 import io.harness.connector.task.ConnectorValidationHandler;
 import io.harness.connector.task.NotSupportedValidationHandler;
+import io.harness.connector.task.artifactory.ArtifactoryValidationHandler;
 import io.harness.connector.task.aws.AwsValidationHandler;
 import io.harness.connector.task.azure.AzureValidationHandler;
+import io.harness.connector.task.docker.DockerValidationHandler;
 import io.harness.connector.task.gcp.GcpValidationTaskHandler;
 import io.harness.connector.task.git.GitValidationHandler;
 import io.harness.connector.validator.ArtifactoryConnectionValidator;
@@ -221,7 +223,7 @@ public class ConnectorRegistryFactory {
     registrar.put(ConnectorType.DOCKER,
         new ConnectorRegistrar(ConnectorCategory.ARTIFACTORY, DockerConnectionValidator.class,
             DockerConnectorValidationParamsProvider.class, DockerDTOToEntity.class, DockerEntityToDTO.class,
-            NotSupportedValidationHandler.class));
+            DockerValidationHandler.class));
     registrar.put(ConnectorType.GCP,
         new ConnectorRegistrar(ConnectorCategory.CLOUD_PROVIDER, GcpConnectorValidator.class,
             GcpValidationParamsProvider.class, GcpDTOToEntity.class, GcpEntityToDTO.class,
@@ -240,7 +242,7 @@ public class ConnectorRegistryFactory {
     registrar.put(ConnectorType.ARTIFACTORY,
         new ConnectorRegistrar(ConnectorCategory.ARTIFACTORY, ArtifactoryConnectionValidator.class,
             ArtifactoryValidationParamsProvider.class, ArtifactoryDTOToEntity.class, ArtifactoryEntityToDTO.class,
-            NotSupportedValidationHandler.class));
+            ArtifactoryValidationHandler.class));
     registrar.put(ConnectorType.JIRA,
         new ConnectorRegistrar(ConnectorCategory.TICKETING, JiraConnectorValidator.class,
             JiraValidationParamsProvider.class, JiraDTOToEntity.class, JiraEntityToDTO.class,

440-connector-nextgen/src/main/java/io/harness/connector/validator/AbstractArtifactConnectorValidator.java

@@ -0,0 +1,44 @@
+package io.harness.connector.validator;
+
+import io.harness.connector.ConnectorValidationResult;
+import io.harness.connector.ManagerExecutable;
+import io.harness.delegate.beans.DelegateResponseData;
+import io.harness.delegate.beans.artifactory.ArtifactoryTaskResponse;
+import io.harness.delegate.beans.connector.ConnectorConfigDTO;
+import io.harness.delegate.beans.connector.artifactoryconnector.ArtifactoryConnectorDTO;
+import io.harness.delegate.beans.connector.docker.DockerConnectorDTO;
+import io.harness.delegate.beans.connector.docker.DockerTestConnectionTaskResponse;
+import io.harness.exception.InvalidRequestException;
+
+public abstract class AbstractArtifactConnectorValidator extends AbstractConnectorValidator {
+  public boolean shouldExecuteOnDelegate(ConnectorConfigDTO connectorConfigDTO) {
+    Boolean executeOnDelegate = Boolean.TRUE;
+    if (connectorConfigDTO instanceof ManagerExecutable) {
+      executeOnDelegate = ((ManagerExecutable) connectorConfigDTO).getExecuteOnDelegate();
+    }
+    return executeOnDelegate;
+  }
+
+  public ConnectorValidationResult validate(ConnectorConfigDTO connectorConfigDTO, String accountIdentifier,
+      String orgIdentifier, String projectIdentifier, String identifier) {
+    boolean executeOnDelegate = shouldExecuteOnDelegate(connectorConfigDTO);
+    if (!executeOnDelegate) {
+      return super.validateConnectorViaManager(
+          connectorConfigDTO, accountIdentifier, orgIdentifier, projectIdentifier, identifier);
+    } else {
+      DelegateResponseData responseData =
+          super.validateConnector(connectorConfigDTO, accountIdentifier, orgIdentifier, projectIdentifier, identifier);
+      return getValidationResult(connectorConfigDTO, responseData);
+    }
+  }
+
+  private ConnectorValidationResult getValidationResult(
+      ConnectorConfigDTO connectorConfigDTO, DelegateResponseData delegateResponseData) {
+    if (connectorConfigDTO instanceof ArtifactoryConnectorDTO) {
+      return ((ArtifactoryTaskResponse) delegateResponseData).getConnectorValidationResult();
+    } else if (connectorConfigDTO instanceof DockerConnectorDTO) {
+      return ((DockerTestConnectionTaskResponse) delegateResponseData).getConnectorValidationResult();
+    }
+    throw new InvalidRequestException("Invalid connector type found during connection test");
+  }
+}

440-connector-nextgen/src/main/java/io/harness/connector/validator/ArtifactoryConnectionValidator.java

@@ -14,7 +14,6 @@
 import io.harness.connector.ConnectorResponseDTO;
 import io.harness.connector.ConnectorValidationResult;
 import io.harness.delegate.beans.artifactory.ArtifactoryTaskParams;
-import io.harness.delegate.beans.artifactory.ArtifactoryTaskResponse;
 import io.harness.delegate.beans.connector.ConnectorConfigDTO;
 import io.harness.delegate.beans.connector.artifactoryconnector.ArtifactoryConnectorDTO;
 import io.harness.delegate.task.TaskParameters;
@@ -24,7 +23,7 @@
 
 @Slf4j
 @Singleton
-public class ArtifactoryConnectionValidator extends AbstractConnectorValidator {
+public class ArtifactoryConnectionValidator extends AbstractArtifactConnectorValidator {
   @Override
   public <T extends ConnectorConfigDTO> TaskParameters getTaskParameters(
       T connectorConfig, String accountIdentifier, String orgIdentifier, String projectIdentifier) {
@@ -46,9 +45,7 @@ public String getTaskType() {
   @Override
   public ConnectorValidationResult validate(ConnectorConfigDTO connectorDTO, String accountIdentifier,
       String orgIdentifier, String projectIdentifier, String identifier) {
-    ArtifactoryTaskResponse responseData = (ArtifactoryTaskResponse) super.validateConnector(
-        connectorDTO, accountIdentifier, orgIdentifier, projectIdentifier, identifier);
-    return responseData.getConnectorValidationResult();
+    return super.validate(connectorDTO, accountIdentifier, orgIdentifier, projectIdentifier, identifier);
   }
 
   @Override

440-connector-nextgen/src/main/java/io/harness/connector/validator/DockerConnectionValidator.java

@@ -15,15 +15,14 @@
 import io.harness.delegate.beans.connector.docker.DockerAuthCredentialsDTO;
 import io.harness.delegate.beans.connector.docker.DockerConnectorDTO;
 import io.harness.delegate.beans.connector.docker.DockerTestConnectionTaskParams;
-import io.harness.delegate.beans.connector.docker.DockerTestConnectionTaskResponse;
 import io.harness.delegate.task.TaskParameters;
 
 import com.google.inject.Singleton;
 import lombok.extern.slf4j.Slf4j;
 
 @Slf4j
 @Singleton
-public class DockerConnectionValidator extends AbstractConnectorValidator {
+public class DockerConnectionValidator extends AbstractArtifactConnectorValidator {
   @Override
   public <T extends ConnectorConfigDTO> TaskParameters getTaskParameters(
       T connectorConfig, String accountIdentifier, String orgIdentifier, String projectIdentifier) {
@@ -45,9 +44,7 @@ public String getTaskType() {
   @Override
   public ConnectorValidationResult validate(ConnectorConfigDTO dockerConnector, String accountIdentifier,
       String orgIdentifier, String projectIdentifier, String identifier) {
-    DockerTestConnectionTaskResponse responseData = (DockerTestConnectionTaskResponse) super.validateConnector(
-        dockerConnector, accountIdentifier, orgIdentifier, projectIdentifier, identifier);
-    return responseData.getConnectorValidationResult();
+    return super.validate(dockerConnector, accountIdentifier, orgIdentifier, projectIdentifier, identifier);
   }
 
   @Override

440-connector-nextgen/src/test/java/io/harness/connector/validator/ArtifactoryConnectionValidatorTest.java

@@ -0,0 +1,125 @@
+/*
+ * Copyright 2021 Harness Inc. All rights reserved.
+ * Use of this source code is governed by the PolyForm Free Trial 1.0.0 license
+ * that can be found in the licenses directory at the root of this repository, also available at
+ * https://polyformproject.org/wp-content/uploads/2020/05/PolyForm-Free-Trial-1.0.0.txt.
+ */
+
+package io.harness.connector.validator;
+
+import static io.harness.connector.ConnectivityStatus.SUCCESS;
+
+import static org.assertj.core.api.Assertions.assertThat;
+import static org.joor.Reflect.on;
+import static org.mockito.Matchers.any;
+import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.when;
+
+import io.harness.CategoryTest;
+import io.harness.artifactory.ArtifactoryClientImpl;
+import io.harness.category.element.UnitTests;
+import io.harness.connector.ConnectorInfoDTO;
+import io.harness.connector.ConnectorResponseDTO;
+import io.harness.connector.ConnectorValidationResult;
+import io.harness.connector.heartbeat.ArtifactoryValidationParamsProvider;
+import io.harness.connector.heartbeat.ConnectorValidationParamsProvider;
+import io.harness.connector.helper.DecryptionHelper;
+import io.harness.connector.helper.EncryptionHelper;
+import io.harness.connector.services.ConnectorService;
+import io.harness.connector.task.ConnectorValidationHandler;
+import io.harness.connector.task.artifactory.ArtifactoryRequestMapper;
+import io.harness.connector.task.artifactory.ArtifactoryValidationHandler;
+import io.harness.delegate.beans.connector.ConnectorType;
+import io.harness.delegate.beans.connector.artifactoryconnector.ArtifactoryAuthCredentialsDTO;
+import io.harness.delegate.beans.connector.artifactoryconnector.ArtifactoryAuthType;
+import io.harness.delegate.beans.connector.artifactoryconnector.ArtifactoryAuthenticationDTO;
+import io.harness.delegate.beans.connector.artifactoryconnector.ArtifactoryConnectorDTO;
+import io.harness.delegate.beans.connector.artifactoryconnector.ArtifactoryUsernamePasswordAuthDTO;
+import io.harness.encryption.Scope;
+import io.harness.encryption.SecretRefData;
+import io.harness.rule.Owner;
+import io.harness.rule.OwnerRule;
+
+import java.util.Map;
+import java.util.Optional;
+import lombok.extern.slf4j.Slf4j;
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.experimental.categories.Category;
+import org.mockito.InjectMocks;
+import org.mockito.Matchers;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+
+@Slf4j
+public class ArtifactoryConnectionValidatorTest extends CategoryTest {
+  @Mock private EncryptionHelper encryptionHelper;
+  @Mock private ConnectorService connectorService;
+  @Mock private DecryptionHelper decryptionHelper;
+  @Mock private ArtifactoryClientImpl artifactoryService;
+  ArtifactoryRequestMapper artifactoryRequestMapper = new ArtifactoryRequestMapper();
+  @Mock private Map<String, ConnectorValidationHandler> connectorTypeToConnectorValidationHandlerMap;
+  @Mock private Map<String, ConnectorValidationParamsProvider> connectorValidationParamsProviderMap;
+  @InjectMocks private ArtifactoryConnectionValidator artifactoryConnectionValidator;
+
+  @Before
+  public void setUp() throws Exception {
+    MockitoAnnotations.initMocks(this);
+  }
+
+  @Test
+  @Owner(developers = OwnerRule.DEV_MITTAL)
+  @Category(UnitTests.class)
+  public void validateTestViaManager() {
+    String artifactoryUrl = "url";
+    String artifactoryUserName = "ArtifactoryUserName";
+    String passwordRefIdentifier = "passwordRefIdentifier";
+    SecretRefData passwordSecretRef = SecretRefData.builder()
+                                          .identifier(passwordRefIdentifier)
+                                          .scope(Scope.ACCOUNT)
+                                          .decryptedValue("password".toCharArray())
+                                          .build();
+
+    ArtifactoryAuthCredentialsDTO artifactoryAuthCredentialsDTO = ArtifactoryUsernamePasswordAuthDTO.builder()
+                                                                      .username(artifactoryUserName)
+                                                                      .passwordRef(passwordSecretRef)
+                                                                      .build();
+
+    ArtifactoryAuthenticationDTO artifactoryAuthenticationDTO = ArtifactoryAuthenticationDTO.builder()
+                                                                    .authType(ArtifactoryAuthType.USER_PASSWORD)
+                                                                    .credentials(artifactoryAuthCredentialsDTO)
+                                                                    .build();
+    ArtifactoryConnectorDTO artifactoryConnectorDTO = ArtifactoryConnectorDTO.builder()
+                                                          .artifactoryServerUrl(artifactoryUrl)
+                                                          .auth(artifactoryAuthenticationDTO)
+                                                          .executeOnDelegate(false)
+                                                          .build();
+    when(connectorService.get(any(), any(), any(), any()))
+        .thenReturn(Optional.of(ConnectorResponseDTO.builder()
+                                    .connector(ConnectorInfoDTO.builder()
+                                                   .connectorType(ConnectorType.ARTIFACTORY)
+                                                   .identifier("identifier")
+                                                   .projectIdentifier("projectIdentifier")
+                                                   .orgIdentifier("orgIdentifier")
+                                                   .build())
+                                    .build()));
+
+    ArtifactoryValidationHandler artifactoryValidationHandler = mock(ArtifactoryValidationHandler.class);
+    when(artifactoryService.validateArtifactServer(any())).thenReturn(true);
+    on(artifactoryValidationHandler).set("decryptionHelper", decryptionHelper);
+    on(artifactoryValidationHandler).set("artifactoryService", artifactoryService);
+    on(artifactoryValidationHandler).set("artifactoryRequestMapper", artifactoryRequestMapper);
+    when(artifactoryValidationHandler.validate(any(), any())).thenCallRealMethod();
+    when(connectorTypeToConnectorValidationHandlerMap.get(Matchers.eq("Artifactory")))
+        .thenReturn(artifactoryValidationHandler);
+
+    ArtifactoryValidationParamsProvider artifactoryValidationParamsProvider = new ArtifactoryValidationParamsProvider();
+    on(artifactoryValidationParamsProvider).set("encryptionHelper", encryptionHelper);
+    when(connectorValidationParamsProviderMap.get(Matchers.eq("Artifactory")))
+        .thenReturn(artifactoryValidationParamsProvider);
+
+    ConnectorValidationResult validationResult = artifactoryConnectionValidator.validate(
+        artifactoryConnectorDTO, "accountIdentifier", "orgIdentifier", "projectIdentifier", "identifier");
+    assertThat(validationResult.getStatus()).isEqualTo(SUCCESS);
+  }
+}