<bug>[sblk]: fix vg being re created

kvmagent/kvmagent/plugins/shared_block_plugin.py

@@ -444,10 +444,10 @@ def get_disk_paths(disks):
 
         return diskPaths
 
-    def create_vg_if_not_found(self, vgUuid, disks, hostUuid, allDisks, forceWipe=False):
+    def create_vg_if_not_found(self, vgUuid, disks, hostUuid, allDisks, forceWipe=False, is_first_create_vg=False):
         # type: (str, set([CheckDisk]), str, set([CheckDisk]), bool) -> bool
         @linux.retry(times=5, sleep_time=random.uniform(0.1, 3))
-        def find_vg(vgUuid, raise_exception = True):
+        def find_vg(vgUuid, raise_exception=True):
             cmd = shell.ShellCmd("timeout 5 vgscan --ignorelockingfailure; vgs --nolocking -t %s -otags | grep %s" % (vgUuid, INIT_TAG))
             cmd(is_exception=False)
             if cmd.return_code != 0 and raise_exception:
@@ -457,14 +457,17 @@ def find_vg(vgUuid, raise_exception = True):
             return True
 
         @linux.retry(times=3, sleep_time=random.uniform(0.1, 3))
-        def create_vg(hostUuid, vgUuid, diskPaths, raise_excption = True):
+        def create_vg(hostUuid, vgUuid, diskPaths, raise_exception=True):
+            if not is_first_create_vg:
+                raise Exception("vg %s has already been created before, and there may be a risk of data loss during "
+                                "secondary creation. Please check your storage" % vgUuid)
             cmd = shell.ShellCmd("vgcreate -qq --shared --addtag '%s::%s::%s::%s' --metadatasize %s %s %s" %
                                  (INIT_TAG, hostUuid, time.time(), linux.get_hostname(),
                                   DEFAULT_VG_METADATA_SIZE, vgUuid, " ".join(diskPaths)))
             cmd(is_exception=False)
             logger.debug("created vg %s, ret: %s, stdout: %s, stderr: %s" %
                          (vgUuid, cmd.return_code, cmd.stdout, cmd.stderr))
-            if cmd.return_code != 0 and raise_excption:
+            if cmd.return_code != 0 and raise_exception:
                 raise RetryException("ret: %s, stdout: %s, stderr: %s" %
                                 (cmd.return_code, cmd.stdout, cmd.stderr))
             elif cmd.return_code != 0:
@@ -640,7 +643,7 @@ def config_lvm(host_id, enableLvmetad=False):
 
         lvm.start_lvmlockd(cmd.ioTimeout)
         logger.debug("find/create vg %s lock..." % cmd.vgUuid)
-        rsp.isFirst = self.create_vg_if_not_found(cmd.vgUuid, disks, cmd.hostUuid, allDisks, cmd.forceWipe)
+        rsp.isFirst = self.create_vg_if_not_found(cmd.vgUuid, disks, cmd.hostUuid, allDisks, cmd.forceWipe, cmd.isFirst)
 
 #       sanlock table:
 #       

kvmagent/kvmagent/test/shareblock_testsuite/shared_block_plugin_teststub.py

@@ -16,14 +16,15 @@ def __init__(self):
     def disconnect(self, vgUuid, hostUuid):
         return sharedblock_utils.shareblock_disconnect(vgUuid=vgUuid,hostUuid=hostUuid)
 
-    def connect(self, sharedBlockUuids, allSharedBlockUuids, vgUuid, hostUuid, hostId, forceWipe=False):
+    def connect(self, sharedBlockUuids, allSharedBlockUuids, vgUuid, hostUuid, hostId, forceWipe=False, isFirst=True):
         return sharedblock_utils.shareblock_connect(
             sharedBlockUuids=sharedBlockUuids,
             allSharedBlockUuids=allSharedBlockUuids,
             vgUuid=vgUuid,
             hostId=hostId,
             hostUuid=hostUuid,
-            forceWipe=forceWipe
+            forceWipe=forceWipe,
+            isFirst=isFirst
         )
 
     def logout(self, vgUuid, hostUuid):

kvmagent/kvmagent/test/shareblock_testsuite/test_shareblock_connect.py

@@ -1,8 +1,9 @@
+import os.path
 import random
 
 from kvmagent.test.shareblock_testsuite.shared_block_plugin_teststub import SharedBlockPluginTestStub
 from kvmagent.test.utils import sharedblock_utils,pytest_utils,storage_device_utils
-from zstacklib.utils import bash
+from zstacklib.utils import bash,lvm
 from unittest import TestCase
 from zstacklib.test.utils import misc,env
 import concurrent.futures
@@ -50,4 +51,19 @@ def test_sharedblock_connect(self):
                 to_do.append(future)
 
             for future in concurrent.futures.as_completed(to_do):
-                self.assertEqual(future.result().success, True, future.result().error)
+                if not future.result().success:
+                    self.assertEqual("other thread is connecting now" in future.result().error, True, future.result().error)
+
+        r, o ,e = bash.bash_roe("vgchange --lockstop %s" % vgUuid)
+        self.assertEqual(0, r, e)
+
+        r, o = bash.bash_ro(" pvs -oname --noheading -Svg_name=%s" % vgUuid)
+        disk = o.strip().splitlines()[0].strip()
+        bash.bash_roe("wipefs -af %s" % disk)
+        r = bash.bash_r("vgs | grep %s" % vgUuid)
+        self.assertNotEqual(0, r)
+
+        rsp = self.connect([blockUuid], [blockUuid], vgUuid, hostUuid, hostId, forceWipe=True, isFirst=False)
+        self.assertEqual(False, rsp.success, rsp.error)
+        r = bash.bash_r("vgs | grep %s" % vgUuid)
+        self.assertNotEqual(0, r)

kvmagent/kvmagent/test/utils/sharedblock_utils.py

@@ -20,15 +20,16 @@ def sharedblock_ping(vgUuid):
     }))
 
 @misc.return_jsonobject()
-def shareblock_connect(sharedBlockUuids=None, allSharedBlockUuids=None, vgUuid=None,hostId=None,hostUuid=None, forceWipe=True):
+def shareblock_connect(sharedBlockUuids=None, allSharedBlockUuids=None, vgUuid=None,hostId=None,hostUuid=None, forceWipe=True, isFirst=True):
     return get_sharedblock_plugin().connect(misc.make_a_request({
         "sharedBlockUuids":sharedBlockUuids, # [], ls /dev/disk/by-id -l|grep scsi
         "allSharedBlockUuids":allSharedBlockUuids,
         "vgUuid": vgUuid ,# random uuid
         "hostId":hostId,
         "hostUuid": hostUuid,
         "forceWipe": forceWipe,
-        "primaryStorageUuid":vgUuid
+        "primaryStorageUuid":vgUuid,
+        "isFirst":isFirst
     }))
 
 @misc.return_jsonobject()