Update Curl calls to use full index names for FTS

Change-Id: I4b895ade31453b5400e91fb05d275778cb8d1811
Reviewed-on: https://review.couchbase.org/c/testrunner/+/244277
Tested-by: <dananjay.s@couchbase.com>
Reviewed-by: Balakumaran G <balakumaran.gopal@couchbase.com>

Author: dananjay-s

lib/membase/api/on_prem_rest_client.py

@@ -4127,7 +4127,7 @@ def load_synonym_source(self,bucket="default",scope="_default",collection="_defa
         return status, json_parsed
 
     def create_fts_index(self, index_name, params, bucket="_default", scope="_default",mode =None):
-        """create or edit fts index , returns {"status":"ok"} on success"""
+        """create or edit fts index , returns (status, full_index_name) on success"""
         api = self.fts_baseUrl + "api/index/{0}".format(index_name)
         if self.is_elixir:
             if scope is None:
@@ -4139,10 +4139,18 @@ def create_fts_index(self, index_name, params, bucket="_default", scope="_defaul
             return status, content
 
         if status:
-            log.info("Index {0} created".format(index_name))
+            full_name = index_name
+            try:
+                response = json.loads(content)
+                if 'name' in response:
+                    full_name = response['name']
+                    log.info("Index created with full name: {0}".format(full_name))
+            except (json.JSONDecodeError, TypeError, ValueError):
+                pass
+            log.info("Index {0} created".format(full_name))
+            return status, full_name
         else:
             raise Exception("Error creating index: {0}".format(content))
-        return status
 
     def update_fts_index(self, index_name, index_def, bucket="_default", scope="_default",mode=None):
         api = self.fts_baseUrl + "api/index/{0}".format(index_name)

pytests/fts/fts_base.py

@@ -1320,18 +1320,40 @@ def get_rank_of_doc_in_search_results(self, content, doc_id):
             self.__log.info("Doc ID %s not found in search results." % doc_id)
             return -1
 
+    def _build_full_index_name(self):
+        """Construct the fully-prefixed index name (bucket.scope.name) for global endpoint."""
+        if self._source_name and self.index_type != "fulltext-alias":
+            scope = self.scope if self.scope else "_default"
+            return "{0}.{1}.{2}".format(self._source_name, scope, self.name)
+        return self.name
+
+    def _update_index_name(self, full_name):
+        """Update index name to the server-assigned full name if it differs."""
+        if full_name and full_name != self.name and not self.is_elixir:
+            self.__log.info("Index name updated from '{0}' to '{1}'".format(
+                self.name, full_name))
+            self.name = full_name
+            self.index_definition['name'] = full_name
+
     def create(self, rest=None):
         self.__log.info("Checking if index already exists ...")
         if not rest:
             rest = RestConnection(self.__cluster.get_random_fts_node())
         status, _ = rest.get_fts_index_definition(self.name, self._source_name, self.scope)
         if status != 400:
             rest.delete_fts_index(self.name, self._source_name, self.scope)
+        else:
+            full_name = self._build_full_index_name()
+            if full_name != self.name:
+                status, _ = rest.get_fts_index_definition(full_name, self._source_name, self.scope)
+                if status != 400:
+                    rest.delete_fts_index(full_name, self._source_name, self.scope)
         self.__log.info("Creating {0} {1} on {2}".format(
             self.index_type,
             self.name,
             rest.ip))
-        rest.create_fts_index(self.name, self.index_definition, self._source_name, self.scope)
+        _, full_name = rest.create_fts_index(self.name, self.index_definition, self._source_name, self.scope)
+        self._update_index_name(full_name)
         self.__cluster.get_indexes().append(self)
         self.uuid = self.get_uuid()
         global_vars.system_event_logs.add_event(SearchServiceEvents.index_created(rest.ip, self.uuid,
@@ -1344,7 +1366,8 @@ def create_no_check(self, rest=None):
             self.index_type,
             self.name,
             rest.ip))
-        rest.create_fts_index(self.name, self.index_definition, self._source_name, self.scope)
+        _, full_name = rest.create_fts_index(self.name, self.index_definition, self._source_name, self.scope)
+        self._update_index_name(full_name)
         self.__cluster.get_indexes().append(self)
 
     def update(self, rest=None):
@@ -3238,15 +3261,15 @@ def create_fts_index_wait_for_completion(self, sample_index_name_1, sample_bucke
         return fts_idx
 
     def get_fts_index_by_name(self, name):
-        """ Returns an FTSIndex object with the given name """
+        """ Returns an FTSIndex object with the given name (supports both short and full prefixed names) """
         for index in self.__indexes:
-            if index.name == name:
+            if index.name == name or index.name.endswith('.' + name):
                 return index
 
     def delete_fts_index(self, name):
-        """ Delete an FTSIndex object with the given name from a given node """
+        """ Delete an FTSIndex object with the given name from a given node (supports both short and full prefixed names) """
         for index in self.__indexes.copy():
-            if index.name == name:
+            if index.name == name or index.name.endswith('.' + name):
                 index.delete()
 
     def delete_all_fts_indexes(self):

pytests/fts/fts_callable.py

@@ -368,9 +368,9 @@ def create_alias(self, target_indexes, name=None, alias_def=None, bucket=None, s
                                                 scope=scope)
 
     def delete_fts_index(self, name):
-        """ Delete an FTSIndex object with the given name from a given node """
+        """ Delete an FTSIndex object with the given name from a given node (supports both short and full prefixed names) """
         for index in self.fts_indexes:
-            if index.name == name:
+            if index.name == name or index.name.endswith('.' + name):
                 index.delete()
 
     def delete_all(self):
@@ -642,9 +642,15 @@ def check_if_index_exists(self, index_name, bucket_name=None, scope_name=None, i
             Returns true / false if index exists
             Returns index's node and server group distribution if required -> node_def = True
             Returns index definition if required -> index_def = True
+            Tries both the short name and the fully-prefixed name (bucket.scope.name).
         """
         rest = RestConnection(self.cb_cluster.get_random_fts_node())
         resp = rest.get_fts_index_definition(index_name, bucket_name, scope_name)
+        if not resp[0] and bucket_name:
+            scope = scope_name if scope_name else "_default"
+            full_name = "{0}.{1}.{2}".format(bucket_name, scope, index_name)
+            if full_name != index_name:
+                resp = rest.get_fts_index_definition(full_name, bucket_name, scope_name)
         if resp[0]:
             if node_def:
                 return resp[1]['planPIndexes'][0]['nodes']

pytests/fts/rbac_fts.py

@@ -115,7 +115,7 @@ def delete_index_with_no_credentials(self):
         rest = self.get_rest_handle_for_credentials("Administrator", "password")
         index.create(rest)
 
-        api = "http://{0}:8094/api/index/travel".format(server.ip)
+        api = "http://{0}:8094/api/index/{1}".format(server.ip, index.name)
         response, content = httplib2.Http(timeout=120).request(api,
                                                               "DELETE",
                                                               headers=None)
@@ -139,7 +139,7 @@ def get_index_with_no_credentials(self):
         rest = self.get_rest_handle_for_credentials("Administrator", "password")
         index.create(rest)
 
-        api = "http://{0}:8094/api/index/travel".format(server.ip)
+        api = "http://{0}:8094/api/index/{1}".format(server.ip, index.name)
         response, content = httplib2.Http(timeout=120).request(api,
                                                                "GET",
                                                                headers=None)
@@ -164,7 +164,7 @@ def query_index_with_no_credentials(self):
         index.create(rest)
         self.wait_for_indexing_complete()
 
-        api = "http://{0}:8094/api/index/travel/query?".format(server.ip)
+        api = "http://{0}:8094/api/index/{1}/query?".format(server.ip, index.name)
         query = {"match": "Wick", "field": "city"}
         import urllib.request, urllib.parse, urllib.error
         api = api + urllib.parse.urlencode(query)

pytests/fts/stable_topology_fts.py

@@ -2833,12 +2833,14 @@ def test_ssl(self):
 
         self.log.info("Running command : {0}".format(cmd))
         output = subprocess.check_output(cmd, shell=True)
-        if json.loads(output)["status"] == "ok":
+        create_response = json.loads(output)
+        if create_response["status"] == "ok":
+            full_index_name = create_response.get("name", "default_idx")
             query = "curl -g -k " + \
                     "-XPOST -H \"Content-Type: application/json\" " + \
                     "-u Administrator:password " + \
-                    "https://{0}:18094/api/index/default_idx/query -d ". \
-                        format(fts_node.ip, fts_ssl_port) + \
+                    "https://{0}:18094/api/index/{1}/query -d ". \
+                        format(fts_node.ip, full_index_name) + \
                     "\'{0}\'".format(json.dumps(qry))
             self.sleep(20, "wait for indexing to complete")
             output = subprocess.check_output(query, shell=True)

pytests/logredaction/log_redaction_tests.py

@@ -585,14 +585,14 @@ def test_fts_log_redaction(self):
                                               password='password')
                 rest.create_bucket(bucket="default", ramQuotaMB=256)
                 self.sleep(15)
-        status = rest.create_fts_index("index1", index_definition)
+        status, full_index_name = rest.create_fts_index("index1", index_definition)
         if status:
-            log.info("Index 'index1' created")
+            log.info("Index '{0}' created".format(full_index_name))
         else:
             log.info("Error creating index, status = {0}".format(status))
         self.sleep(60, "waiting for docs to get indexed")
         query_json = {"query": {"field": "type", "match": "emp"}}
-        hits, _, _, _ = rest.run_fts_query(index_name="index1",
+        hits, _, _, _ = rest.run_fts_query(index_name=full_index_name,
                            query_json=query_json)
         log.info("Hits from query {0}: {1}".format(query_json, hits))
         self.set_redaction_level()

pytests/security/x509tests.py

@@ -1006,21 +1006,25 @@ def check_fts_service(self, host):
         else:
             output = x509main()._execute_command_clientcert(host.ip, url='/api/index/default_idx', port=18094, headers=" -XPUT -H \"Content-Type: application/json\" -u Administrator:password ",
                                                             client_cert=False, curl=True, verb='GET', data="'" + json.dumps(idx) + "'")
-        self.assertEqual(json.loads(output)['status'], "ok", "Issue with creating FTS index with client Cert")
+        create_resp = json.loads(output)
+        self.assertEqual(create_resp['status'], "ok", "Issue with creating FTS index with client Cert")
+        full_idx_name = create_resp.get('name', 'default_idx')
 
         output = x509main()._execute_command_clientcert(host.ip, url='/api/index/default_idx01', port=self.fts_port, headers=" -XPUT -H \"Content-Type: application/json\" -u Administrator:password ",
                                                         client_cert=False, curl=True, verb='GET', data="'" + json.dumps(idx) + "'", plain_curl=True)
-        self.assertEqual(json.loads(output)['status'], "ok", "Issue with creating FTS index with client Cert")
+        create_resp_01 = json.loads(output)
+        self.assertEqual(create_resp_01['status'], "ok", "Issue with creating FTS index with client Cert")
+        full_idx01_name = create_resp_01.get('name', 'default_idx01')
 
         if self.client_cert_state == 'enable':
-            output = x509main()._execute_command_clientcert(host.ip, url='/api/index/default_idx', port=18094, headers=" -H \"Content-Type: application/json\" ",
+            output = x509main()._execute_command_clientcert(host.ip, url='/api/index/{0}'.format(full_idx_name), port=18094, headers=" -H \"Content-Type: application/json\" ",
                                                             client_cert=True, curl=True, verb='DELETE')
         else:
-            output = x509main()._execute_command_clientcert(host.ip, url='/api/index/default_idx', port=18094, headers=" -H \"Content-Type: application/json\" -u Administrator:password ",
+            output = x509main()._execute_command_clientcert(host.ip, url='/api/index/{0}'.format(full_idx_name), port=18094, headers=" -H \"Content-Type: application/json\" -u Administrator:password ",
                                                             client_cert=False, curl=True, verb='DELETE')
         self.assertEqual(json.loads(output)['status'], "ok", "Issue with deleteing FTS index with client Cert")
 
-        output = x509main()._execute_command_clientcert(host.ip, url='/api/index/default_idx01', port=self.fts_port, headers=" -H \"Content-Type: application/json\" -u Administrator:password ",
+        output = x509main()._execute_command_clientcert(host.ip, url='/api/index/{0}'.format(full_idx01_name), port=self.fts_port, headers=" -H \"Content-Type: application/json\" -u Administrator:password ",
                                                         client_cert=False, curl=True, verb='DELETE', plain_curl=True)
         self.assertEqual(json.loads(output)['status'], "ok", "Issue with deleteing FTS index on 8094")