updater

package
v0.0.0-...-8d187f3 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 22, 2024 License: Apache-2.0 Imports: 21 Imported by: 0

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

This section is empty.

Types

type AZ 

type AZ struct {
	UpdaterBase[
		cloudmodel.AZ,
		*diffbase.AZ,
		*mysqlmodel.AZ,
		mysqlmodel.AZ,
		*message.AZAdd,
		message.AZAdd,
		*message.AZUpdate,
		message.AZUpdate,
		*message.AZFieldsUpdate,
		message.AZFieldsUpdate,
		*message.AZDelete,
		message.AZDelete]
}

func NewAZ 

func NewAZ(wholeCache *cache.Cache, cloudData []cloudmodel.AZ) *AZ

type CEN 

type CEN struct {
	UpdaterBase[
		cloudmodel.CEN,
		*diffbase.CEN,
		*mysqlmodel.CEN,
		mysqlmodel.CEN,
		*message.CENAdd,
		message.CENAdd,
		*message.CENUpdate,
		message.CENUpdate,
		*message.CENFieldsUpdate,
		message.CENFieldsUpdate,
		*message.CENDelete,
		message.CENDelete]
}

func NewCEN 

func NewCEN(wholeCache *cache.Cache, cloudData []cloudmodel.CEN) *CEN

type DHCPPort 

type DHCPPort struct {
	UpdaterBase[
		cloudmodel.DHCPPort,
		*diffbase.DHCPPort,
		*mysqlmodel.DHCPPort,
		mysqlmodel.DHCPPort,
		*message.DHCPPortAdd,
		message.DHCPPortAdd,
		*message.DHCPPortUpdate,
		message.DHCPPortUpdate,
		*message.DHCPPortFieldsUpdate,
		message.DHCPPortFieldsUpdate,
		*message.DHCPPortDelete,
		message.DHCPPortDelete]
}

func NewDHCPPort 

func NewDHCPPort(wholeCache *cache.Cache, cloudData []cloudmodel.DHCPPort) *DHCPPort

type DataGenerator 

type DataGenerator[CT constraint.CloudModel, MT constraint.MySQLModel, BT constraint.DiffBase, MFUPT msg.FieldsUpdatePtr[MFUT], MFUT msg.FieldsUpdate] interface {
	// contains filtered or unexported methods
}

type FloatingIP 

type FloatingIP struct {
	UpdaterBase[
		cloudmodel.FloatingIP,
		*diffbase.FloatingIP,
		*mysqlmodel.FloatingIP,
		mysqlmodel.FloatingIP,
		*message.FloatingIPAdd,
		message.FloatingIPAdd,
		*message.FloatingIPUpdate,
		message.FloatingIPUpdate,
		*message.FloatingIPFieldsUpdate,
		message.FloatingIPFieldsUpdate,
		*message.FloatingIPDelete,
		message.FloatingIPDelete]
}

func NewFloatingIP 

func NewFloatingIP(wholeCache *cache.Cache, cloudData []cloudmodel.FloatingIP) *FloatingIP

type Host 

type Host struct {
	UpdaterBase[
		cloudmodel.Host,
		*diffbase.Host,
		*mysqlmodel.Host,
		mysqlmodel.Host,
		*message.HostAdd,
		message.HostAdd,
		*message.HostUpdate,
		message.HostUpdate,
		*message.HostFieldsUpdate,
		message.HostFieldsUpdate,
		*message.HostDelete,
		message.HostDelete]
}

func NewHost 

func NewHost(wholeCache *cache.Cache, cloudData []cloudmodel.Host) *Host

type IP 

type IP struct {
	// contains filtered or unexported fields
}

func NewIP 

func NewIP(cache *cache.Cache, cloudData []cloudmodel.IP, domainToolDataSet *tool.DataSet) *IP

func (*IP) GetChanged 

func (i *IP) GetChanged() bool

func (*IP) GetLANIP 

func (i *IP) GetLANIP() *LANIP

func (*IP) GetResourceType 

func (i *IP) GetResourceType() string

func (*IP) GetWANIP 

func (i *IP) GetWANIP() *WANIP

func (*IP) HandleAddAndUpdate 

func (i *IP) HandleAddAndUpdate()

func (*IP) HandleDelete 

func (i *IP) HandleDelete()

type LANIP 

type LANIP struct {
	UpdaterBase[
		cloudmodel.IP,
		*diffbase.LANIP,
		*mysqlmodel.LANIP,
		mysqlmodel.LANIP,
		*message.LANIPAdd,
		message.LANIPAdd,
		*message.LANIPUpdate,
		message.LANIPUpdate,
		*message.LANIPFieldsUpdate,
		message.LANIPFieldsUpdate,
		*message.LANIPDelete,
		message.LANIPDelete]
}

func NewLANIP 

func NewLANIP(wholeCache *cache.Cache, domainToolDataSet *tool.DataSet) *LANIP

func (*LANIP) SetCloudData 

func (i *LANIP) SetCloudData(cloudData []cloudmodel.IP)

type LB 

type LB struct {
	UpdaterBase[
		cloudmodel.LB,
		*diffbase.LB,
		*mysqlmodel.LB,
		mysqlmodel.LB,
		*message.LBAdd,
		message.LBAdd,
		*message.LBUpdate,
		message.LBUpdate,
		*message.LBFieldsUpdate,
		message.LBFieldsUpdate,
		*message.LBDelete,
		message.LBDelete]
}

func NewLB 

func NewLB(wholeCache *cache.Cache, cloudData []cloudmodel.LB) *LB

type LBListener 

type LBListener struct {
	UpdaterBase[
		cloudmodel.LBListener,
		*diffbase.LBListener,
		*mysqlmodel.LBListener,
		mysqlmodel.LBListener,
		*message.LBListenerAdd,
		message.LBListenerAdd,
		*message.LBListenerUpdate,
		message.LBListenerUpdate,
		*message.LBListenerFieldsUpdate,
		message.LBListenerFieldsUpdate,
		*message.LBListenerDelete,
		message.LBListenerDelete]
}

func NewLBListener 

func NewLBListener(wholeCache *cache.Cache, cloudData []cloudmodel.LBListener) *LBListener

type LBTargetServer 

type LBTargetServer struct {
	UpdaterBase[
		cloudmodel.LBTargetServer,
		*diffbase.LBTargetServer,
		*mysqlmodel.LBTargetServer,
		mysqlmodel.LBTargetServer,
		*message.LBTargetServerAdd,
		message.LBTargetServerAdd,
		*message.LBTargetServerUpdate,
		message.LBTargetServerUpdate,
		*message.LBTargetServerFieldsUpdate,
		message.LBTargetServerFieldsUpdate,
		*message.LBTargetServerDelete,
		message.LBTargetServerDelete]
}

func NewLBTargetServer 

func NewLBTargetServer(wholeCache *cache.Cache, cloudData []cloudmodel.LBTargetServer) *LBTargetServer

type LBVMConnection 

type LBVMConnection struct {
	UpdaterBase[
		cloudmodel.LBVMConnection,
		*diffbase.LBVMConnection,
		*mysqlmodel.LBVMConnection,
		mysqlmodel.LBVMConnection,
		*message.LBVMConnectionAdd,
		message.LBVMConnectionAdd,
		*message.LBVMConnectionUpdate,
		message.LBVMConnectionUpdate,
		*message.LBVMConnectionFieldsUpdate,
		message.LBVMConnectionFieldsUpdate,
		*message.LBVMConnectionDelete,
		message.LBVMConnectionDelete]
}

func NewLBVMConnection 

func NewLBVMConnection(wholeCache *cache.Cache, cloudData []cloudmodel.LBVMConnection) *LBVMConnection

type NATGateway 

type NATGateway struct {
	UpdaterBase[
		cloudmodel.NATGateway,
		*diffbase.NATGateway,
		*mysqlmodel.NATGateway,
		mysqlmodel.NATGateway,
		*message.NATGatewayAdd,
		message.NATGatewayAdd,
		*message.NATGatewayUpdate,
		message.NATGatewayUpdate,
		*message.NATGatewayFieldsUpdate,
		message.NATGatewayFieldsUpdate,
		*message.NATGatewayDelete,
		message.NATGatewayDelete]
}

func NewNATGateway 

func NewNATGateway(wholeCache *cache.Cache, cloudData []cloudmodel.NATGateway) *NATGateway

type NATRule 

type NATRule struct {
	UpdaterBase[
		cloudmodel.NATRule,
		*diffbase.NATRule,
		*mysqlmodel.NATRule,
		mysqlmodel.NATRule,
		*message.NATRuleAdd,
		message.NATRuleAdd,
		*message.NATRuleUpdate,
		message.NATRuleUpdate,
		*message.NATRuleFieldsUpdate,
		message.NATRuleFieldsUpdate,
		*message.NATRuleDelete,
		message.NATRuleDelete]
}

func NewNATRule 

func NewNATRule(wholeCache *cache.Cache, cloudData []cloudmodel.NATRule) *NATRule

type NATVMConnection 

type NATVMConnection struct {
	UpdaterBase[
		cloudmodel.NATVMConnection,
		*diffbase.NATVMConnection,
		*mysqlmodel.NATVMConnection,
		mysqlmodel.NATVMConnection,
		*message.NATVMConnectionAdd,
		message.NATVMConnectionAdd,
		*message.NATVMConnectionUpdate,
		message.NATVMConnectionUpdate,
		*message.NATVMConnectionFieldsUpdate,
		message.NATVMConnectionFieldsUpdate,
		*message.NATVMConnectionDelete,
		message.NATVMConnectionDelete]
}

func NewNATVMConnection 

func NewNATVMConnection(wholeCache *cache.Cache, cloudData []cloudmodel.NATVMConnection) *NATVMConnection

type Network 

type Network struct {
	UpdaterBase[
		cloudmodel.Network,
		*diffbase.Network,
		*mysqlmodel.Network,
		mysqlmodel.Network,
		*message.NetworkAdd,
		message.NetworkAdd,
		*message.NetworkUpdate,
		message.NetworkUpdate,
		*message.NetworkFieldsUpdate,
		message.NetworkFieldsUpdate,
		*message.NetworkDelete,
		message.NetworkDelete]
}

func NewNetwork 

func NewNetwork(wholeCache *cache.Cache, cloudData []cloudmodel.Network) *Network

type PeerConnection 

type PeerConnection struct {
	UpdaterBase[
		cloudmodel.PeerConnection,
		*diffbase.PeerConnection,
		*mysqlmodel.PeerConnection,
		mysqlmodel.PeerConnection,
		*message.PeerConnectionAdd,
		message.PeerConnectionAdd,
		*message.PeerConnectionUpdate,
		message.PeerConnectionUpdate,
		*message.PeerConnectionFieldsUpdate,
		message.PeerConnectionFieldsUpdate,
		*message.PeerConnectionDelete,
		message.PeerConnectionDelete]
}

func NewPeerConnection 

func NewPeerConnection(wholeCache *cache.Cache, cloudData []cloudmodel.PeerConnection) *PeerConnection

type Pod 

type Pod struct {
	UpdaterBase[
		cloudmodel.Pod,
		*diffbase.Pod,
		*mysqlmodel.Pod,
		mysqlmodel.Pod,
		*message.PodAdd,
		message.PodAdd,
		*message.PodUpdate,
		message.PodUpdate,
		*message.PodFieldsUpdate,
		message.PodFieldsUpdate,
		*message.PodDelete,
		message.PodDelete]
}

func NewPod 

func NewPod(wholeCache *cache.Cache, cloudData []cloudmodel.Pod) *Pod

type PodCluster 

type PodCluster struct {
	UpdaterBase[
		cloudmodel.PodCluster,
		*diffbase.PodCluster,
		*mysqlmodel.PodCluster,
		mysqlmodel.PodCluster,
		*message.PodClusterAdd,
		message.PodClusterAdd,
		*message.PodClusterUpdate,
		message.PodClusterUpdate,
		*message.PodClusterFieldsUpdate,
		message.PodClusterFieldsUpdate,
		*message.PodClusterDelete,
		message.PodClusterDelete]
}

func NewPodCluster 

func NewPodCluster(wholeCache *cache.Cache, cloudData []cloudmodel.PodCluster) *PodCluster

type PodGroup 

type PodGroup struct {
	UpdaterBase[
		cloudmodel.PodGroup,
		*diffbase.PodGroup,
		*mysqlmodel.PodGroup,
		mysqlmodel.PodGroup,
		*message.PodGroupAdd,
		message.PodGroupAdd,
		*message.PodGroupUpdate,
		message.PodGroupUpdate,
		*message.PodGroupFieldsUpdate,
		message.PodGroupFieldsUpdate,
		*message.PodGroupDelete,
		message.PodGroupDelete]
}

func NewPodGroup 

func NewPodGroup(wholeCache *cache.Cache, cloudData []cloudmodel.PodGroup) *PodGroup

type PodGroupPort 

type PodGroupPort struct {
	UpdaterBase[
		cloudmodel.PodGroupPort,
		*diffbase.PodGroupPort,
		*mysqlmodel.PodGroupPort,
		mysqlmodel.PodGroupPort,
		*message.PodGroupPortAdd,
		message.PodGroupPortAdd,
		*message.PodGroupPortUpdate,
		message.PodGroupPortUpdate,
		*message.PodGroupPortFieldsUpdate,
		message.PodGroupPortFieldsUpdate,
		*message.PodGroupPortDelete,
		message.PodGroupPortDelete]
}

func NewPodGroupPort 

func NewPodGroupPort(wholeCache *cache.Cache, cloudData []cloudmodel.PodGroupPort) *PodGroupPort

type PodIngress 

type PodIngress struct {
	UpdaterBase[
		cloudmodel.PodIngress,
		*diffbase.PodIngress,
		*mysqlmodel.PodIngress,
		mysqlmodel.PodIngress,
		*message.PodIngressAdd,
		message.PodIngressAdd,
		*message.PodIngressUpdate,
		message.PodIngressUpdate,
		*message.PodIngressFieldsUpdate,
		message.PodIngressFieldsUpdate,
		*message.PodIngressDelete,
		message.PodIngressDelete]
}

func NewPodIngress 

func NewPodIngress(wholeCache *cache.Cache, cloudData []cloudmodel.PodIngress) *PodIngress

type PodIngressRule 

type PodIngressRule struct {
	UpdaterBase[
		cloudmodel.PodIngressRule,
		*diffbase.PodIngressRule,
		*mysqlmodel.PodIngressRule,
		mysqlmodel.PodIngressRule,
		*message.PodIngressRuleAdd,
		message.PodIngressRuleAdd,
		*message.PodIngressRuleUpdate,
		message.PodIngressRuleUpdate,
		*message.PodIngressRuleFieldsUpdate,
		message.PodIngressRuleFieldsUpdate,
		*message.PodIngressRuleDelete,
		message.PodIngressRuleDelete]
}

func NewPodIngressRule 

func NewPodIngressRule(wholeCache *cache.Cache, cloudData []cloudmodel.PodIngressRule) *PodIngressRule

type PodIngressRuleBackend 

type PodIngressRuleBackend struct {
	UpdaterBase[
		cloudmodel.PodIngressRuleBackend,
		*diffbase.PodIngressRuleBackend,
		*mysqlmodel.PodIngressRuleBackend,
		mysqlmodel.PodIngressRuleBackend,
		*message.PodIngressRuleBackendAdd,
		message.PodIngressRuleBackendAdd,
		*message.PodIngressRuleBackendUpdate,
		message.PodIngressRuleBackendUpdate,
		*message.PodIngressRuleBackendFieldsUpdate,
		message.PodIngressRuleBackendFieldsUpdate,
		*message.PodIngressRuleBackendDelete,
		message.PodIngressRuleBackendDelete]
}

func NewPodIngressRuleBackend 

func NewPodIngressRuleBackend(wholeCache *cache.Cache, cloudData []cloudmodel.PodIngressRuleBackend) *PodIngressRuleBackend

type PodNamespace 

type PodNamespace struct {
	UpdaterBase[
		cloudmodel.PodNamespace,
		*diffbase.PodNamespace,
		*mysqlmodel.PodNamespace,
		mysqlmodel.PodNamespace,
		*message.PodNamespaceAdd,
		message.PodNamespaceAdd,
		*message.PodNamespaceUpdate,
		message.PodNamespaceUpdate,
		*message.PodNamespaceFieldsUpdate,
		message.PodNamespaceFieldsUpdate,
		*message.PodNamespaceDelete,
		message.PodNamespaceDelete]
}

func NewPodNamespace 

func NewPodNamespace(wholeCache *cache.Cache, cloudData []cloudmodel.PodNamespace) *PodNamespace

type PodNode 

type PodNode struct {
	UpdaterBase[
		cloudmodel.PodNode,
		*diffbase.PodNode,
		*mysqlmodel.PodNode,
		mysqlmodel.PodNode,
		*message.PodNodeAdd,
		message.PodNodeAdd,
		*message.PodNodeUpdate,
		message.PodNodeUpdate,
		*message.PodNodeFieldsUpdate,
		message.PodNodeFieldsUpdate,
		*message.PodNodeDelete,
		message.PodNodeDelete]
}

func NewPodNode 

func NewPodNode(wholeCache *cache.Cache, cloudData []cloudmodel.PodNode) *PodNode

type PodReplicaSet 

type PodReplicaSet struct {
	UpdaterBase[
		cloudmodel.PodReplicaSet,
		*diffbase.PodReplicaSet,
		*mysqlmodel.PodReplicaSet,
		mysqlmodel.PodReplicaSet,
		*message.PodReplicaSetAdd,
		message.PodReplicaSetAdd,
		*message.PodReplicaSetUpdate,
		message.PodReplicaSetUpdate,
		*message.PodReplicaSetFieldsUpdate,
		message.PodReplicaSetFieldsUpdate,
		*message.PodReplicaSetDelete,
		message.PodReplicaSetDelete]
}

func NewPodReplicaSet 

func NewPodReplicaSet(wholeCache *cache.Cache, cloudData []cloudmodel.PodReplicaSet) *PodReplicaSet

type PodService 

type PodService struct {
	UpdaterBase[
		cloudmodel.PodService,
		*diffbase.PodService,
		*mysqlmodel.PodService,
		mysqlmodel.PodService,
		*message.PodServiceAdd,
		message.PodServiceAdd,
		*message.PodServiceUpdate,
		message.PodServiceUpdate,
		*message.PodServiceFieldsUpdate,
		message.PodServiceFieldsUpdate,
		*message.PodServiceDelete,
		message.PodServiceDelete]
}

func NewPodService 

func NewPodService(wholeCache *cache.Cache, cloudData []cloudmodel.PodService) *PodService

type PodServicePort 

type PodServicePort struct {
	UpdaterBase[
		cloudmodel.PodServicePort,
		*diffbase.PodServicePort,
		*mysqlmodel.PodServicePort,
		mysqlmodel.PodServicePort,
		*message.PodServicePortAdd,
		message.PodServicePortAdd,
		*message.PodServicePortUpdate,
		message.PodServicePortUpdate,
		*message.PodServicePortFieldsUpdate,
		message.PodServicePortFieldsUpdate,
		*message.PodServicePortDelete,
		message.PodServicePortDelete]
}

func NewPodServicePort 

func NewPodServicePort(wholeCache *cache.Cache, cloudData []cloudmodel.PodServicePort) *PodServicePort

type Process 

type Process struct {
	UpdaterBase[
		cloudmodel.Process,
		*diffbase.Process,
		*mysqlmodel.Process,
		mysqlmodel.Process,
		*message.ProcessAdd,
		message.ProcessAdd,
		*message.ProcessUpdate,
		message.ProcessUpdate,
		*message.ProcessFieldsUpdate,
		message.ProcessFieldsUpdate,
		*message.ProcessDelete,
		message.ProcessDelete]
}

func NewProcess 

func NewProcess(wholeCache *cache.Cache, cloudData []cloudmodel.Process) *Process

type Publisher 

type Publisher interface {
	GetChanged() bool
	GetResourceType() string
}

type RDSInstance 

type RDSInstance struct {
	UpdaterBase[
		cloudmodel.RDSInstance,
		*diffbase.RDSInstance,
		*mysqlmodel.RDSInstance,
		mysqlmodel.RDSInstance,
		*message.RDSInstanceAdd,
		message.RDSInstanceAdd,
		*message.RDSInstanceUpdate,
		message.RDSInstanceUpdate,
		*message.RDSInstanceFieldsUpdate,
		message.RDSInstanceFieldsUpdate,
		*message.RDSInstanceDelete,
		message.RDSInstanceDelete]
}

func NewRDSInstance 

func NewRDSInstance(wholeCache *cache.Cache, cloudData []cloudmodel.RDSInstance) *RDSInstance

type RedisInstance 

type RedisInstance struct {
	UpdaterBase[
		cloudmodel.RedisInstance,
		*diffbase.RedisInstance,
		*mysqlmodel.RedisInstance,
		mysqlmodel.RedisInstance,
		*message.RedisInstanceAdd,
		message.RedisInstanceAdd,
		*message.RedisInstanceUpdate,
		message.RedisInstanceUpdate,
		*message.RedisInstanceFieldsUpdate,
		message.RedisInstanceFieldsUpdate,
		*message.RedisInstanceDelete,
		message.RedisInstanceDelete]
}

func NewRedisInstance 

func NewRedisInstance(wholeCache *cache.Cache, cloudData []cloudmodel.RedisInstance) *RedisInstance

type Region 

type Region struct {
	UpdaterBase[
		cloudmodel.Region,
		*diffbase.Region,
		*mysqlmodel.Region,
		mysqlmodel.Region,
		*message.RegionAdd,
		message.RegionAdd,
		*message.RegionUpdate,
		message.RegionUpdate,
		*message.RegionFieldsUpdate,
		message.RegionFieldsUpdate,
		*message.RegionDelete,
		message.RegionDelete]
}

func NewRegion 

func NewRegion(wholeCache *cache.Cache, cloudData []cloudmodel.Region) *Region

type ResourceUpdater 

type ResourceUpdater interface {
	// 以资源的 lcuuid 为 key ，逐一检查 cloud 数据
	// 若 cache 的 diff base 中不存在，则添加
	// 若 cache 的 diff base 中存在，基于可更新字段，检查 cloud 数据是否发生变化，若发生变化，则更新；
	// 无论已存在资源有无变化，根据 cache 的 sequence 更新的 diff base 中的 sequence，用于标记资源是否需要被删除
	HandleAddAndUpdate()
	// 逐一检查 diff base 中的资源，若 sequence 不等于 cache 中的 sequence，则删除
	HandleDelete()

	Publisher
}

ResourceUpdater 实现资源进行新旧数据比对，并根据比对结果增删改资源

type RoutingTable 

type RoutingTable struct {
	UpdaterBase[
		cloudmodel.RoutingTable,
		*diffbase.RoutingTable,
		*mysqlmodel.RoutingTable,
		mysqlmodel.RoutingTable,
		*message.RoutingTableAdd,
		message.RoutingTableAdd,
		*message.RoutingTableUpdate,
		message.RoutingTableUpdate,
		*message.RoutingTableFieldsUpdate,
		message.RoutingTableFieldsUpdate,
		*message.RoutingTableDelete,
		message.RoutingTableDelete]
}

func NewRoutingTable 

func NewRoutingTable(wholeCache *cache.Cache, cloudData []cloudmodel.RoutingTable) *RoutingTable

type SubDomain 

type SubDomain struct {
	UpdaterBase[
		cloudmodel.SubDomain,
		*diffbase.SubDomain,
		*mysqlmodel.SubDomain,
		mysqlmodel.SubDomain,
		*message.SubDomainAdd,
		message.SubDomainAdd,
		*message.SubDomainUpdate,
		message.SubDomainUpdate,
		*message.SubDomainFieldsUpdate,
		message.SubDomainFieldsUpdate,
		*message.SubDomainDelete,
		message.SubDomainDelete]
}

func NewSubDomain 

func NewSubDomain(wholeCache *cache.Cache, cloudData []cloudmodel.SubDomain) *SubDomain

type Subnet 

type Subnet struct {
	UpdaterBase[
		cloudmodel.Subnet,
		*diffbase.Subnet,
		*mysqlmodel.Subnet,
		mysqlmodel.Subnet,
		*message.SubnetAdd,
		message.SubnetAdd,
		*message.SubnetUpdate,
		message.SubnetUpdate,
		*message.SubnetFieldsUpdate,
		message.SubnetFieldsUpdate,
		*message.SubnetDelete,
		message.SubnetDelete]
}

func NewSubnet 

func NewSubnet(wholeCache *cache.Cache, cloudData []cloudmodel.Subnet) *Subnet

type UpdaterBase 

type UpdaterBase[
	CT constraint.CloudModel,
	BT constraint.DiffBase,
	MPT constraint.MySQLModelPtr[MT],
	MT constraint.MySQLModel,
	MAPT msg.AddPtr[MAT],
	MAT msg.Add,
	MUPT msg.UpdatePtr[MUT],
	MUT msg.Update,
	MFUPT msg.FieldsUpdatePtr[MFUT],
	MFUT msg.FieldsUpdate,
	MDPT msg.DeletePtr[MDT],
	MDT msg.Delete,
] struct {

	// Set Changed to true if the resource database and cache are updated,
	// used for cache update notifications to trisolaris module.
	Changed bool
	// contains filtered or unexported fields
}

func (*UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) GetChanged 

func (u *UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) GetChanged() bool

func (*UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) GetResourceType 

func (u *UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) GetResourceType() string

func (*UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) HandleAddAndUpdate 

func (u *UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) HandleAddAndUpdate()

func (*UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) HandleDelete 

func (u *UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) HandleDelete()

func (*UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) RegisterListener 

func (u *UpdaterBase[CT, BT, MPT, MT, MAPT, MAT, MUPT, MUT, MFUPT, MFUT, MDPT, MDT]) RegisterListener(listener listener.Listener[CT, MT, BT]) ResourceUpdater

type VIP 

type VIP struct {
	UpdaterBase[
		cloudmodel.VIP,
		*diffbase.VIP,
		*mysqlmodel.VIP,
		mysqlmodel.VIP,
		*message.VIPAdd,
		message.VIPAdd,
		*message.VIPUpdate,
		message.VIPUpdate,
		*message.VIPFieldsUpdate,
		message.VIPFieldsUpdate,
		*message.VIPDelete,
		message.VIPDelete]
}

func NewVIP 

func NewVIP(wholeCache *cache.Cache, cloudData []cloudmodel.VIP) *VIP

type VInterface 

type VInterface struct {
	UpdaterBase[
		cloudmodel.VInterface,
		*diffbase.VInterface,
		*mysqlmodel.VInterface,
		mysqlmodel.VInterface,
		*message.VInterfaceAdd,
		message.VInterfaceAdd,
		*message.VInterfaceUpdate,
		message.VInterfaceUpdate,
		*message.VInterfaceFieldsUpdate,
		message.VInterfaceFieldsUpdate,
		*message.VInterfaceDelete,
		message.VInterfaceDelete]
}

func NewVInterface 

func NewVInterface(wholeCache *cache.Cache, cloudData []cloudmodel.VInterface, domainToolDataSet *tool.DataSet) *VInterface

type VM 

type VM struct {
	UpdaterBase[
		cloudmodel.VM,
		*diffbase.VM,
		*mysqlmodel.VM,
		mysqlmodel.VM,
		*message.VMAdd,
		message.VMAdd,
		*message.VMUpdate,
		message.VMUpdate,
		*message.VMFieldsUpdate,
		message.VMFieldsUpdate,
		*message.VMDelete,
		message.VMDelete]
}

func NewVM 

func NewVM(wholeCache *cache.Cache, cloudData []cloudmodel.VM) *VM

type VMPodNodeConnection 

type VMPodNodeConnection struct {
	UpdaterBase[
		cloudmodel.VMPodNodeConnection,
		*diffbase.VMPodNodeConnection,
		*mysqlmodel.VMPodNodeConnection,
		mysqlmodel.VMPodNodeConnection,
		*message.VMPodNodeConnectionAdd,
		message.VMPodNodeConnectionAdd,
		*message.VMPodNodeConnectionUpdate,
		message.VMPodNodeConnectionUpdate,
		*message.VMPodNodeConnectionFieldsUpdate,
		message.VMPodNodeConnectionFieldsUpdate,
		*message.VMPodNodeConnectionDelete,
		message.VMPodNodeConnectionDelete]
}

func NewVMPodNodeConnection 

func NewVMPodNodeConnection(wholeCache *cache.Cache, cloudData []cloudmodel.VMPodNodeConnection) *VMPodNodeConnection

type VPC 

type VPC struct {
	UpdaterBase[
		cloudmodel.VPC,
		*diffbase.VPC,
		*mysqlmodel.VPC,
		mysqlmodel.VPC,
		*message.VPCAdd,
		message.VPCAdd,
		*message.VPCUpdate,
		message.VPCUpdate,
		*message.VPCFieldsUpdate,
		message.VPCFieldsUpdate,
		*message.VPCDelete,
		message.VPCDelete]
}

func NewVPC 

func NewVPC(wholeCache *cache.Cache, cloudData []cloudmodel.VPC) *VPC

type VRouter 

type VRouter struct {
	UpdaterBase[
		cloudmodel.VRouter,
		*diffbase.VRouter,
		*mysqlmodel.VRouter,
		mysqlmodel.VRouter,
		*message.VRouterAdd,
		message.VRouterAdd,
		*message.VRouterUpdate,
		message.VRouterUpdate,
		*message.VRouterFieldsUpdate,
		message.VRouterFieldsUpdate,
		*message.VRouterDelete,
		message.VRouterDelete]
}

func NewVRouter 

func NewVRouter(wholeCache *cache.Cache, cloudData []cloudmodel.VRouter) *VRouter

type WANIP 

type WANIP struct {
	UpdaterBase[
		cloudmodel.IP,
		*diffbase.WANIP,
		*mysqlmodel.WANIP,
		mysqlmodel.WANIP,
		*message.WANIPAdd,
		message.WANIPAdd,
		*message.WANIPUpdate,
		message.WANIPUpdate,
		*message.WANIPFieldsUpdate,
		message.WANIPFieldsUpdate,
		*message.WANIPDelete,
		message.WANIPDelete]
}

func NewWANIP 

func NewWANIP(wholeCache *cache.Cache, domainToolDataSet *tool.DataSet) *WANIP

func (*WANIP) SetCloudData 

func (i *WANIP) SetCloudData(cloudData []cloudmodel.IP)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.