fix for operator restore

Change-Id: I5e48bd2737ef38b61749792f73f3515e1cd6c874
Reviewed-on: http://review.couchbase.org/c/perfrunner/+/152492
Tested-by: Build Bot <[email protected]>
Reviewed-by: Korrigan Clark <[email protected]>

Author: korry8911

perfrunner/helpers/rest.py

@@ -1110,3 +1110,9 @@ def get_bucket_info(self, host: str, bucket: str) -> List[str]:
         api = 'http://{}:{}/pools/default/buckets/{}'\
             .format(host, port, bucket)
         return self.get(url=api).json()
+
+    def flush_bucket(self, host: str, bucket: str):
+        logger.info('Flushing bucket: {}'.format(bucket))
+        host, port = self.translate_host_and_port(host, '8091')
+        api = 'http://{}:{}/pools/default/buckets/{}/controller/doFlush'.format(host, port, bucket)
+        self.post(url=api)

perfrunner/remote/kubernetes.py

@@ -26,7 +26,9 @@ def __init__(self, cluster_spec, os):
         self.restore_file = 'restore.yaml'
         self.operator_version = None
 
-    def kubectl(self, params, kube_config, split_lines=True, max_attempts=3):
+    def kubectl(self, params, kube_config=None, split_lines=True, max_attempts=3):
+        if not kube_config:
+            kube_config = self.kube_config_path
         params = params.split()
         if params[0] == 'exec':
             params = params[0:5] + [" ".join(params[5::])]
@@ -668,42 +670,6 @@ def create_restore(self):
         restore_template_path = self.get_restore_template_path()
         self.create_from_file(restore_template_path)
 
-    def wait_for_restore_complete(self):
-        logger.info('waiting for restore')
-        running = False
-        tries = 0
-        while not running and tries < 60:
-            try:
-                running = self.get_restore('my-restore')['status']['running']
-            except Exception:
-                logger.info("restore not started")
-            tries += 1
-            time.sleep(1)
-        if not running:
-            raise Exception('failed to see running restore')
-        logger.info("restore started")
-        tries = 0
-        start = time.time()
-        while tries < 7200:
-            try:
-                self.get_restore('my-restore')
-            except Exception as ex:
-                break
-            tries += 1
-            time.sleep(1)
-        end = time.time()
-        if tries >= 3600:
-            raise Exception('failed complete restore')
-        logger.info("restore finished")
-        return end - start
-
-    def recreate_bucket(self, bucket_name):
-        bucket_path = self.get_bucket_path(bucket_name)
-        self.delete_from_file(bucket_path)
-        time.sleep(60)
-        self.create_from_file("cloud/operator/2/1/{}.yaml".format(bucket_name))
-        time.sleep(60)
-
     def istioctl(self, params, kube_config=None, split_lines=True, max_attempts=1):
         kube_config = kube_config or self.kube_config_path
         params = params.split()

perfrunner/tests/operator.py

@@ -1,7 +1,7 @@
 import datetime
 
 from logger import logger
-from perfrunner.helpers.cbmonitor import with_stats
+from perfrunner.helpers.cbmonitor import timeit, with_stats
 from perfrunner.tests import PerfTest
 
 
@@ -30,9 +30,9 @@ def parse_backup_status(self, backup_status):
         time_elapsed = time_elapsed.total_seconds()
         capacity_used = backup_status['capacityUsed']
         if "Mi" in capacity_used:
-            backup_size = float(backup_status['capacityUsed'].strip("Mi"))/1024
+            backup_size = round(float(backup_status['capacityUsed'].strip("Mi"))/1024, 2)
         if "Gi" in capacity_used:
-            backup_size = float(backup_status['capacityUsed'].strip("Gi"))
+            backup_size = round(float(backup_status['capacityUsed'].strip("Gi")), 2)
         return time_elapsed, backup_size
 
     def _report_kpi(self, time_elapsed, backup_size):
@@ -67,15 +67,18 @@ def run(self):
 class OperatorBackupRestoreTest(OperatorBackupTest):
 
     @with_stats
+    @timeit
     def restore(self):
         logger.info('Running restore')
         self.remote.create_restore()
-        elapsed_time = self.remote.wait_for_restore_complete()
-        return elapsed_time
+        self.check_num_items()
 
-    def recreate_bucket(self):
-        logger.info('Recreating bucket')
-        self.remote.recreate_bucket("bucket-1")
+    def flush_buckets(self):
+        logger.info('Flushing bucket')
+        for i in range(self.test_config.cluster.num_buckets):
+            bucket = 'bucket-{}'.format(i + 1)
+            self.rest.flush_bucket(self.master_node, bucket)
+            self.check_num_items(bucket_items={bucket: 0})
 
     def _report_kpi(self, time_elapsed_backup, time_elapsed_restore, backup_size):
         edition = 'Operator'
@@ -114,6 +117,6 @@ def run(self):
         self.backup()
         backup_status = self.remote.get_backup('my-backup')['status']
         time_elapsed_backup, backup_size = self.parse_backup_status(backup_status)
-        self.recreate_bucket()
+        self.flush_buckets()
         time_elapsed_restore = self.restore()
         self.report_kpi(time_elapsed_backup, time_elapsed_restore, backup_size)