vpcagent: models: join network addresses

pkg/vpcagent/models/models.go

@@ -62,9 +62,10 @@ type Guestnetwork struct {
 	compute_models.SGuestnetwork
 
 	// Guest could be nil for when the guest is pending_deleted
-	Guest     *Guest     `json:"-"`
-	Network   *Network   `json:"-"`
-	Elasticip *Elasticip `json:"-"`
+	Guest     *Guest           `json:"-"`
+	Network   *Network         `json:"-"`
+	Elasticip *Elasticip       `json:"-"`
+	SubIPs    NetworkAddresses `json:"-"`
 }
 
 func (el *Guestnetwork) Copy() *Guestnetwork {
@@ -73,6 +74,19 @@ func (el *Guestnetwork) Copy() *Guestnetwork {
 	}
 }
 
+type NetworkAddress struct {
+	compute_models.SNetworkAddress
+
+	Guestnetwork *Guestnetwork `json:"-"`
+	Network      *Network      `json:"-"`
+}
+
+func (el *NetworkAddress) Copy() *NetworkAddress {
+	return &NetworkAddress{
+		SNetworkAddress: el.SNetworkAddress,
+	}
+}
+
 type Guest struct {
 	compute_models.SGuest
 

pkg/vpcagent/models/modelset.go

@@ -19,6 +19,7 @@ import (
 
 	"yunion.io/x/log"
 
+	computeapis "yunion.io/x/onecloud/pkg/apis/compute"
 	"yunion.io/x/onecloud/pkg/cloudcommon/db"
 	mcclient_modulebase "yunion.io/x/onecloud/pkg/mcclient/modulebase"
 	mcclient_modules "yunion.io/x/onecloud/pkg/mcclient/modules"
@@ -34,6 +35,7 @@ type (
 	SecurityGroups     map[string]*SecurityGroup
 	SecurityGroupRules map[string]*SecurityGroupRule
 	Elasticips         map[string]*Elasticip
+	NetworkAddresses   map[string]*NetworkAddress
 
 	Guestnetworks  map[string]*Guestnetwork  // key: rowId
 	Guestsecgroups map[string]*Guestsecgroup // key: guestId/secgroupId
@@ -300,6 +302,21 @@ func (ms Networks) joinGuestnetworks(subEntries Guestnetworks) bool {
 	return true
 }
 
+func (ms Networks) joinNetworkAddresses(subEntries NetworkAddresses) bool {
+	correct := true
+	for _, subEntry := range subEntries {
+		netId := subEntry.NetworkId
+		m, ok := ms[netId]
+		if !ok {
+			log.Errorf("cannot find network id %s of network address %s", netId, subEntry.Id)
+			correct = false
+			break
+		}
+		subEntry.Network = m
+	}
+	return correct
+}
+
 func (ms Networks) joinElasticips(subEntries Elasticips) bool {
 	for _, m := range ms {
 		m.Elasticips = Elasticips{}
@@ -391,6 +408,56 @@ func (set Guestnetworks) joinElasticips(subEntries Elasticips) bool {
 	return correct
 }
 
+func (set Guestnetworks) joinNetworkAddresses(subEntries NetworkAddresses) bool {
+	correct := true
+	byRowId := map[string]*Guestnetwork{}
+	for _, guestnetwork := range set {
+		rowIdStr := fmt.Sprintf("%d", guestnetwork.RowId)
+		byRowId[rowIdStr] = guestnetwork
+	}
+	for _, subEntry := range subEntries {
+		if subEntry.ParentType != computeapis.NetworkAddressParentTypeGuestnetwork {
+			continue
+		}
+		switch subEntry.Type {
+		case computeapis.NetworkAddressTypeSubIP:
+			parentId := subEntry.ParentId
+			guestnetwork, ok := byRowId[parentId]
+			if !ok {
+				log.Errorf("cannot find guestnetwork row id %s of network address %s", parentId, subEntry.Id)
+				correct = false
+			}
+			if guestnetwork.SubIPs == nil {
+				guestnetwork.SubIPs = NetworkAddresses{}
+			}
+			guestnetwork.SubIPs[subEntry.Id] = subEntry
+			subEntry.Guestnetwork = guestnetwork
+		}
+	}
+	return correct
+}
+
+func (set NetworkAddresses) ModelManager() mcclient_modulebase.IBaseManager {
+	return &mcclient_modules.NetworkAddresses
+}
+
+func (set NetworkAddresses) NewModel() db.IModel {
+	return &NetworkAddress{}
+}
+
+func (set NetworkAddresses) AddModel(i db.IModel) {
+	m := i.(*NetworkAddress)
+	set[m.Id] = m
+}
+
+func (set NetworkAddresses) Copy() apihelper.IModelSet {
+	setCopy := NetworkAddresses{}
+	for id, el := range set {
+		setCopy[id] = el.Copy()
+	}
+	return setCopy
+}
+
 func (set SecurityGroups) ModelManager() mcclient_modulebase.IBaseManager {
 	return &mcclient_modules.SecGroups
 }

pkg/vpcagent/models/modelsets.go

@@ -31,6 +31,7 @@ type ModelSetsMaxUpdatedAt struct {
 	Guestnetworks      time.Time
 	Guestsecgroups     time.Time
 	Elasticips         time.Time
+	NetworkAddresses   time.Time
 
 	DnsRecords time.Time
 }
@@ -47,6 +48,7 @@ func NewModelSetsMaxUpdatedAt() *ModelSetsMaxUpdatedAt {
 		Guestnetworks:      apihelper.PseudoZeroTime,
 		Guestsecgroups:     apihelper.PseudoZeroTime,
 		Elasticips:         apihelper.PseudoZeroTime,
+		NetworkAddresses:   apihelper.PseudoZeroTime,
 
 		DnsRecords: apihelper.PseudoZeroTime,
 	}
@@ -63,6 +65,7 @@ type ModelSets struct {
 	Guestnetworks      Guestnetworks
 	Guestsecgroups     Guestsecgroups
 	Elasticips         Elasticips
+	NetworkAddresses   NetworkAddresses
 
 	DnsRecords DnsRecords
 }
@@ -79,6 +82,7 @@ func NewModelSets() *ModelSets {
 		Guestnetworks:      Guestnetworks{},
 		Guestsecgroups:     Guestsecgroups{},
 		Elasticips:         Elasticips{},
+		NetworkAddresses:   NetworkAddresses{},
 
 		DnsRecords: DnsRecords{},
 	}
@@ -97,6 +101,7 @@ func (mss *ModelSets) ModelSetList() []apihelper.IModelSet {
 		mss.Guestnetworks,
 		mss.Guestsecgroups,
 		mss.Elasticips,
+		mss.NetworkAddresses,
 
 		mss.DnsRecords,
 	}
@@ -118,6 +123,7 @@ func (mss *ModelSets) copy_() *ModelSets {
 		Guestnetworks:      mss.Guestnetworks.Copy().(Guestnetworks),
 		Guestsecgroups:     mss.Guestsecgroups.Copy().(Guestsecgroups),
 		Elasticips:         mss.Elasticips.Copy().(Elasticips),
+		NetworkAddresses:   mss.NetworkAddresses.Copy().(NetworkAddresses),
 
 		DnsRecords: mss.DnsRecords.Copy().(DnsRecords),
 	}
@@ -161,6 +167,7 @@ func (mss *ModelSets) join() bool {
 	p = append(p, mss.Wires.joinNetworks(mss.Networks))
 	p = append(p, mss.Vpcs.joinNetworks(mss.Networks))
 	p = append(p, mss.Networks.joinGuestnetworks(mss.Guestnetworks))
+	p = append(p, mss.Networks.joinNetworkAddresses(mss.NetworkAddresses))
 	p = append(p, mss.Networks.joinElasticips(mss.Elasticips))
 	p = append(p, mss.Guests.joinHosts(mss.Hosts))
 	p = append(p, mss.Guests.joinSecurityGroups(mss.SecurityGroups))
@@ -168,6 +175,7 @@ func (mss *ModelSets) join() bool {
 	p = append(p, mss.Guestsecgroups.join(mss.SecurityGroups, mss.Guests))
 	p = append(p, mss.Guestnetworks.joinGuests(mss.Guests))
 	p = append(p, mss.Guestnetworks.joinElasticips(mss.Elasticips))
+	p = append(p, mss.Guestnetworks.joinNetworkAddresses(mss.NetworkAddresses))
 	for _, b := range p {
 		if !b {
 			return false