修正：1. 删除VPC导致hostwire数据不一致问题 2. 阿里云主机无操作系统信息

3. 其他一些BUGfix

pkg/compute/models/cloudproviders.go

@@ -123,10 +123,21 @@ func (self *SCloudprovider) PostCreate(ctx context.Context, userCred mcclient.To
 }
 
 func (self *SCloudprovider) savePassword(secret string) error {
-	sec, err := utils.EncryptAESBase64(self.Id, self.Secret)
+	sec, err := utils.EncryptAESBase64(self.Id, secret)
 	if err != nil {
 		return err
 	}
+
+	/*log.Debugf("savePassword %s => %s", secret, sec)
+	newsec, err := utils.DescryptAESBase64(self.Id, sec)
+	if err != nil {
+		return err
+	}
+	if newsec != secret {
+		log.Errorf("Encrypt/Descrypt mismatch!!")
+		return fmt.Errorf("Encrypt/Descrypt mismatch!!")
+	}*/
+
 	_, err = self.GetModelManager().TableSpec().Update(self, func() error {
 		self.Secret = sec
 		return nil
@@ -158,6 +169,89 @@ type SSyncRange struct {
 	Host     []string
 }
 
+func (sr *SSyncRange) NeedSyncInfo() bool {
+	if sr.FullSync {
+		return true
+	}
+	if sr.Region != nil && len(sr.Region) > 0 {
+		return true
+	}
+	if sr.Zone != nil && len(sr.Zone) > 0 {
+		return true
+	}
+	if sr.Host != nil && len(sr.Host) > 0 {
+		return true
+	}
+	return false
+}
+
+func (sr *SSyncRange) normalizeRegionIds() error {
+	for i := 0; i < len(sr.Region); i += 1 {
+		obj, err := CloudregionManager.FetchByIdOrName("", sr.Region[i])
+		if err != nil {
+			if err == sql.ErrNoRows {
+				return httperrors.NewResourceNotFoundError("Region %s not found", sr.Region[i])
+			} else {
+				return err
+			}
+		}
+		sr.Region[i] = obj.GetId()
+	}
+	return nil
+}
+
+func (sr *SSyncRange) normalizeZoneIds() error {
+	for i := 0; i < len(sr.Zone); i += 1 {
+		obj, err := ZoneManager.FetchByIdOrName("", sr.Zone[i])
+		if err != nil {
+			if err == sql.ErrNoRows {
+				return httperrors.NewResourceNotFoundError("Zone %s not found", sr.Zone[i])
+			} else {
+				return err
+			}
+		}
+		sr.Zone[i] = obj.GetId()
+	}
+	return nil
+}
+
+func (sr *SSyncRange) normalizeHostIds() error {
+	for i := 0; i < len(sr.Host); i += 1 {
+		obj, err := HostManager.FetchByIdOrName("", sr.Host[i])
+		if err != nil {
+			if err == sql.ErrNoRows {
+				return httperrors.NewResourceNotFoundError("Host %s not found", sr.Host[i])
+			} else {
+				return err
+			}
+		}
+		sr.Host[i] = obj.GetId()
+	}
+	return nil
+}
+
+func (sr *SSyncRange) Normalize() error {
+	if sr.Region != nil && len(sr.Region) > 0 {
+		err := sr.normalizeRegionIds()
+		if err != nil {
+			return err
+		}
+	}
+	if sr.Zone != nil && len(sr.Zone) > 0 {
+		err := sr.normalizeZoneIds()
+		if err != nil {
+			return err
+		}
+	}
+	if sr.Host != nil && len(sr.Host) > 0 {
+		err := sr.normalizeHostIds()
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
 func (self *SCloudprovider) AllowPerformSync(ctx context.Context, userCred mcclient.TokenCredential, query jsonutils.JSONObject, data jsonutils.JSONObject) bool {
 	return userCred.IsSystemAdmin()
 }
@@ -260,10 +354,13 @@ func (self *SCloudprovider) GetDriver() (cloudprovider.ICloudProvider, error) {
 	if !self.Enabled {
 		return nil, fmt.Errorf("Cloud provider is not enabled")
 	}
+
 	secret, err := self.getPassword()
 	if err != nil {
 		return nil, fmt.Errorf("Invalid password %s", err)
 	}
+	// log.Debugf("XXXXX secret: %s", secret)
+
 	return cloudprovider.GetProvider(self.Id, self.Name, self.AccessUrl, self.Account, secret, self.Provider)
 }
 

pkg/compute/models/hosts.go

@@ -344,8 +344,9 @@ func (self *SHost) RealDelete(ctx context.Context, userCred mcclient.TokenCreden
 	for _, netif := range self.GetNetInterfaces() {
 		netif.Remove(ctx, userCred)
 	}
-	for _, hostwire := range self.GetWires() {
-		hostwire.Delete(ctx, userCred)
+	for _, hostwire := range self.GetHostwires() {
+		hostwire.Detach(ctx, userCred)
+		// hostwire.Delete(ctx, userCred)
 	}
 	return self.SEnabledStatusStandaloneResourceBase.Delete(ctx, userCred)
 }
@@ -572,7 +573,7 @@ func (self *SHost) GetWireCount() int {
 	return self.GetWiresQuery().Count()
 }
 
-func (self *SHost) GetWires() []SHostwire {
+func (self *SHost) GetHostwires() []SHostwire {
 	hw := make([]SHostwire, 0)
 	q := self.GetWiresQuery()
 	err := db.FetchModelObjects(HostwireManager, q, &hw)
@@ -897,7 +898,19 @@ func (manager *SHostManager) newFromCloudHost(extHost cloudprovider.ICloudHost,
 func (self *SHost) SyncHostStorages(ctx context.Context, userCred mcclient.TokenCredential, storages []cloudprovider.ICloudStorage) compare.SyncResult {
 	syncResult := compare.SyncResult{}
 
-	dbStorages := self._getAttachedStorages(tristate.None, tristate.None)
+	dbStorages := make([]SStorage, 0)
+
+	hostStorages := self.GetHoststorages()
+	for i := 0; i < len(hostStorages); i += 1 {
+		storage := hostStorages[i].GetStorage()
+		if storage == nil {
+			hostStorages[i].Delete(ctx, userCred)
+		} else {
+			dbStorages = append(dbStorages, *storage)
+		}
+	}
+
+	// dbStorages := self._getAttachedStorages(tristate.None, tristate.None)
 
 	removed := make([]SStorage, 0)
 	commondb := make([]SStorage, 0)
@@ -980,7 +993,19 @@ func (self *SHost) newCloudHostStorage(ctx context.Context, userCred mcclient.To
 func (self *SHost) SyncHostWires(ctx context.Context, userCred mcclient.TokenCredential, wires []cloudprovider.ICloudWire) compare.SyncResult {
 	syncResult := compare.SyncResult{}
 
-	dbWires := self.getAttachedWires()
+	dbWires := make([]SWire, 0)
+
+	hostWires := self.GetHostwires()
+	for i := 0; i < len(hostWires); i += 1 {
+		wire := hostWires[i].GetWire()
+		if wire == nil {
+			hostWires[i].Delete(ctx, userCred)
+		} else {
+			dbWires = append(dbWires, *wire)
+		}
+	}
+
+	// dbWires := self.getAttachedWires()
 
 	removed := make([]SWire, 0)
 	commondb := make([]SWire, 0)

pkg/compute/models/networks.go

@@ -41,6 +41,7 @@ const (
 	NETWORK_STATUS_PENDING       = "pending"
 	NETWORK_STATUS_AVAILABLE     = "available"
 	NETWORK_STATUS_FAILED        = "failed"
+	NETWORK_STATUS_UNKNOWN       = "unknown"
 	NETWORK_STATUS_START_DELETE  = "start_delete"
 	NETWORK_STATUS_DELETING      = "deleting"
 	NETWORK_STATUS_DELETED       = "deleted"
@@ -413,7 +414,7 @@ func (manager *SNetworkManager) SyncNetworks(ctx context.Context, userCred mccli
 	}
 
 	for i := 0; i < len(removed); i += 1 {
-		err = removed[i].ValidateDeleteCondition(ctx)
+		/*err = removed[i].ValidateDeleteCondition(ctx)
 		if err != nil { // cannot delete
 			syncResult.DeleteError(err)
 		} else {
@@ -423,6 +424,12 @@ func (manager *SNetworkManager) SyncNetworks(ctx context.Context, userCred mccli
 			} else {
 				syncResult.Delete()
 			}
+		}*/
+		err = removed[i].SetStatus(userCred, NETWORK_STATUS_UNKNOWN, "Sync to remove")
+		if err != nil {
+			syncResult.DeleteError(err)
+		} else {
+			syncResult.Delete()
 		}
 	}
 	for i := 0; i < len(commondb); i += 1 {

pkg/compute/models/storagecachedimages.go

@@ -78,7 +78,7 @@ func (manager *SStoragecachedimageManager) AllowListDescendent(ctx context.Conte
 	return userCred.IsSystemAdmin()
 }
 
-func (self *SStoragecachedimage) getCachedimage() *SCachedimage {
+func (self *SStoragecachedimage) GetCachedimage() *SCachedimage {
 	cachedImage, _ := CachedimageManager.FetchById(self.CachedimageId)
 	if cachedImage != nil {
 		return cachedImage.(*SCachedimage)
@@ -86,7 +86,7 @@ func (self *SStoragecachedimage) getCachedimage() *SCachedimage {
 	return nil
 }
 
-func (self *SStoragecachedimage) getStoragecache() *SStoragecache {
+func (self *SStoragecachedimage) GetStoragecache() *SStoragecache {
 	cache, _ := StoragecacheManager.FetchById(self.StoragecacheId)
 	if cache != nil {
 		return cache.(*SStoragecache)
@@ -95,11 +95,11 @@ func (self *SStoragecachedimage) getStoragecache() *SStoragecache {
 }
 
 func (self *SStoragecachedimage) getExtraDetails(extra *jsonutils.JSONDict) *jsonutils.JSONDict {
-	storagecache := self.getStoragecache()
+	storagecache := self.GetStoragecache()
 	if storagecache != nil {
 		extra.Add(jsonutils.NewStringArray(storagecache.getStorageNames()), "storages")
 	}
-	cachedImage := self.getCachedimage()
+	cachedImage := self.GetCachedimage()
 	if cachedImage != nil {
 		extra.Add(jsonutils.NewString(cachedImage.getName()), "image")
 		extra.Add(jsonutils.NewInt(cachedImage.Size), "size")
@@ -158,7 +158,7 @@ func (self *SStoragecachedimage) ValidateDeleteCondition(ctx context.Context) er
 	if !self.isDownloadSessionExpire() {
 		return httperrors.NewResourceBusyError("Active download session not expired")
 	}
-	image := self.getCachedimage()
+	image := self.GetCachedimage()
 	if !image.canDeleteLastCache() {
 		return httperrors.NewResourceBusyError("Cannot delete the last cache")
 	}
@@ -179,8 +179,8 @@ func (self *SStoragecachedimage) markDeleting(ctx context.Context, userCred mccl
 		return err
 	}
 
-	cache := self.getStoragecache()
-	image := self.getCachedimage()
+	cache := self.GetStoragecache()
+	image := self.GetCachedimage()
 
 	lockman.LockJointObject(ctx, cache, image)
 	defer lockman.ReleaseJointObject(ctx, cache, image)

pkg/compute/models/storagecaches.go

@@ -136,7 +136,7 @@ func (self *SStoragecache) getCachedImageSize() int64 {
 	}
 	var size int64 = 0
 	for _, img := range images {
-		imginfo := img.getCachedimage()
+		imginfo := img.GetCachedimage()
 		size += imginfo.Size
 	}
 	return size

pkg/compute/models/vpcs.go

@@ -25,6 +25,7 @@ const (
 	VPC_STATUS_DELETING      = "deleting"
 	VPC_STATUS_DELETE_FAILED = "delete_failed"
 	VPC_STATUS_DELETED       = "deleted"
+	VPC_STATUS_UNKNOWN       = "unknown"
 
 	MAX_VPC_PER_REGION = 3
 )
@@ -189,25 +190,26 @@ func (manager *SVpcManager) SyncVPCs(ctx context.Context, userCred mcclient.Toke
 	}
 
 	for i := 0; i < len(removed); i += 1 {
-		err = removed[i].ValidateDeleteCondition(ctx)
-		if err != nil { // cannot delete
-			_, err = removed[i].PerformDisable(ctx, userCred, nil, nil)
-			if err == nil {
-				err = removed[i].SetStatus(userCred, VPC_STATUS_PENDING, "sync to delete")
-			}
-			if err != nil {
-				syncResult.DeleteError(err)
-			} else {
-				syncResult.Delete()
-			}
-		} else {
-			err = removed[i].Delete(ctx, userCred)
-			if err != nil {
-				syncResult.DeleteError(err)
-			} else {
-				syncResult.Delete()
-			}
+		// err = removed[i].ValidateDeleteCondition(ctx)
+		// if err != nil { // cannot delete
+		removed[i].markAllNetworksUnknown(userCred)
+		_, err = removed[i].PerformDisable(ctx, userCred, nil, nil)
+		if err == nil {
+			err = removed[i].SetStatus(userCred, VPC_STATUS_UNKNOWN, "sync to delete")
 		}
+		if err != nil {
+			syncResult.DeleteError(err)
+		} else {
+			syncResult.Delete()
+		}
+		// } else {
+		// 	err = removed[i].Delete(ctx, userCred)
+		// 	if err != nil {
+		//		syncResult.DeleteError(err)
+		//	} else {
+		//		syncResult.Delete()
+		//	}
+		// }
 	}
 	for i := 0; i < len(commondb); i += 1 {
 		err = commondb[i].SyncWithCloudVpc(commonext[i])
@@ -274,6 +276,17 @@ func (manager *SVpcManager) newFromCloudVpc(extVPC cloudprovider.ICloudVpc, regi
 	return &vpc, nil
 }
 
+func (self *SVpc) markAllNetworksUnknown(userCred mcclient.TokenCredential) error {
+	wires := self.GetWires()
+	if wires == nil || len(wires) == 0 {
+		return nil
+	}
+	for i := 0; i <= len(wires); i += 1 {
+		wires[i].markNetworkUnknown(userCred)
+	}
+	return nil
+}
+
 func (manager *SVpcManager) InitializeData() error {
 	vpcObj, err := manager.FetchById("default")
 	if err != nil {

pkg/compute/models/wires.go

@@ -83,11 +83,25 @@ func (wire *SWire) ValidateDeleteCondition(ctx context.Context) error {
 	return wire.SStandaloneResourceBase.ValidateDeleteCondition(ctx)
 }
 
+func (wire *SWire) getHostwireQuery() *sqlchemy.SQuery {
+	return HostwireManager.Query().Equals("wire_id", wire.Id)
+}
+
 func (wire *SWire) HostCount() int {
-	q := HostwireManager.Query().Equals("wire_id", wire.Id)
+	q := wire.getHostwireQuery()
 	return q.Count()
 }
 
+func (wire *SWire) GetHostwires() ([]SHostwire, error) {
+	q := wire.getHostwireQuery()
+	hostwires := make([]SHostwire, 0)
+	err := db.FetchModelObjects(HostwireManager, q, &hostwires)
+	if err != nil {
+		return nil, err
+	}
+	return hostwires, nil
+}
+
 func (wire *SWire) NetworkCount() int {
 	q := NetworkManager.Query().Equals("wire_id", wire.Id)
 	return q.Count()
@@ -141,7 +155,13 @@ func (manager *SWireManager) SyncWires(ctx context.Context, userCred mcclient.To
 	}
 
 	for i := 0; i < len(removed); i += 1 {
-		err = removed[i].ValidateDeleteCondition(ctx)
+		err = removed[i].markNetworkUnknown(userCred)
+		if err != nil { // cannot delete
+			syncResult.DeleteError(err)
+		} else {
+			syncResult.Delete()
+		}
+		/* err = removed[i].ValidateDeleteCondition(ctx)
 		if err != nil { // cannot delete
 			syncResult.DeleteError(err)
 		} else {
@@ -151,7 +171,7 @@ func (manager *SWireManager) SyncWires(ctx context.Context, userCred mcclient.To
 			} else {
 				syncResult.Delete()
 			}
-		}
+		}*/
 	}
 	for i := 0; i < len(commondb); i += 1 {
 		err = commondb[i].syncWithCloudWire(commonext[i])
@@ -192,6 +212,17 @@ func (self *SWire) syncWithCloudWire(extWire cloudprovider.ICloudWire) error {
 	return err
 }
 
+func (self *SWire) markNetworkUnknown(userCred mcclient.TokenCredential) error {
+	nets, err := self.getNetworks()
+	if err != nil {
+		return err
+	}
+	for i := 0; i < len(nets); i += 1 {
+		nets[i].SetStatus(userCred, NETWORK_STATUS_UNKNOWN, "wire sync to remove")
+	}
+	return nil
+}
+
 func (manager *SWireManager) newFromCloudWire(extWire cloudprovider.ICloudWire, vpc *SVpc) (*SWire, error) {
 	wire := SWire{}
 	wire.SetModelManager(manager)
@@ -303,6 +334,16 @@ func (self *SWire) getNetworkQuery() *sqlchemy.SQuery {
 	return NetworkManager.Query().Equals("wire_id", self.Id)
 }
 
+func (self *SWire) getNetworks() ([]SNetwork, error) {
+	q := self.getNetworkQuery()
+	nets := make([]SNetwork, 0)
+	err := db.FetchModelObjects(NetworkManager, q, &nets)
+	if err != nil {
+		return nil, err
+	}
+	return nets, nil
+}
+
 func (self *SWire) getGatewayNetworkQuery() *sqlchemy.SQuery {
 	q := self.getNetworkQuery()
 	q = q.IsNotNull("guest_gateway").IsNotEmpty("guest_gateway")