feat: implement correct license statuses (#13894)

Author: malikdiarra

airbyte-commons-server/src/main/java/io/airbyte/commons/server/handlers/InstanceConfigurationHandler.java

@@ -4,6 +4,7 @@
 
 package io.airbyte.commons.server.handlers;
 
+import com.google.common.annotations.VisibleForTesting;
 import io.airbyte.api.model.generated.AuthConfiguration;
 import io.airbyte.api.model.generated.AuthConfiguration.ModeEnum;
 import io.airbyte.api.model.generated.InstanceConfigurationResponse;
@@ -34,6 +35,7 @@
 import jakarta.inject.Named;
 import jakarta.inject.Singleton;
 import java.io.IOException;
+import java.time.Clock;
 import java.util.Optional;
 import java.util.Set;
 import java.util.UUID;
@@ -62,6 +64,7 @@ public class InstanceConfigurationHandler {
   private final String trackingStrategy;
   private final AuthConfigs authConfigs;
   private final PermissionService permissionService;
+  private final Clock clock;
 
   public InstanceConfigurationHandler(@Named("airbyteUrl") final Optional<String> airbyteUrl,
                                       @Value("${airbyte.tracking.strategy:}") final String trackingStrategy,
@@ -73,7 +76,8 @@ public InstanceConfigurationHandler(@Named("airbyteUrl") final Optional<String>
                                       final UserPersistence userPersistence,
                                       final OrganizationPersistence organizationPersistence,
                                       final AuthConfigs authConfigs,
-                                      final PermissionService permissionService) {
+                                      final PermissionService permissionService,
+                                      final Optional<Clock> clock) {
     this.airbyteUrl = airbyteUrl;
     this.trackingStrategy = trackingStrategy;
     this.airbyteEdition = airbyteEdition;
@@ -85,6 +89,7 @@ public InstanceConfigurationHandler(@Named("airbyteUrl") final Optional<String>
     this.organizationPersistence = organizationPersistence;
     this.authConfigs = authConfigs;
     this.permissionService = permissionService;
+    this.clock = clock.orElse(Clock.systemUTC());
   }
 
   public InstanceConfigurationResponse getInstanceConfiguration() throws IOException {
@@ -212,7 +217,7 @@ public LicenseInfoResponse licenseInfo() {
           .usedNodes(0)
           .maxEditors(license.maxEditors().orElse(null))
           .maxNodes(license.maxNodes().orElse(null))
-          .licenseStatus(LicenseStatus.PRO);
+          .licenseStatus(getLicenseStatus());
     }
     return null;
   }
@@ -235,4 +240,21 @@ private Integer editorsUsage() {
     return editors.size();
   }
 
+  @VisibleForTesting
+  LicenseStatus currentLicenseStatus() {
+    if (activeAirbyteLicense.isEmpty()
+        || activeAirbyteLicense.get().getLicense().isEmpty()
+        || activeAirbyteLicense.get().getLicense().get().type() == AirbyteLicense.LicenseType.INVALID) {
+      return LicenseStatus.INVALID;
+    }
+    final AirbyteLicense actualLicense = activeAirbyteLicense.get().getLicense().get();
+    if (actualLicense.expirationDate().map(exp -> exp.toInstant().isBefore(clock.instant())).orElse(false)) {
+      return LicenseStatus.EXPIRED;
+    }
+    if (actualLicense.maxEditors().map(m -> editorsUsage() > m).orElse(false)) {
+      return LicenseStatus.EXCEEDED;
+    }
+    return LicenseStatus.PRO;
+  }
+
 }

airbyte-commons-server/src/test/java/io/airbyte/commons/server/handlers/InstanceConfigurationHandlerTest.java

@@ -28,6 +28,7 @@
 import io.airbyte.config.AuthenticatedUser;
 import io.airbyte.config.Configs.AirbyteEdition;
 import io.airbyte.config.Organization;
+import io.airbyte.config.Permission;
 import io.airbyte.config.StandardWorkspace;
 import io.airbyte.config.persistence.ConfigNotFoundException;
 import io.airbyte.config.persistence.OrganizationPersistence;
@@ -36,9 +37,13 @@
 import io.airbyte.data.services.PermissionService;
 import io.airbyte.validation.json.JsonValidationException;
 import java.io.IOException;
+import java.time.Clock;
+import java.time.Instant;
+import java.time.ZoneId;
 import java.util.Date;
 import java.util.Optional;
 import java.util.UUID;
+import java.util.stream.Stream;
 import org.junit.jupiter.api.BeforeEach;
 import org.junit.jupiter.api.Test;
 import org.junit.jupiter.api.extension.ExtendWith;
@@ -159,7 +164,8 @@ void testGetInstanceConfigurationTrackingStrategy(final String envValue, final T
         mUserPersistence,
         mOrganizationPersistence,
         mAuthConfigs,
-        permissionService);
+        permissionService,
+        Optional.empty());
 
     final var result = handler.getInstanceConfiguration();
 
@@ -280,6 +286,67 @@ void testLicenseInfo() {
     assertEquals(licenseInfoResponse.getMaxNodes(), MAX_NODES);
   }
 
+  @Test
+  void testInvalidLicenseTest() {
+    final ActiveAirbyteLicense license = new ActiveAirbyteLicense();
+    license.setLicense(null);
+    final InstanceConfigurationHandler handler = new InstanceConfigurationHandler(
+        Optional.of(AIRBYTE_URL),
+        "logging",
+        AirbyteEdition.PRO,
+        new AirbyteVersion("0.50.1"),
+        Optional.of(license),
+        mWorkspacePersistence,
+        mWorkspacesHandler,
+        mUserPersistence,
+        mOrganizationPersistence,
+        mAuthConfigs,
+        permissionService,
+        Optional.empty());
+    assertEquals(handler.currentLicenseStatus(), LicenseStatus.INVALID);
+  }
+
+  @Test
+  void testExpiredLicenseTest() {
+    final InstanceConfigurationHandler handler = new InstanceConfigurationHandler(
+        Optional.of(AIRBYTE_URL),
+        "logging",
+        AirbyteEdition.PRO,
+        new AirbyteVersion("0.50.1"),
+        Optional.of(activeAirbyteLicense),
+        mWorkspacePersistence,
+        mWorkspacesHandler,
+        mUserPersistence,
+        mOrganizationPersistence,
+        mAuthConfigs,
+        permissionService,
+        Optional.of(Clock.fixed(Instant.MAX, ZoneId.systemDefault())));
+    assertEquals(handler.currentLicenseStatus(), LicenseStatus.EXPIRED);
+  }
+
+  @Test
+  void testExceededEditorsLicenseTest() {
+
+    final InstanceConfigurationHandler handler = new InstanceConfigurationHandler(
+        Optional.of(AIRBYTE_URL),
+        "logging",
+        AirbyteEdition.PRO,
+        new AirbyteVersion("0.50.1"),
+        Optional.of(activeAirbyteLicense),
+        mWorkspacePersistence,
+        mWorkspacesHandler,
+        mUserPersistence,
+        mOrganizationPersistence,
+        mAuthConfigs,
+        permissionService,
+        Optional.empty());
+    when(permissionService.listPermissions()).thenReturn(
+        Stream.generate(UUID::randomUUID)
+            .map(userId -> new Permission().withUserId(userId).withPermissionType(Permission.PermissionType.ORGANIZATION_EDITOR))
+            .limit(MAX_EDITORS + 10).toList());
+    assertEquals(handler.currentLicenseStatus(), LicenseStatus.EXCEEDED);
+  }
+
   private void stubGetDefaultUser() throws IOException {
     when(mUserPersistence.getDefaultUser()).thenReturn(
         Optional.of(new AuthenticatedUser()
@@ -317,7 +384,8 @@ private InstanceConfigurationHandler getInstanceConfigurationHandler(final boole
         mUserPersistence,
         mOrganizationPersistence,
         mAuthConfigs,
-        permissionService);
+        permissionService,
+        Optional.empty());
   }
 
 }