MB-66724 Rename Columnar versions to Enterprise Analytics

lubomarinski · lubomarinski · commit 8b7ce2d68448 · 2025-05-15T15:05:58.000Z
Change-Id: Ie1aac1a71bf22967206bfd4d639e440dbe66b740 Reviewed-on: https://review.couchbase.org/c/couchbase-cli/+/227834 Tested-by: Build Bot <build@couchbase.com> Reviewed-by: Matt Hall <matt.hall@couchbase.com>
diff --git a/CMakeLists.txt b/CMakeLists.txt
@@ -2,7 +2,7 @@ PROJECT(CouchbaseClient)
 CMAKE_MINIMUM_REQUIRED(VERSION 3.13)
 
 IF (BUILD_COLUMNAR)
-  SET (_cli_version "${COLUMNAR_PRODUCT_VERSION}-columnar")
+  SET (_cli_version "${COLUMNAR_PRODUCT_VERSION}-enterprise-analytics")
 ELSE ()
   SET (_cli_version "${PRODUCT_VERSION}")
 ENDIF ()
diff --git a/cbmgr.py b/cbmgr.py
@@ -177,18 +177,18 @@ def force_communicate_tls(rest: ClusterManager) -> bool:
 
 
 def rest_initialiser(cluster_init_check=False, version_check=False, enterprise_check=None, credentials_required=True,
-                     columnar_check=None):
+                     enterprise_analytics_check=None):
     """rest_initialiser is a decorator that does common subcommand tasks.
 
     The decorator will always creates a cluster manager and assign it to the subcommand variable rest
     :param cluster_init_check: if true it will check if the cluster is initialized before executing the subcommand
     :param version_check: if true it will check if the cluster and CLI version match if they do not it prints a warning
     :param enterprise_check: if true it will check if the cluster is enterprise and fail if not. If it is false it does
-        the check but it does not fail if not enterprise. If none it does not perform the check. The result of the check
-        is stored on the instance parameter enterprise
-    :param columnar_check: if true it will check if the cluster supports columnar and fail if not. If it is false it does
-        the check but it does not fail if not columnar. If none it does not perform the check. The result of the check
-        is stored on the instance parameter columnar
+        the check but it does not fail if not enterprise. If none it does not perform the check. The result of the
+        check is stored on the instance parameter enterprise
+    :param enterprise_analytics_check: if true it will check if the cluster supports Enterprise Analytics and fail if
+        not. If it is false it does the check but it does not fail if not Enterprise Analytics. If none it does not
+        perform the check. The result of the check is stored on the instance parameter enterprise_analytics
     """
     def inner(fn):
         def decorator(self, opts):
@@ -208,21 +208,21 @@ def decorator(self, opts):
                 check_cluster_initialized(self.rest)
             if version_check:
                 check_versions(self.rest)
-            if enterprise_check is not None or columnar_check is not None:
-                # check columnar when we check enterprise to avoid a duplicate fetch on pools
-                enterprise, columnar, errors = self.rest.is_enterprise_columnar()
+            if enterprise_check is not None or enterprise_analytics_check is not None:
+                # check Enterprise Analytics when we check enterprise to avoid a duplicate fetch on pools
+                enterprise, enterprise_analytics, errors = self.rest.get_cluster_type()
                 _exit_if_errors(errors)
 
                 if enterprise_check and not enterprise:
                     _exit_if_errors(['Command only available in enterprise edition'])
 
-                if columnar_check and not columnar:
-                    _exit_if_errors(['Command only available for columnar'])
+                if enterprise_analytics_check and not enterprise_analytics:
+                    _exit_if_errors(['Command only available for Enterprise Analytics'])
 
                 if enterprise_check is not None:
                     self.enterprise = enterprise
-                if columnar_check is not None:
-                    self.columnar = columnar
+                if enterprise_analytics_check is not None:
+                    self.enterprise_analytics = enterprise_analytics
 
             return fn(self, opts)
         return decorator
@@ -324,13 +324,13 @@ def index_storage_mode_to_param(value, default="plasma"):
     return value
 
 
-def process_services(services, enterprise, columnar, cluster_version="0.0.0"):
+def process_services(services, enterprise, enterprise_analytics, cluster_version="0.0.0"):
     """Converts services to a format Couchbase understands"""
-    if not services and not columnar:
+    if not services and not enterprise_analytics:
         services = "data"
-    elif services and columnar:
-        return None, ["--services cannot be specified on Columnar"]
-    elif columnar:
+    elif services and enterprise_analytics:
+        return None, ["--services cannot be specified on Enterprise Analytics"]
+    elif enterprise_analytics:
         return None, None
 
     sep = ","
@@ -763,7 +763,7 @@ def __init__(self, deprecate_username=False, deprecate_password=False, cluster_d
         # Filled by the decorators
         self.rest = None
         self.enterprise = None
-        self.columnar = None
+        self.enterprise_analytics = None
 
         self.parser = CliParser(formatter_class=CLIHelpFormatter, add_help=False, allow_abbrev=False)
         group = self.parser.add_argument_group("Cluster options")
@@ -911,7 +911,7 @@ def __init__(self):
         group.add_argument("--node-to-node-encryption", dest="encryption", metavar="<on|off>", default="off",
                            choices=["on", "off"], help="Enable node to node encryption")
 
-    @rest_initialiser(enterprise_check=False, columnar_check=False)
+    @rest_initialiser(enterprise_check=False, enterprise_analytics_check=False)
     def execute(self, opts):
         initialized, errors = self.rest.is_cluster_initialized()
         _exit_if_errors(errors)
@@ -921,13 +921,13 @@ def execute(self, opts):
         if not self.enterprise and opts.index_storage_mode == 'memopt':
             _exit_if_errors(["memopt option for --index-storage-setting can only be configured on enterprise edition"])
 
-        if not self.columnar and opts.services and "manager-only" in opts.services:
+        if not self.enterprise_analytics and opts.services and "manager-only" in opts.services:
             _exit_if_errors(["Cannot initialize cluster with the manager only service"])
 
-        services, errors = process_services(opts.services, self.enterprise, self.columnar)
+        services, errors = process_services(opts.services, self.enterprise, self.enterprise_analytics)
         _exit_if_errors(errors)
 
-        if not self.columnar and 'kv' not in services.split(','):
+        if not self.enterprise_analytics and 'kv' not in services.split(','):
             _exit_if_errors(["Cannot set up first cluster node without the data service"])
 
         if 'ipv4' in opts.ip_family:
@@ -936,7 +936,7 @@ def execute(self, opts):
             ip_family = 'ipv6'
         ip_only = True if 'only' in opts.ip_family else False
 
-        if not self.columnar and not opts.index_storage_mode and 'index' in services.split(','):
+        if not self.enterprise_analytics and not opts.index_storage_mode and 'index' in services.split(','):
             opts.index_storage_mode = "default"
 
         default = "plasma"
@@ -951,7 +951,7 @@ def execute(self, opts):
         _exit_if_errors(errors)
 
         versionCheck = compare_versions(min_version, "7.2.3")
-        if not self.columnar and versionCheck == -1:
+        if not self.enterprise_analytics and versionCheck == -1:
             _exit_if_errors(["--cluster-init can only be used against >= 7.2.3 clusters"])
 
         if not self.enterprise and opts.notifications == "0":
@@ -2489,7 +2489,8 @@ def __init__(self):
         group.add_argument("--index-storage-setting", dest="index_storage_mode", metavar="<mode>",
                            choices=["default", "memopt"], help="The index storage mode")
 
-    @rest_initialiser(cluster_init_check=True, version_check=True, enterprise_check=False, columnar_check=False)
+    @rest_initialiser(cluster_init_check=True, version_check=True,
+                      enterprise_check=False, enterprise_analytics_check=False)
     def execute(self, opts):
         if opts.use_client_cert:
             if opts.server_username is not None or opts.server_password is not None:
@@ -2505,13 +2506,14 @@ def execute(self, opts):
         min_version, error = self.rest.min_version()
         _exit_if_errors(error)
 
-        opts.services, errors = process_services(opts.services, self.enterprise, self.columnar, min_version)
+        opts.services, errors = process_services(opts.services, self.enterprise, self.enterprise_analytics, min_version)
         _exit_if_errors(errors)
 
         settings, errors = self.rest.index_settings()
         _exit_if_errors(errors)
 
-        if not self.columnar and opts.index_storage_mode is None and settings['storageMode'] == "" and "index" in opts.services:
+        if not self.enterprise_analytics and opts.index_storage_mode is None and settings[
+                'storageMode'] == "" and "index" in opts.services:
             opts.index_storage_mode = "default"
 
         # For supporting the default index backend changing from forestdb to plasma in Couchbase 5.0
@@ -4077,7 +4079,7 @@ def execute(self, opts):
         _exit_if_errors(errors)
 
         versionCheck = compare_versions(min_version, "7.2.3")
-        if not self.enterprise and not self.columnar and versionCheck != -1:
+        if not self.enterprise and not self.enterprise_analytics and versionCheck != -1:
             _exit_if_errors(["Modifying notifications settings is an Enterprise Edition only feature"])
 
         enabled = None
@@ -5670,7 +5672,7 @@ def __init__(self):
         ld_group.add_argument("--link-details-path", dest="link_details_path", metavar="<path>",
                               help="The path to the link details JSON file")
 
-    @rest_initialiser(cluster_init_check=True, version_check=True, columnar_check=True)
+    @rest_initialiser(cluster_init_check=True, version_check=True, enterprise_analytics_check=True)
     def execute(self, opts):
         if opts.create or opts.edit:
             self._set(opts)
diff --git a/cluster_manager.py b/cluster_manager.py
@@ -262,16 +262,18 @@ def is_cluster_initialized(self):
             return True, None
         return False, errors
 
-    def is_enterprise_columnar(self):
+    def get_cluster_type(self):
         """
-        Returns a tuple of (isEnterprise, isColumnar, errors)
+        Returns a tuple of (isEnterprise, isEnterpriseAnalytics, errors)
         """
         data, errors = self.pools()
         if errors:
             return None, None, errors
 
-        # If isColumnar isn't present, then it must be a <8.0 non-Columnar cluster (MB-65393)
-        return data["isEnterprise"], data.get("isColumnar", False), None
+        isEnterprise = data["isEnterprise"]
+        isEnterpriseAnalytics = "prodName" in data and data["prodName"] == "Enterprise Analytics"
+
+        return isEnterprise, isEnterpriseAnalytics, None
 
     def get_hostnames_for_service(self, service_name):
         """ Gets all hostnames that run a service
diff --git a/test/mock_server.py b/test/mock_server.py
@@ -261,15 +261,15 @@ def get_pools(rest_params=None, server_args=None, path="", endpoint_match=None):
 
     is_admin = True
     enterprise = True
-    columnar = False
+    enterprise_analytics = False
     version = '0.0.0-0000-enterprise'
     init = True
     if 'enterprise' in server_args:
         enterprise = server_args['enterprise']
-    if 'columnar' in server_args:
-        columnar = server_args['columnar']
-        if columnar:
-            version = '0.0.0-0000-columnar'
+    if 'enterprise_analytics' in server_args:
+        enterprise_analytics = server_args['enterprise_analytics']
+        if enterprise_analytics:
+            version = '0.0.0-0000-enterprise-analytics'
     if 'is_admin' in server_args:
         is_admin = server_args['is_admin']
     if "version" in server_args:
@@ -283,14 +283,15 @@ def get_pools(rest_params=None, server_args=None, path="", endpoint_match=None):
                      'pools': [{'streamingUri': '/poolsStreaming/default?uuid=5f8b140987f4e46c950e3fa82e7fcb48',
                                 'name': 'default', 'uri': '/pools/default?uuid=5f8b140987f4e46c950e3fa82e7fcb48'}],
                      'isEnterprise': enterprise,
-                     'isColumnar': columnar,
+                     'prodName': "Enterprise Analytics" if enterprise_analytics else None,
                      'componentsVersion': {'kernel': '2.16.4', 'ale': version, 'ssl': '5.3.3',
                                            'os_mon': '2.2.14', 'stdlib': '1.19.4', 'inets': '5.9.8',
                                            'public_key': '0.21', 'ns_server': version, 'crypto': '3.2', 'asn1': '2.0.4',
                                            'lhttpc': '1.3.0', 'sasl': '2.3.4'}, 'implementationVersion': version,
                      'isAdminCreds': is_admin, 'isROAdminCreds': False}
 
-    response_no_init = {'uuid': [], 'settings': [], 'pools': [], 'isEnterprise': enterprise, 'isColumnar': columnar,
+    response_no_init = {'uuid': [], 'settings': [], 'pools': [], 'isEnterprise': enterprise,
+                        'prodName': "Enterprise Analytics" if enterprise_analytics else None,
                         'componentsVersion': {'kernel': '5.4.3.2', 'ale': version, 'ssl': '8.2.6.2', 'os_mon': '2.4.4',
                                               'stdlib': '3.4.5', 'inets': '6.5.2.4', 'public_key': '1.5.2',
                                               'ns_server': version, 'crypto': '4.2.2.2', 'asn1': '5.0.5.1',
diff --git a/test/test_cbmgr.py b/test/test_cbmgr.py
@@ -25,30 +25,30 @@ def test_process_services(self):
                 "error": ["The manager only service can only be used with >= 7.6.0 clusters"],
                 "cluster_version": "7.2.0"
             },
-            "ColumnarDataService": {
+            "EnterpriseAnalyticsDataService": {
                 "service": "data",
                 "expected": None,
-                "columnar": True,
-                "error": ["--services cannot be specified on Columnar"]
+                "enterprise_analytics": True,
+                "error": ["--services cannot be specified on Enterprise Analytics"]
             },
-            "ColumnarManagerOnly": {
+            "EnterpriseAnalyticsManagerOnly": {
                 "service": "manager-only",
                 "expected": None,
-                "columnar": True,
-                "error": ["--services cannot be specified on Columnar"]
+                "enterprise_analytics": True,
+                "error": ["--services cannot be specified on Enterprise Analytics"]
             },
-            "ColumnarBlankService": {
+            "EnterpriseAnalyticsBlankService": {
                 "service": "",
                 "expected": None,
-                "columnar": True
+                "enterprise_analytics": True
             },
         }
 
         for name, test in tests.items():
             with self.subTest(name):
                 cluster_version = test.setdefault("cluster_version", "7.6.0")
-                columnar = test.setdefault("columnar", False)
-                services, err = process_services(test["service"], True, columnar, cluster_version)
+                enterprise_analytics = test.setdefault("enterprise_analytics", False)
+                services, err = process_services(test["service"], True, enterprise_analytics, cluster_version)
                 self.assertEqual(err, test.setdefault("error", None))
                 self.assertEqual(services, test["expected"])
 
diff --git a/test/test_cli.py b/test/test_cli.py
diff --git a/test/test_cluster_manager.py b/test/test_cluster_manager.py
