From 71c70181f17be851d1afffd1ae484879086997af Mon Sep 17 00:00:00 2001 From: zhengya Date: Sun, 25 Jun 2023 16:08:49 +0800 Subject: [PATCH] [CONTROLLER/RECORDER] refactors listener module --- server/controller/recorder/cache/cache.go | 6 +- server/controller/recorder/listener/az.go | 46 +++ server/controller/recorder/listener/cen.go | 46 +++ .../controller/recorder/listener/dhcp_port.go | 12 +- server/controller/recorder/listener/domain.go | 10 +- .../recorder/listener/floating_ip.go | 46 +++ server/controller/recorder/listener/host.go | 24 +- server/controller/recorder/listener/lan_ip.go | 23 +- server/controller/recorder/listener/lb.go | 24 +- .../recorder/listener/lb_listener.go | 46 +++ .../recorder/listener/lb_target_server.go | 46 +++ .../recorder/listener/lb_vm_connection.go | 45 +++ .../controller/recorder/listener/listener.go | 27 ++ .../recorder/listener/nat_gateway.go | 24 +- .../controller/recorder/listener/nat_rule.go | 45 +++ .../recorder/listener/nat_vm_connection.go | 45 +++ .../controller/recorder/listener/network.go | 47 +++ .../recorder/listener/peer_connection.go | 46 +++ server/controller/recorder/listener/pod.go | 12 +- .../recorder/listener/pod_cluster.go | 46 +++ .../controller/recorder/listener/pod_group.go | 46 +++ .../recorder/listener/pod_group_port.go | 46 +++ .../recorder/listener/pod_ingress.go | 46 +++ .../recorder/listener/pod_ingress_rule.go | 45 +++ .../listener/pod_ingress_rule_backend.go | 45 +++ .../recorder/listener/pod_namespace.go | 46 +++ .../controller/recorder/listener/pod_node.go | 24 +- .../recorder/listener/pod_replica_set.go | 46 +++ .../recorder/listener/pod_service.go | 24 +- .../recorder/listener/pod_service_port.go | 46 +++ .../controller/recorder/listener/process.go | 3 + .../recorder/listener/prometheus_target.go | 46 +++ .../recorder/listener/rds_instance.go | 22 +- .../recorder/listener/redis_instance.go | 22 +- server/controller/recorder/listener/region.go | 46 +++ .../recorder/listener/routing_table.go | 46 +++ .../recorder/listener/security_group.go | 46 +++ .../recorder/listener/security_group_rule.go | 46 +++ .../recorder/listener/sub_domain.go | 34 +- server/controller/recorder/listener/subnet.go | 45 +++ .../recorder/listener/vinterface.go | 46 +++ server/controller/recorder/listener/vm.go | 24 +- .../listener/vm_pod_node_connection.go | 44 +++ .../recorder/listener/vm_security_group.go | 45 +++ server/controller/recorder/listener/vpc.go | 45 +++ .../controller/recorder/listener/vrouter.go | 24 +- server/controller/recorder/listener/wan_ip.go | 23 +- server/controller/recorder/recorder.go | 285 ++++++++--------- server/controller/recorder/updater/az.go | 13 - server/controller/recorder/updater/cen.go | 13 - .../controller/recorder/updater/dhcp_port.go | 14 - .../recorder/updater/floating_ip.go | 13 - server/controller/recorder/updater/host.go | 14 - server/controller/recorder/updater/lan_ip.go | 13 - server/controller/recorder/updater/lb.go | 14 - .../recorder/updater/lb_listener.go | 13 - .../recorder/updater/lb_target_server.go | 13 - .../recorder/updater/lb_vm_connection.go | 13 - .../recorder/updater/nat_gateway.go | 14 - .../controller/recorder/updater/nat_rule.go | 13 - .../recorder/updater/nat_vm_connection.go | 13 - server/controller/recorder/updater/network.go | 14 - .../recorder/updater/peer_connection.go | 13 - server/controller/recorder/updater/pod.go | 14 - .../recorder/updater/pod_cluster.go | 13 - .../controller/recorder/updater/pod_group.go | 13 - .../recorder/updater/pod_group_port.go | 13 - .../recorder/updater/pod_ingress.go | 13 - .../recorder/updater/pod_ingress_rule.go | 13 - .../updater/pod_ingress_rule_backend.go | 13 - .../recorder/updater/pod_namespace.go | 13 - .../controller/recorder/updater/pod_node.go | 14 - .../recorder/updater/pod_replica_set.go | 13 - .../recorder/updater/pod_service.go | 14 - .../recorder/updater/pod_service_port.go | 13 - server/controller/recorder/updater/process.go | 13 - .../recorder/updater/prometheus_target.go | 13 - .../recorder/updater/rds_instance.go | 14 - .../recorder/updater/redis_instance.go | 14 - server/controller/recorder/updater/region.go | 13 - .../recorder/updater/routing_table.go | 13 - .../recorder/updater/security_group.go | 13 - .../recorder/updater/security_group_rule.go | 13 - .../controller/recorder/updater/sub_domain.go | 13 - server/controller/recorder/updater/subnet.go | 13 - .../recorder/updater/updatable_field.go | 290 ------------------ server/controller/recorder/updater/updater.go | 97 +++--- .../controller/recorder/updater/vinterface.go | 14 - server/controller/recorder/updater/vm.go | 14 - .../updater/vm_pod_node_connection.go | 13 - .../recorder/updater/vm_security_group.go | 13 - server/controller/recorder/updater/vpc.go | 13 - server/controller/recorder/updater/vrouter.go | 14 - server/controller/recorder/updater/wan_ip.go | 13 - 94 files changed, 1713 insertions(+), 1231 deletions(-) create mode 100644 server/controller/recorder/listener/az.go create mode 100644 server/controller/recorder/listener/cen.go create mode 100644 server/controller/recorder/listener/floating_ip.go create mode 100644 server/controller/recorder/listener/lb_listener.go create mode 100644 server/controller/recorder/listener/lb_target_server.go create mode 100644 server/controller/recorder/listener/lb_vm_connection.go create mode 100644 server/controller/recorder/listener/listener.go create mode 100644 server/controller/recorder/listener/nat_rule.go create mode 100644 server/controller/recorder/listener/nat_vm_connection.go create mode 100644 server/controller/recorder/listener/network.go create mode 100644 server/controller/recorder/listener/peer_connection.go create mode 100644 server/controller/recorder/listener/pod_cluster.go create mode 100644 server/controller/recorder/listener/pod_group.go create mode 100644 server/controller/recorder/listener/pod_group_port.go create mode 100644 server/controller/recorder/listener/pod_ingress.go create mode 100644 server/controller/recorder/listener/pod_ingress_rule.go create mode 100644 server/controller/recorder/listener/pod_ingress_rule_backend.go create mode 100644 server/controller/recorder/listener/pod_namespace.go create mode 100644 server/controller/recorder/listener/pod_replica_set.go create mode 100644 server/controller/recorder/listener/pod_service_port.go create mode 100644 server/controller/recorder/listener/prometheus_target.go create mode 100644 server/controller/recorder/listener/region.go create mode 100644 server/controller/recorder/listener/routing_table.go create mode 100644 server/controller/recorder/listener/security_group.go create mode 100644 server/controller/recorder/listener/security_group_rule.go create mode 100644 server/controller/recorder/listener/subnet.go create mode 100644 server/controller/recorder/listener/vinterface.go create mode 100644 server/controller/recorder/listener/vm_pod_node_connection.go create mode 100644 server/controller/recorder/listener/vm_security_group.go create mode 100644 server/controller/recorder/listener/vpc.go delete mode 100644 server/controller/recorder/updater/updatable_field.go diff --git a/server/controller/recorder/cache/cache.go b/server/controller/recorder/cache/cache.go index bd0fea1c06a..8f68c6e9e62 100644 --- a/server/controller/recorder/cache/cache.go +++ b/server/controller/recorder/cache/cache.go @@ -1514,13 +1514,13 @@ func (c *Cache) refreshProcesses() { c.AddProcesses(processes) } -func (c *Cache) AddPrometheusTarget(items []*mysql.PrometheusTarget) { +func (c *Cache) AddPrometheusTargets(items []*mysql.PrometheusTarget) { for _, item := range items { c.DiffBaseDataSet.addPrometheusTarget(item, c.Sequence) } } -func (c *Cache) DeletePrometheusTarget(lcuuids []string) { +func (c *Cache) DeletePrometheusTargets(lcuuids []string) { for _, lcuuid := range lcuuids { c.DiffBaseDataSet.deletePrometheusTarget(lcuuid) } @@ -1534,5 +1534,5 @@ func (c *Cache) refreshPrometheusTarget() { return } - c.AddPrometheusTarget(prometheusTargets) + c.AddPrometheusTargets(prometheusTargets) } diff --git a/server/controller/recorder/listener/az.go b/server/controller/recorder/listener/az.go new file mode 100644 index 00000000000..f9223417a59 --- /dev/null +++ b/server/controller/recorder/listener/az.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type AZ struct { + cache *cache.Cache +} + +func NewAZ(c *cache.Cache) *AZ { + listener := &AZ{ + cache: c, + } + return listener +} + +func (a *AZ) OnUpdaterAdded(addedDBItems []*mysql.AZ) { + a.cache.AddAZs(addedDBItems) +} + +func (a *AZ) OnUpdaterUpdated(cloudItem *cloudmodel.AZ, diffBase *cache.AZ) { + diffBase.Update(cloudItem) +} + +func (a *AZ) OnUpdaterDeleted(lcuuids []string) { + a.cache.DeleteAZs(lcuuids) +} diff --git a/server/controller/recorder/listener/cen.go b/server/controller/recorder/listener/cen.go new file mode 100644 index 00000000000..9617079764d --- /dev/null +++ b/server/controller/recorder/listener/cen.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type CEN struct { + cache *cache.Cache +} + +func NewCEN(c *cache.Cache) *CEN { + listener := &CEN{ + cache: c, + } + return listener +} + +func (c *CEN) OnUpdaterAdded(addedDBItems []*mysql.CEN) { + c.cache.AddCENs(addedDBItems) +} + +func (c *CEN) OnUpdaterUpdated(cloudItem *cloudmodel.CEN, diffBase *cache.CEN) { + diffBase.Update(cloudItem) +} + +func (c *CEN) OnUpdaterDeleted(lcuuids []string) { + c.cache.DeleteCENs(lcuuids) +} diff --git a/server/controller/recorder/listener/dhcp_port.go b/server/controller/recorder/listener/dhcp_port.go index 7c280d28dd1..f63a57fe384 100644 --- a/server/controller/recorder/listener/dhcp_port.go +++ b/server/controller/recorder/listener/dhcp_port.go @@ -30,25 +30,25 @@ type DHCPPort struct { } func NewDHCPPort(c *cache.Cache, eq *queue.OverwriteQueue) *DHCPPort { - lisener := &DHCPPort{ + listener := &DHCPPort{ cache: c, eventProducer: event.NewDHCPPort(&c.ToolDataSet, eq), } - return lisener + return listener } func (p *DHCPPort) OnUpdaterAdded(addedDBItems []*mysql.DHCPPort) { - // p.cache.AddDHCPPorts(addedDBItems) p.eventProducer.ProduceByAdd(addedDBItems) + p.cache.AddDHCPPorts(addedDBItems) } func (p *DHCPPort) OnUpdaterUpdated(cloudItem *cloudmodel.DHCPPort, diffBase *cache.DHCPPort) { p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateDHCPPort(cloudItem) + diffBase.Update(cloudItem) + p.cache.UpdateDHCPPort(cloudItem) } func (p *DHCPPort) OnUpdaterDeleted(lcuuids []string) { p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteDHCPPorts(lcuuids) + p.cache.DeleteDHCPPorts(lcuuids) } diff --git a/server/controller/recorder/listener/domain.go b/server/controller/recorder/listener/domain.go index 7fd72d9f2b6..b147466509b 100644 --- a/server/controller/recorder/listener/domain.go +++ b/server/controller/recorder/listener/domain.go @@ -22,19 +22,19 @@ import ( "github.com/deepflowio/deepflow/server/libs/queue" ) -type Domain struct { +type WholeDomain struct { cache *cache.Cache eventProducer *event.Domain } -func NewDomain(domainLcuuid string, c *cache.Cache, eq *queue.OverwriteQueue) *Domain { - lisener := &Domain{ +func NewWholeDomain(domainLcuuid string, c *cache.Cache, eq *queue.OverwriteQueue) *WholeDomain { + listener := &WholeDomain{ cache: c, eventProducer: event.NewDomain(domainLcuuid, &c.ToolDataSet, eq), } - return lisener + return listener } -func (p *Domain) OnUpdatersCompeleted() { +func (p *WholeDomain) OnUpdatersCompleted() { p.eventProducer.ProduceFromMySQL() } diff --git a/server/controller/recorder/listener/floating_ip.go b/server/controller/recorder/listener/floating_ip.go new file mode 100644 index 00000000000..155622a08a6 --- /dev/null +++ b/server/controller/recorder/listener/floating_ip.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * LiFloatingIPsed under the Apache LiFloatingIPse, Version 2.0 (the "LiFloatingIPse"); + * you may not use this file except in compliance with the LiFloatingIPse. + * You may obtain a copy of the LiFloatingIPse at + * + * http://www.apache.org/liFloatingIPses/LIFloatingIPSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the LiFloatingIPse is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the LiFloatingIPse for the specific language governing permissions and + * limitations under the LiFloatingIPse. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type FloatingIP struct { + cache *cache.Cache +} + +func NewFloatingIP(c *cache.Cache) *FloatingIP { + listener := &FloatingIP{ + cache: c, + } + return listener +} + +func (f *FloatingIP) OnUpdaterAdded(addedDBItems []*mysql.FloatingIP) { + f.cache.AddFloatingIPs(addedDBItems) +} + +func (f *FloatingIP) OnUpdaterUpdated(cloudItem *cloudmodel.FloatingIP, diffBase *cache.FloatingIP) { + diffBase.Update(cloudItem) +} + +func (f *FloatingIP) OnUpdaterDeleted(lcuuids []string) { + f.cache.DeleteFloatingIPs(lcuuids) +} diff --git a/server/controller/recorder/listener/host.go b/server/controller/recorder/listener/host.go index 95b214b162c..01a7f41840a 100644 --- a/server/controller/recorder/listener/host.go +++ b/server/controller/recorder/listener/host.go @@ -30,25 +30,25 @@ type Host struct { } func NewHost(c *cache.Cache, eq *queue.OverwriteQueue) *Host { - lisener := &Host{ + listener := &Host{ cache: c, eventProducer: event.NewHost(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *Host) OnUpdaterAdded(addedDBItems []*mysql.Host) { - // p.cache.AddHosts(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (h *Host) OnUpdaterAdded(addedDBItems []*mysql.Host) { + h.eventProducer.ProduceByAdd(addedDBItems) + h.cache.AddHosts(addedDBItems) } -func (p *Host) OnUpdaterUpdated(cloudItem *cloudmodel.Host, diffBase *cache.Host) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateHost(cloudItem) +func (h *Host) OnUpdaterUpdated(cloudItem *cloudmodel.Host, diffBase *cache.Host) { + h.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) + h.cache.UpdateHost(cloudItem) } -func (p *Host) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteHosts(lcuuids) +func (h *Host) OnUpdaterDeleted(lcuuids []string) { + h.eventProducer.ProduceByDelete(lcuuids) + h.cache.DeleteHosts(lcuuids) } diff --git a/server/controller/recorder/listener/lan_ip.go b/server/controller/recorder/listener/lan_ip.go index 19274551202..fbcf1bd22e7 100644 --- a/server/controller/recorder/listener/lan_ip.go +++ b/server/controller/recorder/listener/lan_ip.go @@ -30,25 +30,24 @@ type LANIP struct { } func NewLANIP(c *cache.Cache, eq *queue.OverwriteQueue) *LANIP { - lisener := &LANIP{ + listener := &LANIP{ cache: c, eventProducer: event.NewLANIP(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *LANIP) OnUpdaterAdded(addedDBItems []*mysql.LANIP) { - // p.cache.AddLANIPs(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (i *LANIP) OnUpdaterAdded(addedDBItems []*mysql.LANIP) { + i.eventProducer.ProduceByAdd(addedDBItems) + i.cache.AddLANIPs(addedDBItems) } -func (p *LANIP) OnUpdaterUpdated(cloudItem *cloudmodel.IP, diffBase *cache.LANIP) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateLANIP(cloudItem) +func (i *LANIP) OnUpdaterUpdated(cloudItem *cloudmodel.IP, diffBase *cache.LANIP) { + i.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) } -func (p *LANIP) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteLANIPs(lcuuids) +func (i *LANIP) OnUpdaterDeleted(lcuuids []string) { + i.eventProducer.ProduceByDelete(lcuuids) + i.cache.DeleteLANIPs(lcuuids) } diff --git a/server/controller/recorder/listener/lb.go b/server/controller/recorder/listener/lb.go index 2a1301dd069..be34142d023 100644 --- a/server/controller/recorder/listener/lb.go +++ b/server/controller/recorder/listener/lb.go @@ -30,25 +30,25 @@ type LB struct { } func NewLB(c *cache.Cache, eq *queue.OverwriteQueue) *LB { - lisener := &LB{ + listener := &LB{ cache: c, eventProducer: event.NewLB(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *LB) OnUpdaterAdded(addedDBItems []*mysql.LB) { - // p.cache.AddLBs(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (lb *LB) OnUpdaterAdded(addedDBItems []*mysql.LB) { + lb.eventProducer.ProduceByAdd(addedDBItems) + lb.cache.AddLBs(addedDBItems) } -func (p *LB) OnUpdaterUpdated(cloudItem *cloudmodel.LB, diffBase *cache.LB) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateLB(cloudItem) +func (lb *LB) OnUpdaterUpdated(cloudItem *cloudmodel.LB, diffBase *cache.LB) { + lb.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) + lb.cache.UpdateLB(cloudItem) } -func (p *LB) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteLBs(lcuuids) +func (lb *LB) OnUpdaterDeleted(lcuuids []string) { + lb.eventProducer.ProduceByDelete(lcuuids) + lb.cache.DeleteLBs(lcuuids) } diff --git a/server/controller/recorder/listener/lb_listener.go b/server/controller/recorder/listener/lb_listener.go new file mode 100644 index 00000000000..5dce530b58e --- /dev/null +++ b/server/controller/recorder/listener/lb_listener.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type LBListener struct { + cache *cache.Cache +} + +func NewLBListener(c *cache.Cache) *LBListener { + listener := &LBListener{ + cache: c, + } + return listener +} + +func (l *LBListener) OnUpdaterAdded(addedDBItems []*mysql.LBListener) { + l.cache.AddLBListeners(addedDBItems) +} + +func (l *LBListener) OnUpdaterUpdated(cloudItem *cloudmodel.LBListener, diffBase *cache.LBListener) { + diffBase.Update(cloudItem) +} + +func (l *LBListener) OnUpdaterDeleted(lcuuids []string) { + l.cache.DeleteLBListeners(lcuuids) +} diff --git a/server/controller/recorder/listener/lb_target_server.go b/server/controller/recorder/listener/lb_target_server.go new file mode 100644 index 00000000000..2944df05731 --- /dev/null +++ b/server/controller/recorder/listener/lb_target_server.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type LBTargetServer struct { + cache *cache.Cache +} + +func NewLBTargetServer(c *cache.Cache) *LBTargetServer { + listener := &LBTargetServer{ + cache: c, + } + return listener +} + +func (l *LBTargetServer) OnUpdaterAdded(addedDBItems []*mysql.LBTargetServer) { + l.cache.AddLBTargetServers(addedDBItems) +} + +func (l *LBTargetServer) OnUpdaterUpdated(cloudItem *cloudmodel.LBTargetServer, diffBase *cache.LBTargetServer) { + diffBase.Update(cloudItem) +} + +func (l *LBTargetServer) OnUpdaterDeleted(lcuuids []string) { + l.cache.DeleteLBTargetServers(lcuuids) +} diff --git a/server/controller/recorder/listener/lb_vm_connection.go b/server/controller/recorder/listener/lb_vm_connection.go new file mode 100644 index 00000000000..21e5c943f0d --- /dev/null +++ b/server/controller/recorder/listener/lb_vm_connection.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type LBVMConnection struct { + cache *cache.Cache +} + +func NewLBVMConnection(c *cache.Cache) *LBVMConnection { + listener := &LBVMConnection{ + cache: c, + } + return listener +} + +func (c *LBVMConnection) OnUpdaterAdded(addedDBItems []*mysql.LBVMConnection) { + c.cache.AddLBVMConnections(addedDBItems) +} + +func (c *LBVMConnection) OnUpdaterUpdated(cloudItem *cloudmodel.LBVMConnection, diffBase *cache.LBVMConnection) { +} + +func (c *LBVMConnection) OnUpdaterDeleted(lcuuids []string) { + c.cache.DeleteLBVMConnections(lcuuids) +} diff --git a/server/controller/recorder/listener/listener.go b/server/controller/recorder/listener/listener.go new file mode 100644 index 00000000000..199f00a4185 --- /dev/null +++ b/server/controller/recorder/listener/listener.go @@ -0,0 +1,27 @@ +/** + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + "github.com/deepflowio/deepflow/server/controller/recorder/constraint" +) + +type Listener[CT constraint.CloudModel, MT constraint.MySQLModel, BT constraint.DiffBase[MT]] interface { + OnUpdaterAdded(addedDBItems []*MT) + OnUpdaterUpdated(cloudItem *CT, diffBaseItem BT) + OnUpdaterDeleted(lcuuids []string) +} diff --git a/server/controller/recorder/listener/nat_gateway.go b/server/controller/recorder/listener/nat_gateway.go index 8a1e5be3c0f..1209013447c 100644 --- a/server/controller/recorder/listener/nat_gateway.go +++ b/server/controller/recorder/listener/nat_gateway.go @@ -30,25 +30,25 @@ type NATGateway struct { } func NewNATGateway(c *cache.Cache, eq *queue.OverwriteQueue) *NATGateway { - lisener := &NATGateway{ + listener := &NATGateway{ cache: c, eventProducer: event.NewNATGateway(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *NATGateway) OnUpdaterAdded(addedDBItems []*mysql.NATGateway) { - // p.cache.AddNATGateways(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (g *NATGateway) OnUpdaterAdded(addedDBItems []*mysql.NATGateway) { + g.eventProducer.ProduceByAdd(addedDBItems) + g.cache.AddNATGateways(addedDBItems) } -func (p *NATGateway) OnUpdaterUpdated(cloudItem *cloudmodel.NATGateway, diffBase *cache.NATGateway) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateNATGateway(cloudItem) +func (g *NATGateway) OnUpdaterUpdated(cloudItem *cloudmodel.NATGateway, diffBase *cache.NATGateway) { + g.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) + g.cache.UpdateNATGateway(cloudItem) } -func (p *NATGateway) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteNATGateways(lcuuids) +func (g *NATGateway) OnUpdaterDeleted(lcuuids []string) { + g.eventProducer.ProduceByDelete(lcuuids) + g.cache.DeleteNATGateways(lcuuids) } diff --git a/server/controller/recorder/listener/nat_rule.go b/server/controller/recorder/listener/nat_rule.go new file mode 100644 index 00000000000..24214ccd05c --- /dev/null +++ b/server/controller/recorder/listener/nat_rule.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type NATRule struct { + cache *cache.Cache +} + +func NewNATRule(c *cache.Cache) *NATRule { + listener := &NATRule{ + cache: c, + } + return listener +} + +func (r *NATRule) OnUpdaterAdded(addedDBItems []*mysql.NATRule) { + r.cache.AddNATRules(addedDBItems) +} + +func (r *NATRule) OnUpdaterUpdated(cloudItem *cloudmodel.NATRule, diffBase *cache.NATRule) { +} + +func (r *NATRule) OnUpdaterDeleted(lcuuids []string) { + r.cache.DeleteNATRules(lcuuids) +} diff --git a/server/controller/recorder/listener/nat_vm_connection.go b/server/controller/recorder/listener/nat_vm_connection.go new file mode 100644 index 00000000000..eddc06be8d6 --- /dev/null +++ b/server/controller/recorder/listener/nat_vm_connection.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type NATVMConnection struct { + cache *cache.Cache +} + +func NewNATVMConnection(c *cache.Cache) *NATVMConnection { + listener := &NATVMConnection{ + cache: c, + } + return listener +} + +func (c *NATVMConnection) OnUpdaterAdded(addedDBItems []*mysql.NATVMConnection) { + c.cache.AddNATVMConnections(addedDBItems) +} + +func (c *NATVMConnection) OnUpdaterUpdated(cloudItem *cloudmodel.NATVMConnection, diffBase *cache.NATVMConnection) { +} + +func (c *NATVMConnection) OnUpdaterDeleted(lcuuids []string) { + c.cache.DeleteNATVMConnections(lcuuids) +} diff --git a/server/controller/recorder/listener/network.go b/server/controller/recorder/listener/network.go new file mode 100644 index 00000000000..8f8db875bb9 --- /dev/null +++ b/server/controller/recorder/listener/network.go @@ -0,0 +1,47 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type Network struct { + cache *cache.Cache +} + +func NewNetwork(c *cache.Cache) *Network { + listener := &Network{ + cache: c, + } + return listener +} + +func (n *Network) OnUpdaterAdded(addedDBItems []*mysql.Network) { + n.cache.AddNetworks(addedDBItems) +} + +func (n *Network) OnUpdaterUpdated(cloudItem *cloudmodel.Network, diffBase *cache.Network) { + diffBase.Update(cloudItem) + n.cache.UpdateNetwork(cloudItem) +} + +func (n *Network) OnUpdaterDeleted(lcuuids []string) { + n.cache.DeleteNetworks(lcuuids) +} diff --git a/server/controller/recorder/listener/peer_connection.go b/server/controller/recorder/listener/peer_connection.go new file mode 100644 index 00000000000..beb8fa2804a --- /dev/null +++ b/server/controller/recorder/listener/peer_connection.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PeerConnections + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PeerConnection struct { + cache *cache.Cache +} + +func NewPeerConnection(c *cache.Cache) *PeerConnection { + listener := &PeerConnection{ + cache: c, + } + return listener +} + +func (c *PeerConnection) OnUpdaterAdded(addedDBItems []*mysql.PeerConnection) { + c.cache.AddPeerConnections(addedDBItems) +} + +func (c *PeerConnection) OnUpdaterUpdated(cloudItem *cloudmodel.PeerConnection, diffBase *cache.PeerConnection) { + diffBase.Update(cloudItem) +} + +func (c *PeerConnection) OnUpdaterDeleted(lcuuids []string) { + c.cache.DeletePeerConnections(lcuuids) +} diff --git a/server/controller/recorder/listener/pod.go b/server/controller/recorder/listener/pod.go index 02dcfe43e13..763ef61e71c 100644 --- a/server/controller/recorder/listener/pod.go +++ b/server/controller/recorder/listener/pod.go @@ -30,25 +30,25 @@ type Pod struct { } func NewPod(c *cache.Cache, eq *queue.OverwriteQueue) *Pod { - lisener := &Pod{ + listener := &Pod{ cache: c, eventProducer: event.NewPod(&c.ToolDataSet, eq), } - return lisener + return listener } func (p *Pod) OnUpdaterAdded(addedDBItems []*mysql.Pod) { - // p.cache.AddPods(addedDBItems) p.eventProducer.ProduceByAdd(addedDBItems) + p.cache.AddPods(addedDBItems) } func (p *Pod) OnUpdaterUpdated(cloudItem *cloudmodel.Pod, diffBase *cache.Pod) { p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdatePod(cloudItem) + diffBase.Update(cloudItem) + p.cache.UpdatePod(cloudItem) } func (p *Pod) OnUpdaterDeleted(lcuuids []string) { p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeletePods(lcuuids) + p.cache.DeletePods(lcuuids) } diff --git a/server/controller/recorder/listener/pod_cluster.go b/server/controller/recorder/listener/pod_cluster.go new file mode 100644 index 00000000000..abc91eaa981 --- /dev/null +++ b/server/controller/recorder/listener/pod_cluster.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PodClusters + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodCluster struct { + cache *cache.Cache +} + +func NewPodCluster(c *cache.Cache) *PodCluster { + listener := &PodCluster{ + cache: c, + } + return listener +} + +func (c *PodCluster) OnUpdaterAdded(addedDBItems []*mysql.PodCluster) { + c.cache.AddPodClusters(addedDBItems) +} + +func (c *PodCluster) OnUpdaterUpdated(cloudItem *cloudmodel.PodCluster, diffBase *cache.PodCluster) { + diffBase.Update(cloudItem) +} + +func (c *PodCluster) OnUpdaterDeleted(lcuuids []string) { + c.cache.DeletePodClusters(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_group.go b/server/controller/recorder/listener/pod_group.go new file mode 100644 index 00000000000..9875fe80451 --- /dev/null +++ b/server/controller/recorder/listener/pod_group.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PodGroups + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodGroup struct { + cache *cache.Cache +} + +func NewPodGroup(c *cache.Cache) *PodGroup { + listener := &PodGroup{ + cache: c, + } + return listener +} + +func (p *PodGroup) OnUpdaterAdded(addedDBItems []*mysql.PodGroup) { + p.cache.AddPodGroups(addedDBItems) +} + +func (p *PodGroup) OnUpdaterUpdated(cloudItem *cloudmodel.PodGroup, diffBase *cache.PodGroup) { + diffBase.Update(cloudItem) +} + +func (p *PodGroup) OnUpdaterDeleted(lcuuids []string) { + p.cache.DeletePodGroups(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_group_port.go b/server/controller/recorder/listener/pod_group_port.go new file mode 100644 index 00000000000..0fe2ff71311 --- /dev/null +++ b/server/controller/recorder/listener/pod_group_port.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PodGroupPorts + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodGroupPort struct { + cache *cache.Cache +} + +func NewPodGroupPort(c *cache.Cache) *PodGroupPort { + listener := &PodGroupPort{ + cache: c, + } + return listener +} + +func (p *PodGroupPort) OnUpdaterAdded(addedDBItems []*mysql.PodGroupPort) { + p.cache.AddPodGroupPorts(addedDBItems) +} + +func (p *PodGroupPort) OnUpdaterUpdated(cloudItem *cloudmodel.PodGroupPort, diffBase *cache.PodGroupPort) { + diffBase.Update(cloudItem) +} + +func (p *PodGroupPort) OnUpdaterDeleted(lcuuids []string) { + p.cache.DeletePodGroupPorts(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_ingress.go b/server/controller/recorder/listener/pod_ingress.go new file mode 100644 index 00000000000..1fedd54831f --- /dev/null +++ b/server/controller/recorder/listener/pod_ingress.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PodIngresss + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodIngress struct { + cache *cache.Cache +} + +func NewPodIngress(c *cache.Cache) *PodIngress { + listener := &PodIngress{ + cache: c, + } + return listener +} + +func (i *PodIngress) OnUpdaterAdded(addedDBItems []*mysql.PodIngress) { + i.cache.AddPodIngresses(addedDBItems) +} + +func (i *PodIngress) OnUpdaterUpdated(cloudItem *cloudmodel.PodIngress, diffBase *cache.PodIngress) { + diffBase.Update(cloudItem) +} + +func (i *PodIngress) OnUpdaterDeleted(lcuuids []string) { + i.cache.DeletePodIngresses(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_ingress_rule.go b/server/controller/recorder/listener/pod_ingress_rule.go new file mode 100644 index 00000000000..3c3ab776924 --- /dev/null +++ b/server/controller/recorder/listener/pod_ingress_rule.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan PodIngressRules + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodIngressRule struct { + cache *cache.Cache +} + +func NewPodIngressRule(c *cache.Cache) *PodIngressRule { + listener := &PodIngressRule{ + cache: c, + } + return listener +} + +func (r *PodIngressRule) OnUpdaterAdded(addedDBItems []*mysql.PodIngressRule) { + r.cache.AddPodIngressRules(addedDBItems) +} + +func (r *PodIngressRule) OnUpdaterUpdated(cloudItem *cloudmodel.PodIngressRule, diffBase *cache.PodIngressRule) { +} + +func (r *PodIngressRule) OnUpdaterDeleted(lcuuids []string) { + r.cache.DeletePodIngressRules(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_ingress_rule_backend.go b/server/controller/recorder/listener/pod_ingress_rule_backend.go new file mode 100644 index 00000000000..87c21b3f135 --- /dev/null +++ b/server/controller/recorder/listener/pod_ingress_rule_backend.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan PodIngressRuleBackends + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodIngressRuleBackend struct { + cache *cache.Cache +} + +func NewPodIngressRuleBackend(c *cache.Cache) *PodIngressRuleBackend { + listener := &PodIngressRuleBackend{ + cache: c, + } + return listener +} + +func (b *PodIngressRuleBackend) OnUpdaterAdded(addedDBItems []*mysql.PodIngressRuleBackend) { + b.cache.AddPodIngressRuleBackends(addedDBItems) +} + +func (b *PodIngressRuleBackend) OnUpdaterUpdated(cloudItem *cloudmodel.PodIngressRuleBackend, diffBase *cache.PodIngressRuleBackend) { +} + +func (b *PodIngressRuleBackend) OnUpdaterDeleted(lcuuids []string) { + b.cache.DeletePodIngressRuleBackends(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_namespace.go b/server/controller/recorder/listener/pod_namespace.go new file mode 100644 index 00000000000..741bd94233c --- /dev/null +++ b/server/controller/recorder/listener/pod_namespace.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PodNamespaces + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodNamespace struct { + cache *cache.Cache +} + +func NewPodNamespace(c *cache.Cache) *PodNamespace { + listener := &PodNamespace{ + cache: c, + } + return listener +} + +func (n *PodNamespace) OnUpdaterAdded(addedDBItems []*mysql.PodNamespace) { + n.cache.AddPodNamespaces(addedDBItems) +} + +func (n *PodNamespace) OnUpdaterUpdated(cloudItem *cloudmodel.PodNamespace, diffBase *cache.PodNamespace) { + diffBase.Update(cloudItem) +} + +func (n *PodNamespace) OnUpdaterDeleted(lcuuids []string) { + n.cache.DeletePodNamespaces(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_node.go b/server/controller/recorder/listener/pod_node.go index 8fe83e1e57c..706a95c48d5 100644 --- a/server/controller/recorder/listener/pod_node.go +++ b/server/controller/recorder/listener/pod_node.go @@ -30,25 +30,25 @@ type PodNode struct { } func NewPodNode(c *cache.Cache, eq *queue.OverwriteQueue) *PodNode { - lisener := &PodNode{ + listener := &PodNode{ cache: c, eventProducer: event.NewPodNode(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *PodNode) OnUpdaterAdded(addedDBItems []*mysql.PodNode) { - // p.cache.AddPodNodes(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (n *PodNode) OnUpdaterAdded(addedDBItems []*mysql.PodNode) { + n.eventProducer.ProduceByAdd(addedDBItems) + n.cache.AddPodNodes(addedDBItems) } -func (p *PodNode) OnUpdaterUpdated(cloudItem *cloudmodel.PodNode, diffBase *cache.PodNode) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdatePodNode(cloudItem) +func (n *PodNode) OnUpdaterUpdated(cloudItem *cloudmodel.PodNode, diffBase *cache.PodNode) { + n.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) + n.cache.UpdatePodNode(cloudItem) } -func (p *PodNode) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeletePodNodes(lcuuids) +func (n *PodNode) OnUpdaterDeleted(lcuuids []string) { + n.eventProducer.ProduceByDelete(lcuuids) + n.cache.DeletePodNodes(lcuuids) } diff --git a/server/controller/recorder/listener/pod_replica_set.go b/server/controller/recorder/listener/pod_replica_set.go new file mode 100644 index 00000000000..afb6b2dfffc --- /dev/null +++ b/server/controller/recorder/listener/pod_replica_set.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PodReplicaSets + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodReplicaSet struct { + cache *cache.Cache +} + +func NewPodReplicaSet(c *cache.Cache) *PodReplicaSet { + listener := &PodReplicaSet{ + cache: c, + } + return listener +} + +func (prs *PodReplicaSet) OnUpdaterAdded(addedDBItems []*mysql.PodReplicaSet) { + prs.cache.AddPodReplicaSets(addedDBItems) +} + +func (prs *PodReplicaSet) OnUpdaterUpdated(cloudItem *cloudmodel.PodReplicaSet, diffBase *cache.PodReplicaSet) { + diffBase.Update(cloudItem) +} + +func (prs *PodReplicaSet) OnUpdaterDeleted(lcuuids []string) { + prs.cache.DeletePodReplicaSets(lcuuids) +} diff --git a/server/controller/recorder/listener/pod_service.go b/server/controller/recorder/listener/pod_service.go index d894a3f9136..c30fa6ed8fd 100644 --- a/server/controller/recorder/listener/pod_service.go +++ b/server/controller/recorder/listener/pod_service.go @@ -30,25 +30,25 @@ type PodService struct { } func NewPodService(c *cache.Cache, eq *queue.OverwriteQueue) *PodService { - lisener := &PodService{ + listener := &PodService{ cache: c, eventProducer: event.NewPodService(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *PodService) OnUpdaterAdded(addedDBItems []*mysql.PodService) { - // p.cache.AddPodServices(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (ps *PodService) OnUpdaterAdded(addedDBItems []*mysql.PodService) { + ps.eventProducer.ProduceByAdd(addedDBItems) + ps.cache.AddPodServices(addedDBItems) } -func (p *PodService) OnUpdaterUpdated(cloudItem *cloudmodel.PodService, diffBase *cache.PodService) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdatePodService(cloudItem) +func (ps *PodService) OnUpdaterUpdated(cloudItem *cloudmodel.PodService, diffBase *cache.PodService) { + ps.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) + ps.cache.UpdatePodService(cloudItem) } -func (p *PodService) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeletePodServices(lcuuids) +func (ps *PodService) OnUpdaterDeleted(lcuuids []string) { + ps.eventProducer.ProduceByDelete(lcuuids) + ps.cache.DeletePodServices(lcuuids) } diff --git a/server/controller/recorder/listener/pod_service_port.go b/server/controller/recorder/listener/pod_service_port.go new file mode 100644 index 00000000000..b5bb3dcd8d1 --- /dev/null +++ b/server/controller/recorder/listener/pod_service_port.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan PodServicePorts + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PodServicePort struct { + cache *cache.Cache +} + +func NewPodServicePort(c *cache.Cache) *PodServicePort { + listener := &PodServicePort{ + cache: c, + } + return listener +} + +func (psp *PodServicePort) OnUpdaterAdded(addedDBItems []*mysql.PodServicePort) { + psp.cache.AddPodServicePorts(addedDBItems) +} + +func (psp *PodServicePort) OnUpdaterUpdated(cloudItem *cloudmodel.PodServicePort, diffBase *cache.PodServicePort) { + diffBase.Update(cloudItem) +} + +func (psp *PodServicePort) OnUpdaterDeleted(lcuuids []string) { + psp.cache.DeletePodServicePorts(lcuuids) +} diff --git a/server/controller/recorder/listener/process.go b/server/controller/recorder/listener/process.go index fe550a7d789..f942867c293 100644 --- a/server/controller/recorder/listener/process.go +++ b/server/controller/recorder/listener/process.go @@ -39,12 +39,15 @@ func NewProcess(c *cache.Cache, eq *queue.OverwriteQueue) *Process { func (p *Process) OnUpdaterAdded(addedDBItems []*mysql.Process) { p.eventProducer.ProduceByAdd(addedDBItems) + p.cache.AddProcesses(addedDBItems) } func (p *Process) OnUpdaterUpdated(cloudItem *cloudmodel.Process, diffBase *cache.Process) { p.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) } func (p *Process) OnUpdaterDeleted(lcuuids []string) { p.eventProducer.ProduceByDelete(lcuuids) + p.cache.DeleteProcesses(lcuuids) } diff --git a/server/controller/recorder/listener/prometheus_target.go b/server/controller/recorder/listener/prometheus_target.go new file mode 100644 index 00000000000..6e312dda2c5 --- /dev/null +++ b/server/controller/recorder/listener/prometheus_target.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type PrometheusTarget struct { + cache *cache.Cache +} + +func NewPrometheusTarget(c *cache.Cache) *PrometheusTarget { + listener := &PrometheusTarget{ + cache: c, + } + return listener +} + +func (p *PrometheusTarget) OnUpdaterAdded(addedDBItems []*mysql.PrometheusTarget) { + p.cache.AddPrometheusTargets(addedDBItems) +} + +func (p *PrometheusTarget) OnUpdaterUpdated(cloudItem *cloudmodel.PrometheusTarget, diffBase *cache.PrometheusTarget) { + diffBase.Update(cloudItem) +} + +func (p *PrometheusTarget) OnUpdaterDeleted(lcuuids []string) { + p.cache.DeletePrometheusTargets(lcuuids) +} diff --git a/server/controller/recorder/listener/rds_instance.go b/server/controller/recorder/listener/rds_instance.go index 8a67df0c959..49e8839c778 100644 --- a/server/controller/recorder/listener/rds_instance.go +++ b/server/controller/recorder/listener/rds_instance.go @@ -30,24 +30,24 @@ type RDSInstance struct { } func NewRDSInstance(c *cache.Cache, eq *queue.OverwriteQueue) *RDSInstance { - lisener := &RDSInstance{ + listener := &RDSInstance{ cache: c, eventProducer: event.NewRDSInstance(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *RDSInstance) OnUpdaterAdded(addedDBItems []*mysql.RDSInstance) { - // p.cache.AddRDSInstances(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (r *RDSInstance) OnUpdaterAdded(addedDBItems []*mysql.RDSInstance) { + r.eventProducer.ProduceByAdd(addedDBItems) + r.cache.AddRDSInstances(addedDBItems) } -func (p *RDSInstance) OnUpdaterUpdated(cloudItem *cloudmodel.RDSInstance, diffBase *cache.RDSInstance) { - // diffBase.Update(cloudItem) - // p.cache.UpdateRDSInstance(cloudItem) +func (r *RDSInstance) OnUpdaterUpdated(cloudItem *cloudmodel.RDSInstance, diffBase *cache.RDSInstance) { + diffBase.Update(cloudItem) + r.cache.UpdateRDSInstance(cloudItem) } -func (p *RDSInstance) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteRDSInstances(lcuuids) +func (r *RDSInstance) OnUpdaterDeleted(lcuuids []string) { + r.eventProducer.ProduceByDelete(lcuuids) + r.cache.DeleteRDSInstances(lcuuids) } diff --git a/server/controller/recorder/listener/redis_instance.go b/server/controller/recorder/listener/redis_instance.go index 8c8cc55a270..2d90a81a957 100644 --- a/server/controller/recorder/listener/redis_instance.go +++ b/server/controller/recorder/listener/redis_instance.go @@ -30,24 +30,24 @@ type RedisInstance struct { } func NewRedisInstance(c *cache.Cache, eq *queue.OverwriteQueue) *RedisInstance { - lisener := &RedisInstance{ + listener := &RedisInstance{ cache: c, eventProducer: event.NewRedisInstance(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *RedisInstance) OnUpdaterAdded(addedDBItems []*mysql.RedisInstance) { - // p.cache.AddRedisInstances(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (ri *RedisInstance) OnUpdaterAdded(addedDBItems []*mysql.RedisInstance) { + ri.eventProducer.ProduceByAdd(addedDBItems) + ri.cache.AddRedisInstances(addedDBItems) } -func (p *RedisInstance) OnUpdaterUpdated(cloudItem *cloudmodel.RedisInstance, diffBase *cache.RedisInstance) { - // diffBase.Update(cloudItem) - // p.cache.UpdateRedisInstance(cloudItem) +func (ri *RedisInstance) OnUpdaterUpdated(cloudItem *cloudmodel.RedisInstance, diffBase *cache.RedisInstance) { + diffBase.Update(cloudItem) + ri.cache.UpdateRedisInstance(cloudItem) } -func (p *RedisInstance) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteRedisInstances(lcuuids) +func (ri *RedisInstance) OnUpdaterDeleted(lcuuids []string) { + ri.eventProducer.ProduceByDelete(lcuuids) + ri.cache.DeleteRedisInstances(lcuuids) } diff --git a/server/controller/recorder/listener/region.go b/server/controller/recorder/listener/region.go new file mode 100644 index 00000000000..df88ce5febb --- /dev/null +++ b/server/controller/recorder/listener/region.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type Region struct { + cache *cache.Cache +} + +func NewRegion(c *cache.Cache) *Region { + listener := &Region{ + cache: c, + } + return listener +} + +func (r *Region) OnUpdaterAdded(addedDBItems []*mysql.Region) { + r.cache.AddRegions(addedDBItems) +} + +func (r *Region) OnUpdaterUpdated(cloudItem *cloudmodel.Region, diffBase *cache.Region) { + diffBase.Update(cloudItem) +} + +func (r *Region) OnUpdaterDeleted(lcuuids []string) { + r.cache.DeleteRegions(lcuuids) +} diff --git a/server/controller/recorder/listener/routing_table.go b/server/controller/recorder/listener/routing_table.go new file mode 100644 index 00000000000..0801e965e9a --- /dev/null +++ b/server/controller/recorder/listener/routing_table.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type RoutingTable struct { + cache *cache.Cache +} + +func NewRoutingTable(c *cache.Cache) *RoutingTable { + listener := &RoutingTable{ + cache: c, + } + return listener +} + +func (rt *RoutingTable) OnUpdaterAdded(addedDBItems []*mysql.RoutingTable) { + rt.cache.AddRoutingTables(addedDBItems) +} + +func (rt *RoutingTable) OnUpdaterUpdated(cloudItem *cloudmodel.RoutingTable, diffBase *cache.RoutingTable) { + diffBase.Update(cloudItem) +} + +func (rt *RoutingTable) OnUpdaterDeleted(lcuuids []string) { + rt.cache.DeleteRoutingTables(lcuuids) +} diff --git a/server/controller/recorder/listener/security_group.go b/server/controller/recorder/listener/security_group.go new file mode 100644 index 00000000000..8e1bbc5fb05 --- /dev/null +++ b/server/controller/recorder/listener/security_group.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type SecurityGroup struct { + cache *cache.Cache +} + +func NewSecurityGroup(c *cache.Cache) *SecurityGroup { + listener := &SecurityGroup{ + cache: c, + } + return listener +} + +func (sg *SecurityGroup) OnUpdaterAdded(addedDBItems []*mysql.SecurityGroup) { + sg.cache.AddSecurityGroups(addedDBItems) +} + +func (sg *SecurityGroup) OnUpdaterUpdated(cloudItem *cloudmodel.SecurityGroup, diffBase *cache.SecurityGroup) { + diffBase.Update(cloudItem) +} + +func (sg *SecurityGroup) OnUpdaterDeleted(lcuuids []string) { + sg.cache.DeleteSecurityGroups(lcuuids) +} diff --git a/server/controller/recorder/listener/security_group_rule.go b/server/controller/recorder/listener/security_group_rule.go new file mode 100644 index 00000000000..0b2fe961618 --- /dev/null +++ b/server/controller/recorder/listener/security_group_rule.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type SecurityGroupRule struct { + cache *cache.Cache +} + +func NewSecurityGroupRule(c *cache.Cache) *SecurityGroupRule { + listener := &SecurityGroupRule{ + cache: c, + } + return listener +} + +func (r *SecurityGroupRule) OnUpdaterAdded(addedDBItems []*mysql.SecurityGroupRule) { + r.cache.AddSecurityGroupRules(addedDBItems) +} + +func (r *SecurityGroupRule) OnUpdaterUpdated(cloudItem *cloudmodel.SecurityGroupRule, diffBase *cache.SecurityGroupRule) { + diffBase.Update(cloudItem) +} + +func (r *SecurityGroupRule) OnUpdaterDeleted(lcuuids []string) { + r.cache.DeleteSecurityGroupRules(lcuuids) +} diff --git a/server/controller/recorder/listener/sub_domain.go b/server/controller/recorder/listener/sub_domain.go index b17b8ddf300..c3e5d2c0e1f 100644 --- a/server/controller/recorder/listener/sub_domain.go +++ b/server/controller/recorder/listener/sub_domain.go @@ -17,23 +17,49 @@ package listener import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" "github.com/deepflowio/deepflow/server/controller/recorder/cache" "github.com/deepflowio/deepflow/server/controller/recorder/event" "github.com/deepflowio/deepflow/server/libs/queue" ) +// SubDomain is used to listen to the changes of the SubDomain resource itself type SubDomain struct { + cache *cache.Cache +} + +func NewSubDomain(c *cache.Cache) *SubDomain { + return &SubDomain{ + cache: c, + } +} + +func (sd *SubDomain) OnUpdaterAdded(addedDBItems []*mysql.SubDomain) { + sd.cache.AddSubDomains(addedDBItems) +} + +func (sd *SubDomain) OnUpdaterUpdated(cloudItem *cloudmodel.SubDomain, diffBase *cache.SubDomain) { + diffBase.Update(cloudItem) +} + +func (sd *SubDomain) OnUpdaterDeleted(lcuuids []string) { + sd.cache.DeleteSubDomains(lcuuids) +} + +// WholeSubDomain is used to listen to the changes of the whole SubDomain related resources +type WholeSubDomain struct { cache *cache.Cache eventProducer *event.SubDomain } -func NewSubDomain(domainLcuuid, subDomainLcuuid string, c *cache.Cache, eq *queue.OverwriteQueue) *SubDomain { - return &SubDomain{ +func NewWholeSubDomain(domainLcuuid, subDomainLcuuid string, c *cache.Cache, eq *queue.OverwriteQueue) *WholeSubDomain { + return &WholeSubDomain{ cache: c, eventProducer: event.NewSubDomain(domainLcuuid, subDomainLcuuid, &c.ToolDataSet, eq), } } -func (p *SubDomain) OnUpdatersCompeleted() { - p.eventProducer.ProduceFromMySQL() +func (wsd *WholeSubDomain) OnUpdatersCompleted() { + wsd.eventProducer.ProduceFromMySQL() } diff --git a/server/controller/recorder/listener/subnet.go b/server/controller/recorder/listener/subnet.go new file mode 100644 index 00000000000..f4b38c13324 --- /dev/null +++ b/server/controller/recorder/listener/subnet.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type Subnet struct { + cache *cache.Cache +} + +func NewSubnet(c *cache.Cache) *Subnet { + return &Subnet{ + cache: c, + } +} + +func (s *Subnet) OnUpdaterAdded(addedDBItems []*mysql.Subnet) { + s.cache.AddSubnets(addedDBItems) +} + +func (s *Subnet) OnUpdaterUpdated(cloudItem *cloudmodel.Subnet, diffBase *cache.Subnet) { + diffBase.Update(cloudItem) +} + +func (s *Subnet) OnUpdaterDeleted(lcuuids []string) { + s.cache.DeleteSubnets(lcuuids) +} diff --git a/server/controller/recorder/listener/vinterface.go b/server/controller/recorder/listener/vinterface.go new file mode 100644 index 00000000000..fea11911928 --- /dev/null +++ b/server/controller/recorder/listener/vinterface.go @@ -0,0 +1,46 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type VInterface struct { + cache *cache.Cache +} + +func NewVInterface(c *cache.Cache) *VInterface { + return &VInterface{ + cache: c, + } +} + +func (i *VInterface) OnUpdaterAdded(addedDBItems []*mysql.VInterface) { + i.cache.AddVInterfaces(addedDBItems) +} + +func (i *VInterface) OnUpdaterUpdated(cloudItem *cloudmodel.VInterface, diffBase *cache.VInterface) { + diffBase.Update(cloudItem) + i.cache.UpdateVInterface(cloudItem) +} + +func (i *VInterface) OnUpdaterDeleted(lcuuids []string) { + i.cache.DeleteVInterfaces(lcuuids) +} diff --git a/server/controller/recorder/listener/vm.go b/server/controller/recorder/listener/vm.go index 54042e932ca..09391808d8a 100644 --- a/server/controller/recorder/listener/vm.go +++ b/server/controller/recorder/listener/vm.go @@ -30,25 +30,25 @@ type VM struct { } func NewVM(c *cache.Cache, eq *queue.OverwriteQueue) *VM { - lisener := &VM{ + listener := &VM{ cache: c, eventProducer: event.NewVM(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *VM) OnUpdaterAdded(addedDBItems []*mysql.VM) { - // p.cache.AddVMs(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (vm *VM) OnUpdaterAdded(addedDBItems []*mysql.VM) { + vm.eventProducer.ProduceByAdd(addedDBItems) + vm.cache.AddVMs(addedDBItems) } -func (p *VM) OnUpdaterUpdated(cloudItem *cloudmodel.VM, diffBase *cache.VM) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateVM(cloudItem) +func (vm *VM) OnUpdaterUpdated(cloudItem *cloudmodel.VM, diffBase *cache.VM) { + vm.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) + vm.cache.UpdateVM(cloudItem) } -func (p *VM) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteVMs(lcuuids) +func (vm *VM) OnUpdaterDeleted(lcuuids []string) { + vm.eventProducer.ProduceByDelete(lcuuids) + vm.cache.DeleteVMs(lcuuids) } diff --git a/server/controller/recorder/listener/vm_pod_node_connection.go b/server/controller/recorder/listener/vm_pod_node_connection.go new file mode 100644 index 00000000000..72b5115321f --- /dev/null +++ b/server/controller/recorder/listener/vm_pod_node_connection.go @@ -0,0 +1,44 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type VMPodNodeConnection struct { + cache *cache.Cache +} + +func NewVMPodNodeConnection(c *cache.Cache) *VMPodNodeConnection { + return &VMPodNodeConnection{ + cache: c, + } +} + +func (c *VMPodNodeConnection) OnUpdaterAdded(addedDBItems []*mysql.VMPodNodeConnection) { + c.cache.AddVMPodNodeConnections(addedDBItems) +} + +func (c *VMPodNodeConnection) OnUpdaterUpdated(cloudItem *cloudmodel.VMPodNodeConnection, diffBase *cache.VMPodNodeConnection) { +} + +func (c *VMPodNodeConnection) OnUpdaterDeleted(lcuuids []string) { + c.cache.DeleteVMPodNodeConnections(lcuuids) +} diff --git a/server/controller/recorder/listener/vm_security_group.go b/server/controller/recorder/listener/vm_security_group.go new file mode 100644 index 00000000000..bc628814ea8 --- /dev/null +++ b/server/controller/recorder/listener/vm_security_group.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type VMSecurityGroup struct { + cache *cache.Cache +} + +func NewVMSecurityGroup(c *cache.Cache) *VMSecurityGroup { + return &VMSecurityGroup{ + cache: c, + } +} + +func (v *VMSecurityGroup) OnUpdaterAdded(addedDBItems []*mysql.VMSecurityGroup) { + v.cache.AddVMSecurityGroups(addedDBItems) +} + +func (v *VMSecurityGroup) OnUpdaterUpdated(cloudItem *cloudmodel.VMSecurityGroup, diffBase *cache.VMSecurityGroup) { + diffBase.Update(cloudItem) +} + +func (v *VMSecurityGroup) OnUpdaterDeleted(lcuuids []string) { + v.cache.DeleteVMSecurityGroups(lcuuids) +} diff --git a/server/controller/recorder/listener/vpc.go b/server/controller/recorder/listener/vpc.go new file mode 100644 index 00000000000..e6d6eb94e63 --- /dev/null +++ b/server/controller/recorder/listener/vpc.go @@ -0,0 +1,45 @@ +/* + * Copyright (c) 2023 Yunshan Networks + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package listener + +import ( + cloudmodel "github.com/deepflowio/deepflow/server/controller/cloud/model" + "github.com/deepflowio/deepflow/server/controller/db/mysql" + "github.com/deepflowio/deepflow/server/controller/recorder/cache" +) + +type VPC struct { + cache *cache.Cache +} + +func NewVPC(c *cache.Cache) *VPC { + return &VPC{ + cache: c, + } +} + +func (v *VPC) OnUpdaterAdded(addedDBItems []*mysql.VPC) { + v.cache.AddVPCs(addedDBItems) +} + +func (v *VPC) OnUpdaterUpdated(cloudItem *cloudmodel.VPC, diffBase *cache.VPC) { + diffBase.Update(cloudItem) +} + +func (v *VPC) OnUpdaterDeleted(lcuuids []string) { + v.cache.DeleteVPCs(lcuuids) +} diff --git a/server/controller/recorder/listener/vrouter.go b/server/controller/recorder/listener/vrouter.go index 12908231292..41d5e552a14 100644 --- a/server/controller/recorder/listener/vrouter.go +++ b/server/controller/recorder/listener/vrouter.go @@ -30,25 +30,25 @@ type VRouter struct { } func NewVRouter(c *cache.Cache, eq *queue.OverwriteQueue) *VRouter { - lisener := &VRouter{ + listener := &VRouter{ cache: c, eventProducer: event.NewVRouter(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *VRouter) OnUpdaterAdded(addedDBItems []*mysql.VRouter) { - // p.cache.AddVRouters(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (r *VRouter) OnUpdaterAdded(addedDBItems []*mysql.VRouter) { + r.eventProducer.ProduceByAdd(addedDBItems) + r.cache.AddVRouters(addedDBItems) } -func (p *VRouter) OnUpdaterUpdated(cloudItem *cloudmodel.VRouter, diffBase *cache.VRouter) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateVRouter(cloudItem) +func (r *VRouter) OnUpdaterUpdated(cloudItem *cloudmodel.VRouter, diffBase *cache.VRouter) { + r.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) + r.cache.UpdateVRouter(cloudItem) } -func (p *VRouter) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteVRouters(lcuuids) +func (r *VRouter) OnUpdaterDeleted(lcuuids []string) { + r.eventProducer.ProduceByDelete(lcuuids) + r.cache.DeleteVRouters(lcuuids) } diff --git a/server/controller/recorder/listener/wan_ip.go b/server/controller/recorder/listener/wan_ip.go index 5cd7fa0e8fc..c5d30a84952 100644 --- a/server/controller/recorder/listener/wan_ip.go +++ b/server/controller/recorder/listener/wan_ip.go @@ -30,25 +30,24 @@ type WANIP struct { } func NewWANIP(c *cache.Cache, eq *queue.OverwriteQueue) *WANIP { - lisener := &WANIP{ + listener := &WANIP{ cache: c, eventProducer: event.NewWANIP(&c.ToolDataSet, eq), } - return lisener + return listener } -func (p *WANIP) OnUpdaterAdded(addedDBItems []*mysql.WANIP) { - // p.cache.AddWANIPs(addedDBItems) - p.eventProducer.ProduceByAdd(addedDBItems) +func (i *WANIP) OnUpdaterAdded(addedDBItems []*mysql.WANIP) { + i.eventProducer.ProduceByAdd(addedDBItems) + i.cache.AddWANIPs(addedDBItems) } -func (p *WANIP) OnUpdaterUpdated(cloudItem *cloudmodel.IP, diffBase *cache.WANIP) { - p.eventProducer.ProduceByUpdate(cloudItem, diffBase) - // diffBase.Update(cloudItem) - // p.cache.UpdateWANIP(cloudItem) +func (i *WANIP) OnUpdaterUpdated(cloudItem *cloudmodel.IP, diffBase *cache.WANIP) { + i.eventProducer.ProduceByUpdate(cloudItem, diffBase) + diffBase.Update(cloudItem) } -func (p *WANIP) OnUpdaterDeleted(lcuuids []string) { - p.eventProducer.ProduceByDelete(lcuuids) - // p.cache.DeleteWANIPs(lcuuids) +func (i *WANIP) OnUpdaterDeleted(lcuuids []string) { + i.eventProducer.ProduceByDelete(lcuuids) + i.cache.DeleteWANIPs(lcuuids) } diff --git a/server/controller/recorder/recorder.go b/server/controller/recorder/recorder.go index a7dbc8477cf..dafb605ecf7 100644 --- a/server/controller/recorder/recorder.go +++ b/server/controller/recorder/recorder.go @@ -164,123 +164,104 @@ func (r *Recorder) refreshDomain(cloudData cloudmodel.Resource) { // 指定创建及更新操作的资源顺序 // 基本原则：无依赖资源优先；实时性需求高资源优先 - listener := listener.NewDomain(r.domainLcuuid, r.cacheMng.DomainCache, r.eventQueue) + listener := listener.NewWholeDomain(r.domainLcuuid, r.cacheMng.DomainCache, r.eventQueue) domainUpdatersInUpdateOrder := r.getDomainUpdatersInOrder(cloudData) - r.executeUpdators(domainUpdatersInUpdateOrder) - listener.OnUpdatersCompeleted() + r.executeUpdaters(domainUpdatersInUpdateOrder) + listener.OnUpdatersCompleted() log.Infof("domain (lcuuid: %s, name: %s) refresh completed", r.domainLcuuid, r.domainName) } func (r *Recorder) getDomainUpdatersInOrder(cloudData cloudmodel.Resource) []updater.ResourceUpdater { - podListener := listener.NewPod(r.cacheMng.DomainCache, r.eventQueue) - pod := updater.NewPod(r.cacheMng.DomainCache, cloudData.Pods) - pod.RegisterCallbacks(podListener.OnUpdaterAdded, podListener.OnUpdaterUpdated, podListener.OnUpdaterDeleted) - - podNodeListener := listener.NewPodNode(r.cacheMng.DomainCache, r.eventQueue) - podNode := updater.NewPodNode(r.cacheMng.DomainCache, cloudData.PodNodes) - podNode.RegisterCallbacks( - podNodeListener.OnUpdaterAdded, podNodeListener.OnUpdaterUpdated, podNodeListener.OnUpdaterDeleted) - - podServiceListener := listener.NewPodService(r.cacheMng.DomainCache, r.eventQueue) - podService := updater.NewPodService(r.cacheMng.DomainCache, cloudData.PodServices) - podService.RegisterCallbacks( - podServiceListener.OnUpdaterAdded, podServiceListener.OnUpdaterUpdated, podServiceListener.OnUpdaterDeleted) - ip := updater.NewIP(r.cacheMng.DomainCache, cloudData.IPs, nil) - lanIPListener := listener.NewLANIP(r.cacheMng.DomainCache, r.eventQueue) - ip.GetLANIP().RegisterCallbacks( - lanIPListener.OnUpdaterAdded, lanIPListener.OnUpdaterUpdated, lanIPListener.OnUpdaterDeleted) - wanIPListener := listener.NewWANIP(r.cacheMng.DomainCache, r.eventQueue) - ip.GetWANIP().RegisterCallbacks( - wanIPListener.OnUpdaterAdded, wanIPListener.OnUpdaterUpdated, wanIPListener.OnUpdaterDeleted) - - dhcpPortListener := listener.NewDHCPPort(r.cacheMng.DomainCache, r.eventQueue) - dhcpPort := updater.NewDHCPPort(r.cacheMng.DomainCache, cloudData.DHCPPorts) - dhcpPort.RegisterCallbacks( - dhcpPortListener.OnUpdaterAdded, dhcpPortListener.OnUpdaterUpdated, dhcpPortListener.OnUpdaterDeleted) - - hostListener := listener.NewHost(r.cacheMng.DomainCache, r.eventQueue) - host := updater.NewHost(r.cacheMng.DomainCache, cloudData.Hosts) - host.RegisterCallbacks( - hostListener.OnUpdaterAdded, hostListener.OnUpdaterUpdated, hostListener.OnUpdaterDeleted) - - lbListener := listener.NewLB(r.cacheMng.DomainCache, r.eventQueue) - lb := updater.NewLB(r.cacheMng.DomainCache, cloudData.LBs) - lb.RegisterCallbacks(lbListener.OnUpdaterAdded, lbListener.OnUpdaterUpdated, lbListener.OnUpdaterDeleted) - - natGateWayListener := listener.NewNATGateway(r.cacheMng.DomainCache, r.eventQueue) - natGateway := updater.NewNATGateway(r.cacheMng.DomainCache, cloudData.NATGateways) - natGateway.RegisterCallbacks( - natGateWayListener.OnUpdaterAdded, natGateWayListener.OnUpdaterUpdated, natGateWayListener.OnUpdaterDeleted) - - rdsInstanceListener := listener.NewRDSInstance(r.cacheMng.DomainCache, r.eventQueue) - rdsInstance := updater.NewRDSInstance(r.cacheMng.DomainCache, cloudData.RDSInstances) - rdsInstance.RegisterCallbacks( - rdsInstanceListener.OnUpdaterAdded, rdsInstanceListener.OnUpdaterUpdated, rdsInstanceListener.OnUpdaterDeleted) - - redisInstanceListener := listener.NewRedisInstance(r.cacheMng.DomainCache, r.eventQueue) - redisInstance := updater.NewRedisInstance(r.cacheMng.DomainCache, cloudData.RedisInstances) - redisInstance.RegisterCallbacks(redisInstanceListener.OnUpdaterAdded, - redisInstanceListener.OnUpdaterUpdated, redisInstanceListener.OnUpdaterDeleted) - - vmListener := listener.NewVM(r.cacheMng.DomainCache, r.eventQueue) - vm := updater.NewVM(r.cacheMng.DomainCache, cloudData.VMs) - vm.RegisterCallbacks(vmListener.OnUpdaterAdded, vmListener.OnUpdaterUpdated, vmListener.OnUpdaterDeleted) - - vRouterListener := listener.NewVRouter(r.cacheMng.DomainCache, r.eventQueue) - vRouter := updater.NewVRouter(r.cacheMng.DomainCache, cloudData.VRouters) - vRouter.RegisterCallbacks( - vRouterListener.OnUpdaterAdded, vRouterListener.OnUpdaterUpdated, vRouterListener.OnUpdaterDeleted) - - processListener := listener.NewProcess(r.cacheMng.DomainCache, r.eventQueue) - process := updater.NewProcess(r.cacheMng.DomainCache, cloudData.Processes) - process.RegisterCallbacks( - processListener.OnUpdaterAdded, processListener.OnUpdaterUpdated, processListener.OnUpdaterDeleted) + ip.GetLANIP().RegisterListener(listener.NewLANIP(r.cacheMng.DomainCache, r.eventQueue)) + ip.GetWANIP().RegisterListener(listener.NewWANIP(r.cacheMng.DomainCache, r.eventQueue)) return []updater.ResourceUpdater{ - updater.NewRegion(r.cacheMng.DomainCache, cloudData.Regions), - updater.NewAZ(r.cacheMng.DomainCache, cloudData.AZs), - updater.NewSubDomain(r.cacheMng.DomainCache, cloudData.SubDomains), - updater.NewVPC(r.cacheMng.DomainCache, cloudData.VPCs), - host, - vm, - updater.NewPodCluster(r.cacheMng.DomainCache, cloudData.PodClusters), - podNode, - updater.NewPodNamespace(r.cacheMng.DomainCache, cloudData.PodNamespaces), - updater.NewPodIngress(r.cacheMng.DomainCache, cloudData.PodIngresses), - updater.NewPodIngressRule(r.cacheMng.DomainCache, cloudData.PodIngressRules), - podService, - updater.NewPodIngressRuleBackend(r.cacheMng.DomainCache, cloudData.PodIngressRuleBackends), - updater.NewPodServicePort(r.cacheMng.DomainCache, cloudData.PodServicePorts), - updater.NewPodGroup(r.cacheMng.DomainCache, cloudData.PodGroups), - updater.NewPodGroupPort(r.cacheMng.DomainCache, cloudData.PodGroupPorts), - updater.NewPodReplicaSet(r.cacheMng.DomainCache, cloudData.PodReplicaSets), - pod, - process, - updater.NewPrometheusTarget(r.cacheMng.DomainCache, cloudData.PrometheusTargets), - updater.NewNetwork(r.cacheMng.DomainCache, cloudData.Networks), - updater.NewSubnet(r.cacheMng.DomainCache, cloudData.Subnets), - vRouter, - updater.NewRoutingTable(r.cacheMng.DomainCache, cloudData.RoutingTables), - dhcpPort, - updater.NewSecurityGroup(r.cacheMng.DomainCache, cloudData.SecurityGroups), - updater.NewSecurityGroupRule(r.cacheMng.DomainCache, cloudData.SecurityGroupRules), - updater.NewVMSecurityGroup(r.cacheMng.DomainCache, cloudData.VMSecurityGroups), - natGateway, - updater.NewNATVMConnection(r.cacheMng.DomainCache, cloudData.NATVMConnections), - updater.NewNATRule(r.cacheMng.DomainCache, cloudData.NATRules), - lb, - updater.NewLBVMConnection(r.cacheMng.DomainCache, cloudData.LBVMConnections), - updater.NewLBListener(r.cacheMng.DomainCache, cloudData.LBListeners), - updater.NewLBTargetServer(r.cacheMng.DomainCache, cloudData.LBTargetServers), - rdsInstance, - redisInstance, - updater.NewPeerConnection(r.cacheMng.DomainCache, cloudData.PeerConnections), - updater.NewCEN(r.cacheMng.DomainCache, cloudData.CENs), - updater.NewVInterface(r.cacheMng.DomainCache, cloudData.VInterfaces, nil), - updater.NewFloatingIP(r.cacheMng.DomainCache, cloudData.FloatingIPs), + updater.NewRegion(r.cacheMng.DomainCache, cloudData.Regions).RegisterListener( + listener.NewRegion(r.cacheMng.DomainCache)), + updater.NewAZ(r.cacheMng.DomainCache, cloudData.AZs).RegisterListener( + listener.NewAZ(r.cacheMng.DomainCache)), + updater.NewSubDomain(r.cacheMng.DomainCache, cloudData.SubDomains).RegisterListener( + listener.NewSubDomain(r.cacheMng.DomainCache)), + updater.NewVPC(r.cacheMng.DomainCache, cloudData.VPCs).RegisterListener( + listener.NewVPC(r.cacheMng.DomainCache)), + updater.NewHost(r.cacheMng.DomainCache, cloudData.Hosts).RegisterListener( + listener.NewHost(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewVM(r.cacheMng.DomainCache, cloudData.VMs).RegisterListener( + listener.NewVM(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewPodCluster(r.cacheMng.DomainCache, cloudData.PodClusters).RegisterListener( + listener.NewPodCluster(r.cacheMng.DomainCache)), + updater.NewPodNode(r.cacheMng.DomainCache, cloudData.PodNodes).RegisterListener( + listener.NewPodNode(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewPodNamespace(r.cacheMng.DomainCache, cloudData.PodNamespaces).RegisterListener( + listener.NewPodNamespace(r.cacheMng.DomainCache)), + updater.NewPodIngress(r.cacheMng.DomainCache, cloudData.PodIngresses).RegisterListener( + listener.NewPodIngress(r.cacheMng.DomainCache)), + updater.NewPodIngressRule(r.cacheMng.DomainCache, cloudData.PodIngressRules).RegisterListener( + listener.NewPodIngressRule(r.cacheMng.DomainCache)), + updater.NewPodService(r.cacheMng.DomainCache, cloudData.PodServices).RegisterListener( + listener.NewPodService(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewPodIngressRuleBackend(r.cacheMng.DomainCache, cloudData.PodIngressRuleBackends).RegisterListener( + listener.NewPodIngressRuleBackend(r.cacheMng.DomainCache)), + updater.NewPodServicePort(r.cacheMng.DomainCache, cloudData.PodServicePorts).RegisterListener( + listener.NewPodServicePort(r.cacheMng.DomainCache)), + updater.NewPodGroup(r.cacheMng.DomainCache, cloudData.PodGroups).RegisterListener( + listener.NewPodGroup(r.cacheMng.DomainCache)), + updater.NewPodGroupPort(r.cacheMng.DomainCache, cloudData.PodGroupPorts).RegisterListener( + listener.NewPodGroupPort(r.cacheMng.DomainCache)), + updater.NewPodReplicaSet(r.cacheMng.DomainCache, cloudData.PodReplicaSets).RegisterListener( + listener.NewPodReplicaSet(r.cacheMng.DomainCache)), + updater.NewPod(r.cacheMng.DomainCache, cloudData.Pods).RegisterListener( + listener.NewPod(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewProcess(r.cacheMng.DomainCache, cloudData.Processes).RegisterListener( + listener.NewProcess(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewPrometheusTarget(r.cacheMng.DomainCache, cloudData.PrometheusTargets).RegisterListener( + listener.NewPrometheusTarget(r.cacheMng.DomainCache)), + updater.NewNetwork(r.cacheMng.DomainCache, cloudData.Networks).RegisterListener( + listener.NewNetwork(r.cacheMng.DomainCache)), + updater.NewSubnet(r.cacheMng.DomainCache, cloudData.Subnets).RegisterListener( + listener.NewSubnet(r.cacheMng.DomainCache)), + updater.NewVRouter(r.cacheMng.DomainCache, cloudData.VRouters).RegisterListener( + listener.NewVRouter(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewRoutingTable(r.cacheMng.DomainCache, cloudData.RoutingTables).RegisterListener( + listener.NewRoutingTable(r.cacheMng.DomainCache)), + updater.NewDHCPPort(r.cacheMng.DomainCache, cloudData.DHCPPorts).RegisterListener( + listener.NewDHCPPort(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewSecurityGroup(r.cacheMng.DomainCache, cloudData.SecurityGroups).RegisterListener( + listener.NewSecurityGroup(r.cacheMng.DomainCache)), + updater.NewSecurityGroupRule(r.cacheMng.DomainCache, cloudData.SecurityGroupRules).RegisterListener( + listener.NewSecurityGroupRule(r.cacheMng.DomainCache)), + updater.NewVMSecurityGroup(r.cacheMng.DomainCache, cloudData.VMSecurityGroups).RegisterListener( + listener.NewVMSecurityGroup(r.cacheMng.DomainCache)), + updater.NewNATGateway(r.cacheMng.DomainCache, cloudData.NATGateways).RegisterListener( + listener.NewNATGateway(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewNATVMConnection(r.cacheMng.DomainCache, cloudData.NATVMConnections).RegisterListener( + listener.NewNATVMConnection(r.cacheMng.DomainCache)), + updater.NewNATRule(r.cacheMng.DomainCache, cloudData.NATRules).RegisterListener( + listener.NewNATRule(r.cacheMng.DomainCache)), + updater.NewLB(r.cacheMng.DomainCache, cloudData.LBs).RegisterListener( + listener.NewLB(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewLBVMConnection(r.cacheMng.DomainCache, cloudData.LBVMConnections).RegisterListener( + listener.NewLBVMConnection(r.cacheMng.DomainCache)), + updater.NewLBListener(r.cacheMng.DomainCache, cloudData.LBListeners).RegisterListener( + listener.NewLBListener(r.cacheMng.DomainCache)), + updater.NewLBTargetServer(r.cacheMng.DomainCache, cloudData.LBTargetServers).RegisterListener( + listener.NewLBTargetServer(r.cacheMng.DomainCache)), + updater.NewRDSInstance(r.cacheMng.DomainCache, cloudData.RDSInstances).RegisterListener( + listener.NewRDSInstance(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewRedisInstance(r.cacheMng.DomainCache, cloudData.RedisInstances).RegisterListener( + listener.NewRedisInstance(r.cacheMng.DomainCache, r.eventQueue)), + updater.NewPeerConnection(r.cacheMng.DomainCache, cloudData.PeerConnections).RegisterListener( + listener.NewPeerConnection(r.cacheMng.DomainCache)), + updater.NewCEN(r.cacheMng.DomainCache, cloudData.CENs).RegisterListener( + listener.NewCEN(r.cacheMng.DomainCache)), + updater.NewVInterface(r.cacheMng.DomainCache, cloudData.VInterfaces, nil).RegisterListener( + listener.NewVInterface(r.cacheMng.DomainCache)), + updater.NewFloatingIP(r.cacheMng.DomainCache, cloudData.FloatingIPs).RegisterListener( + listener.NewFloatingIP(r.cacheMng.DomainCache)), ip, - updater.NewVMPodNodeConnection(r.cacheMng.DomainCache, cloudData.VMPodNodeConnections), // VMPodNodeConnection需放在最后 + updater.NewVMPodNodeConnection(r.cacheMng.DomainCache, cloudData.VMPodNodeConnections).RegisterListener( // VMPodNodeConnection需放在最后 + listener.NewVMPodNodeConnection(r.cacheMng.DomainCache)), } } @@ -307,10 +288,10 @@ func (r *Recorder) refreshSubDomains(cloudSubDomainResourceMap map[string]cloudm r.updateSubDomainSyncedAt(subDomainLcuuid) - listener := listener.NewSubDomain(r.domainLcuuid, subDomainLcuuid, r.cacheMng.DomainCache, r.eventQueue) + listener := listener.NewWholeSubDomain(r.domainLcuuid, subDomainLcuuid, r.cacheMng.DomainCache, r.eventQueue) subDomainUpdatersInUpdateOrder := r.getSubDomainUpdatersInOrder(subDomainLcuuid, subDomainResource, nil, nil) - r.executeUpdators(subDomainUpdatersInUpdateOrder) - listener.OnUpdatersCompeleted() + r.executeUpdaters(subDomainUpdatersInUpdateOrder) + listener.OnUpdatersCompleted() log.Infof("sub_domain (lcuuid: %s) sync refresh completed", subDomainLcuuid) } @@ -321,7 +302,7 @@ func (r *Recorder) refreshSubDomains(cloudSubDomainResourceMap map[string]cloudm if !ok { log.Infof("sub_domain (lcuuid: %s) clean refresh started", subDomainLcuuid) subDomainUpdatersInUpdateOrder := r.getSubDomainUpdatersInOrder(subDomainLcuuid, cloudmodel.SubDomainResource{}, subDomainCache, &r.cacheMng.DomainCache.ToolDataSet) - r.executeUpdators(subDomainUpdatersInUpdateOrder) + r.executeUpdaters(subDomainUpdatersInUpdateOrder) log.Infof("sub_domain (lcuuid: %s) clean refresh completed", subDomainLcuuid) } } @@ -333,56 +314,50 @@ func (r *Recorder) getSubDomainUpdatersInOrder(subDomainLcuuid string, cloudData subDomainCache = r.cacheMng.CreateSubDomainCacheIfNotExists(subDomainLcuuid) } - podListener := listener.NewPod(subDomainCache, r.eventQueue) - pod := updater.NewPod(subDomainCache, cloudData.Pods) - pod.RegisterCallbacks(podListener.OnUpdaterAdded, podListener.OnUpdaterUpdated, podListener.OnUpdaterDeleted) - - processListener := listener.NewProcess(subDomainCache, r.eventQueue) - process := updater.NewProcess(subDomainCache, cloudData.Processes) - process.RegisterCallbacks( - processListener.OnUpdaterAdded, processListener.OnUpdaterUpdated, processListener.OnUpdaterDeleted) - - podNodeListener := listener.NewPodNode(subDomainCache, r.eventQueue) - podNode := updater.NewPodNode(subDomainCache, cloudData.PodNodes) - podNode.RegisterCallbacks( - podNodeListener.OnUpdaterAdded, podNodeListener.OnUpdaterUpdated, podNodeListener.OnUpdaterDeleted) - - podServiceListener := listener.NewPodService(subDomainCache, r.eventQueue) - podService := updater.NewPodService(subDomainCache, cloudData.PodServices) - podService.RegisterCallbacks( - podServiceListener.OnUpdaterAdded, podServiceListener.OnUpdaterUpdated, podServiceListener.OnUpdaterDeleted) - ip := updater.NewIP(subDomainCache, cloudData.IPs, domainToolDataSet) - lanIPListener := listener.NewLANIP(subDomainCache, r.eventQueue) - ip.GetLANIP().RegisterCallbacks( - lanIPListener.OnUpdaterAdded, lanIPListener.OnUpdaterUpdated, lanIPListener.OnUpdaterDeleted) - wanIPListener := listener.NewWANIP(subDomainCache, r.eventQueue) - ip.GetWANIP().RegisterCallbacks( - wanIPListener.OnUpdaterAdded, wanIPListener.OnUpdaterUpdated, wanIPListener.OnUpdaterDeleted) + ip.GetLANIP().RegisterListener(listener.NewLANIP(subDomainCache, r.eventQueue)) + ip.GetWANIP().RegisterListener(listener.NewWANIP(subDomainCache, r.eventQueue)) return []updater.ResourceUpdater{ - updater.NewPodCluster(subDomainCache, cloudData.PodClusters), - podNode, - updater.NewPodNamespace(subDomainCache, cloudData.PodNamespaces), - updater.NewPodIngress(subDomainCache, cloudData.PodIngresses), - updater.NewPodIngressRule(subDomainCache, cloudData.PodIngressRules), - podService, - updater.NewPodIngressRuleBackend(subDomainCache, cloudData.PodIngressRuleBackends), - updater.NewPodServicePort(subDomainCache, cloudData.PodServicePorts), - updater.NewPodGroup(subDomainCache, cloudData.PodGroups), - updater.NewPodGroupPort(subDomainCache, cloudData.PodGroupPorts), - updater.NewPodReplicaSet(subDomainCache, cloudData.PodReplicaSets), - pod, - process, - updater.NewNetwork(subDomainCache, cloudData.Networks), - updater.NewSubnet(subDomainCache, cloudData.Subnets), - updater.NewVInterface(subDomainCache, cloudData.VInterfaces, domainToolDataSet), + updater.NewPodCluster(subDomainCache, cloudData.PodClusters).RegisterListener( + listener.NewPodCluster(subDomainCache)), + updater.NewPodNode(subDomainCache, cloudData.PodNodes).RegisterListener( + listener.NewPodNode(subDomainCache, r.eventQueue)), + updater.NewPodNamespace(subDomainCache, cloudData.PodNamespaces).RegisterListener( + listener.NewPodNamespace(subDomainCache)), + updater.NewPodIngress(subDomainCache, cloudData.PodIngresses).RegisterListener( + listener.NewPodIngress(subDomainCache)), + updater.NewPodIngressRule(subDomainCache, cloudData.PodIngressRules).RegisterListener( + listener.NewPodIngressRule(subDomainCache)), + updater.NewPodService(subDomainCache, cloudData.PodServices).RegisterListener( + listener.NewPodService(subDomainCache, r.eventQueue)), + updater.NewPodIngressRuleBackend(subDomainCache, cloudData.PodIngressRuleBackends).RegisterListener( + listener.NewPodIngressRuleBackend(subDomainCache)), + updater.NewPodServicePort(subDomainCache, cloudData.PodServicePorts).RegisterListener( + listener.NewPodServicePort(subDomainCache)), + updater.NewPodGroup(subDomainCache, cloudData.PodGroups).RegisterListener( + listener.NewPodGroup(subDomainCache)), + updater.NewPodGroupPort(subDomainCache, cloudData.PodGroupPorts).RegisterListener( + listener.NewPodGroupPort(subDomainCache)), + updater.NewPodReplicaSet(subDomainCache, cloudData.PodReplicaSets).RegisterListener( + listener.NewPodReplicaSet(subDomainCache)), + updater.NewPod(subDomainCache, cloudData.Pods).RegisterListener( + listener.NewPod(subDomainCache, r.eventQueue)), + updater.NewProcess(subDomainCache, cloudData.Processes).RegisterListener( + listener.NewProcess(subDomainCache, r.eventQueue)), + updater.NewNetwork(subDomainCache, cloudData.Networks).RegisterListener( + listener.NewNetwork(subDomainCache)), + updater.NewSubnet(subDomainCache, cloudData.Subnets).RegisterListener( + listener.NewSubnet(subDomainCache)), + updater.NewVInterface(subDomainCache, cloudData.VInterfaces, domainToolDataSet).RegisterListener( + listener.NewVInterface(subDomainCache)), ip, - updater.NewVMPodNodeConnection(subDomainCache, cloudData.VMPodNodeConnections), // VMPodNodeConnection需放在最后 + updater.NewVMPodNodeConnection(subDomainCache, cloudData.VMPodNodeConnections).RegisterListener( // VMPodNodeConnection需放在最后 + listener.NewVMPodNodeConnection(subDomainCache)), } } -func (r *Recorder) executeUpdators(updatersInUpdateOrder []updater.ResourceUpdater) { +func (r *Recorder) executeUpdaters(updatersInUpdateOrder []updater.ResourceUpdater) { for _, updater := range updatersInUpdateOrder { updater.HandleAddAndUpdate() } diff --git a/server/controller/recorder/updater/az.go b/server/controller/recorder/updater/az.go index df86fcf30e1..2428aa422d1 100644 --- a/server/controller/recorder/updater/az.go +++ b/server/controller/recorder/updater/az.go @@ -37,7 +37,6 @@ func NewAZ(wholeCache *cache.Cache, cloudData []cloudmodel.AZ) *AZ { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -73,15 +72,3 @@ func (z *AZ) generateUpdateInfo(diffBase *cache.AZ, cloudItem *cloudmodel.AZ) (m } return nil, false } - -func (z *AZ) addCache(dbItems []*mysql.AZ) { - z.cache.AddAZs(dbItems) -} - -func (z *AZ) updateCache(cloudItem *cloudmodel.AZ, diffBase *cache.AZ) { - diffBase.Update(cloudItem) -} - -func (z *AZ) deleteCache(lcuuids []string) { - z.cache.DeleteAZs(lcuuids) -} diff --git a/server/controller/recorder/updater/cen.go b/server/controller/recorder/updater/cen.go index 691e534ee05..fcf1190bd0a 100644 --- a/server/controller/recorder/updater/cen.go +++ b/server/controller/recorder/updater/cen.go @@ -38,7 +38,6 @@ func NewCEN(wholeCache *cache.Cache, cloudData []cloudmodel.CEN) *CEN { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -96,15 +95,3 @@ func (c *CEN) generateUpdateInfo(diffBase *cache.CEN, cloudItem *cloudmodel.CEN) } return nil, false } - -func (c *CEN) addCache(dbItems []*mysql.CEN) { - c.cache.AddCENs(dbItems) -} - -func (c *CEN) updateCache(cloudItem *cloudmodel.CEN, diffBase *cache.CEN) { - diffBase.Update(cloudItem) -} - -func (c *CEN) deleteCache(lcuuids []string) { - c.cache.DeleteCENs(lcuuids) -} diff --git a/server/controller/recorder/updater/dhcp_port.go b/server/controller/recorder/updater/dhcp_port.go index 6cdd0221823..f5a7b73fb1f 100644 --- a/server/controller/recorder/updater/dhcp_port.go +++ b/server/controller/recorder/updater/dhcp_port.go @@ -38,7 +38,6 @@ func NewDHCPPort(wholeCache *cache.Cache, cloudData []cloudmodel.DHCPPort) *DHCP }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -95,16 +94,3 @@ func (p *DHCPPort) generateDBItemToAdd(cloudItem *cloudmodel.DHCPPort) (*mysql.D dbItem.Lcuuid = cloudItem.Lcuuid return dbItem, true } - -func (p *DHCPPort) addCache(dbItems []*mysql.DHCPPort) { - p.cache.AddDHCPPorts(dbItems) -} - -func (p *DHCPPort) updateCache(cloudItem *cloudmodel.DHCPPort, diffBase *cache.DHCPPort) { - diffBase.Update(cloudItem) - p.cache.UpdateDHCPPort(cloudItem) -} - -func (p *DHCPPort) deleteCache(lcuuids []string) { - p.cache.DeleteDHCPPorts(lcuuids) -} diff --git a/server/controller/recorder/updater/floating_ip.go b/server/controller/recorder/updater/floating_ip.go index 4a8939a6648..0e87a6a1158 100644 --- a/server/controller/recorder/updater/floating_ip.go +++ b/server/controller/recorder/updater/floating_ip.go @@ -38,7 +38,6 @@ func NewFloatingIP(wholeCache *cache.Cache, cloudData []cloudmodel.FloatingIP) * }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -109,15 +108,3 @@ func (f *FloatingIP) generateUpdateInfo(diffBase *cache.FloatingIP, cloudItem *c } return updateInfo, len(updateInfo) > 0 } - -func (f *FloatingIP) addCache(dbItems []*mysql.FloatingIP) { - f.cache.AddFloatingIPs(dbItems) -} - -func (f *FloatingIP) updateCache(cloudItem *cloudmodel.FloatingIP, diffBase *cache.FloatingIP) { - diffBase.Update(cloudItem) -} - -func (f *FloatingIP) deleteCache(lcuuids []string) { - f.cache.DeleteFloatingIPs(lcuuids) -} diff --git a/server/controller/recorder/updater/host.go b/server/controller/recorder/updater/host.go index 9f956c331ad..98daff1f497 100644 --- a/server/controller/recorder/updater/host.go +++ b/server/controller/recorder/updater/host.go @@ -38,7 +38,6 @@ func NewHost(wholeCache *cache.Cache, cloudData []cloudmodel.Host) *Host { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -99,16 +98,3 @@ func (h *Host) generateUpdateInfo(diffBase *cache.Host, cloudItem *cloudmodel.Ho } return nil, false } - -func (h *Host) addCache(dbItems []*mysql.Host) { - h.cache.AddHosts(dbItems) -} - -func (h *Host) updateCache(cloudItem *cloudmodel.Host, diffBase *cache.Host) { - diffBase.Update(cloudItem) - h.cache.UpdateHost(cloudItem) -} - -func (h *Host) deleteCache(lcuuids []string) { - h.cache.DeleteHosts(lcuuids) -} diff --git a/server/controller/recorder/updater/lan_ip.go b/server/controller/recorder/updater/lan_ip.go index 1b6b462f022..d008b6491e5 100644 --- a/server/controller/recorder/updater/lan_ip.go +++ b/server/controller/recorder/updater/lan_ip.go @@ -38,7 +38,6 @@ func NewLANIP(wholeCache *cache.Cache, domainToolDataSet *cache.ToolDataSet) *LA }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -126,15 +125,3 @@ func (i *LANIP) generateUpdateInfo(diffBase *cache.LANIP, cloudItem *cloudmodel. return updateInfo, len(updateInfo) > 0 } - -func (i *LANIP) addCache(dbItems []*mysql.LANIP) { - i.cache.AddLANIPs(dbItems) -} - -func (i *LANIP) updateCache(cloudItem *cloudmodel.IP, diffBase *cache.LANIP) { - diffBase.Update(cloudItem) -} - -func (i *LANIP) deleteCache(lcuuids []string) { - i.cache.DeleteLANIPs(lcuuids) -} diff --git a/server/controller/recorder/updater/lb.go b/server/controller/recorder/updater/lb.go index bf36865f289..06641f46fe3 100644 --- a/server/controller/recorder/updater/lb.go +++ b/server/controller/recorder/updater/lb.go @@ -38,7 +38,6 @@ func NewLB(wholeCache *cache.Cache, cloudData []cloudmodel.LB) *LB { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -91,16 +90,3 @@ func (l *LB) generateUpdateInfo(diffBase *cache.LB, cloudItem *cloudmodel.LB) (m } return nil, false } - -func (l *LB) addCache(dbItems []*mysql.LB) { - l.cache.AddLBs(dbItems) -} - -func (l *LB) updateCache(cloudItem *cloudmodel.LB, diffBase *cache.LB) { - diffBase.Update(cloudItem) - l.cache.UpdateLB(cloudItem) -} - -func (l *LB) deleteCache(lcuuids []string) { - l.cache.DeleteLBs(lcuuids) -} diff --git a/server/controller/recorder/updater/lb_listener.go b/server/controller/recorder/updater/lb_listener.go index fe4c9b1635b..2a6ca20740d 100644 --- a/server/controller/recorder/updater/lb_listener.go +++ b/server/controller/recorder/updater/lb_listener.go @@ -38,7 +38,6 @@ func NewLBListener(wholeCache *cache.Cache, cloudData []cloudmodel.LBListener) * }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -94,15 +93,3 @@ func (l *LBListener) generateUpdateInfo(diffBase *cache.LBListener, cloudItem *c } return nil, false } - -func (l *LBListener) addCache(dbItems []*mysql.LBListener) { - l.cache.AddLBListeners(dbItems) -} - -func (l *LBListener) updateCache(cloudItem *cloudmodel.LBListener, diffBase *cache.LBListener) { - diffBase.Update(cloudItem) -} - -func (l *LBListener) deleteCache(lcuuids []string) { - l.cache.DeleteLBListeners(lcuuids) -} diff --git a/server/controller/recorder/updater/lb_target_server.go b/server/controller/recorder/updater/lb_target_server.go index 4e9e9d43b65..6e7b9219757 100644 --- a/server/controller/recorder/updater/lb_target_server.go +++ b/server/controller/recorder/updater/lb_target_server.go @@ -38,7 +38,6 @@ func NewLBTargetServer(wholeCache *cache.Cache, cloudData []cloudmodel.LBTargetS }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -115,15 +114,3 @@ func (s *LBTargetServer) generateUpdateInfo(diffBase *cache.LBTargetServer, clou } return nil, false } - -func (s *LBTargetServer) addCache(dbItems []*mysql.LBTargetServer) { - s.cache.AddLBTargetServers(dbItems) -} - -func (s *LBTargetServer) updateCache(cloudItem *cloudmodel.LBTargetServer, diffBase *cache.LBTargetServer) { - diffBase.Update(cloudItem) -} - -func (s *LBTargetServer) deleteCache(lcuuids []string) { - s.cache.DeleteLBTargetServers(lcuuids) -} diff --git a/server/controller/recorder/updater/lb_vm_connection.go b/server/controller/recorder/updater/lb_vm_connection.go index f792a00e949..1eb4f651d92 100644 --- a/server/controller/recorder/updater/lb_vm_connection.go +++ b/server/controller/recorder/updater/lb_vm_connection.go @@ -38,7 +38,6 @@ func NewLBVMConnection(wholeCache *cache.Cache, cloudData []cloudmodel.LBVMConne }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -78,15 +77,3 @@ func (c *LBVMConnection) generateDBItemToAdd(cloudItem *cloudmodel.LBVMConnectio func (c *LBVMConnection) generateUpdateInfo(diffBase *cache.LBVMConnection, cloudItem *cloudmodel.LBVMConnection) (map[string]interface{}, bool) { return nil, false } - -func (c *LBVMConnection) addCache(dbItems []*mysql.LBVMConnection) { - c.cache.AddLBVMConnections(dbItems) -} - -// 保留接口 -func (c *LBVMConnection) updateCache(cloudItem *cloudmodel.LBVMConnection, diffBase *cache.LBVMConnection) { -} - -func (c *LBVMConnection) deleteCache(lcuuids []string) { - c.cache.DeleteLBVMConnections(lcuuids) -} diff --git a/server/controller/recorder/updater/nat_gateway.go b/server/controller/recorder/updater/nat_gateway.go index cf953130e9a..31b0192b6fb 100644 --- a/server/controller/recorder/updater/nat_gateway.go +++ b/server/controller/recorder/updater/nat_gateway.go @@ -38,7 +38,6 @@ func NewNATGateway(wholeCache *cache.Cache, cloudData []cloudmodel.NATGateway) * }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -87,16 +86,3 @@ func (g *NATGateway) generateUpdateInfo(diffBase *cache.NATGateway, cloudItem *c } return nil, false } - -func (g *NATGateway) addCache(dbItems []*mysql.NATGateway) { - g.cache.AddNATGateways(dbItems) -} - -func (g *NATGateway) updateCache(cloudItem *cloudmodel.NATGateway, diffBase *cache.NATGateway) { - diffBase.Update(cloudItem) - g.cache.UpdateNATGateway(cloudItem) -} - -func (g *NATGateway) deleteCache(lcuuids []string) { - g.cache.DeleteNATGateways(lcuuids) -} diff --git a/server/controller/recorder/updater/nat_rule.go b/server/controller/recorder/updater/nat_rule.go index 1ff3e3012fb..80c76a41297 100644 --- a/server/controller/recorder/updater/nat_rule.go +++ b/server/controller/recorder/updater/nat_rule.go @@ -38,7 +38,6 @@ func NewNATRule(wholeCache *cache.Cache, cloudData []cloudmodel.NATRule) *NATRul }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -91,15 +90,3 @@ func (r *NATRule) generateDBItemToAdd(cloudItem *cloudmodel.NATRule) (*mysql.NAT func (r *NATRule) generateUpdateInfo(diffBase *cache.NATRule, cloudItem *cloudmodel.NATRule) (map[string]interface{}, bool) { return nil, false } - -func (r *NATRule) addCache(dbItems []*mysql.NATRule) { - r.cache.AddNATRules(dbItems) -} - -// 保留接口 -func (r *NATRule) updateCache(cloudItem *cloudmodel.NATRule, diffBase *cache.NATRule) { -} - -func (r *NATRule) deleteCache(lcuuids []string) { - r.cache.DeleteNATRules(lcuuids) -} diff --git a/server/controller/recorder/updater/nat_vm_connection.go b/server/controller/recorder/updater/nat_vm_connection.go index d17389a84c2..f0c0195a35c 100644 --- a/server/controller/recorder/updater/nat_vm_connection.go +++ b/server/controller/recorder/updater/nat_vm_connection.go @@ -38,7 +38,6 @@ func NewNATVMConnection(wholeCache *cache.Cache, cloudData []cloudmodel.NATVMCon }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -78,15 +77,3 @@ func (c *NATVMConnection) generateDBItemToAdd(cloudItem *cloudmodel.NATVMConnect func (c *NATVMConnection) generateUpdateInfo(diffBase *cache.NATVMConnection, cloudItem *cloudmodel.NATVMConnection) (map[string]interface{}, bool) { return nil, false } - -func (c *NATVMConnection) addCache(dbItems []*mysql.NATVMConnection) { - c.cache.AddNATVMConnections(dbItems) -} - -// 保留接口 -func (c *NATVMConnection) updateCache(cloudItem *cloudmodel.NATVMConnection, diffBase *cache.NATVMConnection) { -} - -func (c *NATVMConnection) deleteCache(lcuuids []string) { - c.cache.DeleteNATVMConnections(lcuuids) -} diff --git a/server/controller/recorder/updater/network.go b/server/controller/recorder/updater/network.go index fc295e3f4a1..26552a9076b 100644 --- a/server/controller/recorder/updater/network.go +++ b/server/controller/recorder/updater/network.go @@ -38,7 +38,6 @@ func NewNetwork(wholeCache *cache.Cache, cloudData []cloudmodel.Network) *Networ }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -114,16 +113,3 @@ func (n *Network) generateUpdateInfo(diffBase *cache.Network, cloudItem *cloudmo } return nil, false } - -func (n *Network) addCache(dbItems []*mysql.Network) { - n.cache.AddNetworks(dbItems) -} - -func (n *Network) updateCache(cloudItem *cloudmodel.Network, diffBase *cache.Network) { - diffBase.Update(cloudItem) - n.cache.UpdateNetwork(cloudItem) -} - -func (n *Network) deleteCache(lcuuids []string) { - n.cache.DeleteNetworks(lcuuids) -} diff --git a/server/controller/recorder/updater/peer_connection.go b/server/controller/recorder/updater/peer_connection.go index 87a96bf356c..11b456f235f 100644 --- a/server/controller/recorder/updater/peer_connection.go +++ b/server/controller/recorder/updater/peer_connection.go @@ -38,7 +38,6 @@ func NewPeerConnection(wholeCache *cache.Cache, cloudData []cloudmodel.PeerConne }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -126,15 +125,3 @@ func (c *PeerConnection) generateUpdateInfo(diffBase *cache.PeerConnection, clou } return nil, false } - -func (c *PeerConnection) addCache(dbItems []*mysql.PeerConnection) { - c.cache.AddPeerConnections(dbItems) -} - -func (c *PeerConnection) updateCache(cloudItem *cloudmodel.PeerConnection, diffBase *cache.PeerConnection) { - diffBase.Update(cloudItem) -} - -func (c *PeerConnection) deleteCache(lcuuids []string) { - c.cache.DeletePeerConnections(lcuuids) -} diff --git a/server/controller/recorder/updater/pod.go b/server/controller/recorder/updater/pod.go index 913508106fe..c4e82687281 100644 --- a/server/controller/recorder/updater/pod.go +++ b/server/controller/recorder/updater/pod.go @@ -38,7 +38,6 @@ func NewPod(wholeCache *cache.Cache, cloudData []cloudmodel.Pod) *Pod { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -197,16 +196,3 @@ func (p *Pod) generateUpdateInfo(diffBase *cache.Pod, cloudItem *cloudmodel.Pod) } return nil, false } - -func (p *Pod) addCache(dbItems []*mysql.Pod) { - p.cache.AddPods(dbItems) -} - -func (p *Pod) updateCache(cloudItem *cloudmodel.Pod, diffBase *cache.Pod) { - diffBase.Update(cloudItem) - p.cache.UpdatePod(cloudItem) -} - -func (p *Pod) deleteCache(lcuuids []string) { - p.cache.DeletePods(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_cluster.go b/server/controller/recorder/updater/pod_cluster.go index d132318bc6e..f0385be49c4 100644 --- a/server/controller/recorder/updater/pod_cluster.go +++ b/server/controller/recorder/updater/pod_cluster.go @@ -38,7 +38,6 @@ func NewPodCluster(wholeCache *cache.Cache, cloudData []cloudmodel.PodCluster) * }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -90,15 +89,3 @@ func (c *PodCluster) generateUpdateInfo(diffBase *cache.PodCluster, cloudItem *c } return nil, false } - -func (c *PodCluster) addCache(dbItems []*mysql.PodCluster) { - c.cache.AddPodClusters(dbItems) -} - -func (c *PodCluster) updateCache(cloudItem *cloudmodel.PodCluster, diffBase *cache.PodCluster) { - diffBase.Update(cloudItem) -} - -func (c *PodCluster) deleteCache(lcuuids []string) { - c.cache.DeletePodClusters(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_group.go b/server/controller/recorder/updater/pod_group.go index f8ced339888..c9bf8b2b5e4 100644 --- a/server/controller/recorder/updater/pod_group.go +++ b/server/controller/recorder/updater/pod_group.go @@ -38,7 +38,6 @@ func NewPodGroup(wholeCache *cache.Cache, cloudData []cloudmodel.PodGroup) *PodG }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -105,15 +104,3 @@ func (p *PodGroup) generateUpdateInfo(diffBase *cache.PodGroup, cloudItem *cloud } return nil, false } - -func (p *PodGroup) addCache(dbItems []*mysql.PodGroup) { - p.cache.AddPodGroups(dbItems) -} - -func (p *PodGroup) updateCache(cloudItem *cloudmodel.PodGroup, diffBase *cache.PodGroup) { - diffBase.Update(cloudItem) -} - -func (p *PodGroup) deleteCache(lcuuids []string) { - p.cache.DeletePodGroups(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_group_port.go b/server/controller/recorder/updater/pod_group_port.go index bb527436b6a..eef0f8ffb04 100644 --- a/server/controller/recorder/updater/pod_group_port.go +++ b/server/controller/recorder/updater/pod_group_port.go @@ -38,7 +38,6 @@ func NewPodGroupPort(wholeCache *cache.Cache, cloudData []cloudmodel.PodGroupPor }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -84,15 +83,3 @@ func (p *PodGroupPort) generateUpdateInfo(diffBase *cache.PodGroupPort, cloudIte } return updateInfo, len(updateInfo) > 0 } - -func (p *PodGroupPort) addCache(dbItems []*mysql.PodGroupPort) { - p.cache.AddPodGroupPorts(dbItems) -} - -func (p *PodGroupPort) updateCache(cloudItem *cloudmodel.PodGroupPort, diffBase *cache.PodGroupPort) { - diffBase.Update(cloudItem) -} - -func (p *PodGroupPort) deleteCache(lcuuids []string) { - p.cache.DeletePodGroupPorts(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_ingress.go b/server/controller/recorder/updater/pod_ingress.go index a2d34a02340..535e7028b9b 100644 --- a/server/controller/recorder/updater/pod_ingress.go +++ b/server/controller/recorder/updater/pod_ingress.go @@ -38,7 +38,6 @@ func NewPodIngress(wholeCache *cache.Cache, cloudData []cloudmodel.PodIngress) * }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -94,15 +93,3 @@ func (i *PodIngress) generateUpdateInfo(diffBase *cache.PodIngress, cloudItem *c } return nil, false } - -func (i *PodIngress) addCache(dbItems []*mysql.PodIngress) { - i.cache.AddPodIngresses(dbItems) -} - -func (i *PodIngress) updateCache(cloudItem *cloudmodel.PodIngress, diffBase *cache.PodIngress) { - diffBase.Update(cloudItem) -} - -func (i *PodIngress) deleteCache(lcuuids []string) { - i.cache.DeletePodIngresses(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_ingress_rule.go b/server/controller/recorder/updater/pod_ingress_rule.go index f0c69066e70..48245f70b7d 100644 --- a/server/controller/recorder/updater/pod_ingress_rule.go +++ b/server/controller/recorder/updater/pod_ingress_rule.go @@ -38,7 +38,6 @@ func NewPodIngressRule(wholeCache *cache.Cache, cloudData []cloudmodel.PodIngres }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -72,15 +71,3 @@ func (r *PodIngressRule) generateDBItemToAdd(cloudItem *cloudmodel.PodIngressRul func (r *PodIngressRule) generateUpdateInfo(diffBase *cache.PodIngressRule, cloudItem *cloudmodel.PodIngressRule) (map[string]interface{}, bool) { return nil, false } - -func (b *PodIngressRule) addCache(dbItems []*mysql.PodIngressRule) { - b.cache.AddPodIngressRules(dbItems) -} - -// 保留接口 -func (b *PodIngressRule) updateCache(cloudItem *cloudmodel.PodIngressRule, diffBase *cache.PodIngressRule) { -} - -func (b *PodIngressRule) deleteCache(lcuuids []string) { - b.cache.DeletePodIngressRules(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_ingress_rule_backend.go b/server/controller/recorder/updater/pod_ingress_rule_backend.go index 8145b57a515..15c696789c2 100644 --- a/server/controller/recorder/updater/pod_ingress_rule_backend.go +++ b/server/controller/recorder/updater/pod_ingress_rule_backend.go @@ -38,7 +38,6 @@ func NewPodIngressRuleBackend(wholeCache *cache.Cache, cloudData []cloudmodel.Po }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -89,15 +88,3 @@ func (b *PodIngressRuleBackend) generateDBItemToAdd(cloudItem *cloudmodel.PodIng func (b *PodIngressRuleBackend) generateUpdateInfo(diffBase *cache.PodIngressRuleBackend, cloudItem *cloudmodel.PodIngressRuleBackend) (map[string]interface{}, bool) { return nil, false } - -func (b *PodIngressRuleBackend) addCache(dbItems []*mysql.PodIngressRuleBackend) { - b.cache.AddPodIngressRuleBackends(dbItems) -} - -// 保留接口 -func (b *PodIngressRuleBackend) updateCache(cloudItem *cloudmodel.PodIngressRuleBackend, diffBase *cache.PodIngressRuleBackend) { -} - -func (b *PodIngressRuleBackend) deleteCache(lcuuids []string) { - b.cache.DeletePodIngressRuleBackends(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_namespace.go b/server/controller/recorder/updater/pod_namespace.go index a680e13ba0a..8e5a2e6b646 100644 --- a/server/controller/recorder/updater/pod_namespace.go +++ b/server/controller/recorder/updater/pod_namespace.go @@ -38,7 +38,6 @@ func NewPodNamespace(wholeCache *cache.Cache, cloudData []cloudmodel.PodNamespac }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -86,15 +85,3 @@ func (n *PodNamespace) generateUpdateInfo(diffBase *cache.PodNamespace, cloudIte } return nil, false } - -func (n *PodNamespace) addCache(dbItems []*mysql.PodNamespace) { - n.cache.AddPodNamespaces(dbItems) -} - -func (n *PodNamespace) updateCache(cloudItem *cloudmodel.PodNamespace, diffBase *cache.PodNamespace) { - diffBase.Update(cloudItem) -} - -func (n *PodNamespace) deleteCache(lcuuids []string) { - n.cache.DeletePodNamespaces(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_node.go b/server/controller/recorder/updater/pod_node.go index 0e934dd8165..f646b79f1f5 100644 --- a/server/controller/recorder/updater/pod_node.go +++ b/server/controller/recorder/updater/pod_node.go @@ -38,7 +38,6 @@ func NewPodNode(wholeCache *cache.Cache, cloudData []cloudmodel.PodNode) *PodNod }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -106,16 +105,3 @@ func (n *PodNode) generateUpdateInfo(diffBase *cache.PodNode, cloudItem *cloudmo } return nil, false } - -func (n *PodNode) addCache(dbItems []*mysql.PodNode) { - n.cache.AddPodNodes(dbItems) -} - -func (n *PodNode) updateCache(cloudItem *cloudmodel.PodNode, diffBase *cache.PodNode) { - diffBase.Update(cloudItem) - n.cache.UpdatePodNode(cloudItem) -} - -func (n *PodNode) deleteCache(lcuuids []string) { - n.cache.DeletePodNodes(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_replica_set.go b/server/controller/recorder/updater/pod_replica_set.go index 5d5aa661f45..b3c2351418f 100644 --- a/server/controller/recorder/updater/pod_replica_set.go +++ b/server/controller/recorder/updater/pod_replica_set.go @@ -38,7 +38,6 @@ func NewPodReplicaSet(wholeCache *cache.Cache, cloudData []cloudmodel.PodReplica }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -111,15 +110,3 @@ func (r *PodReplicaSet) generateUpdateInfo(diffBase *cache.PodReplicaSet, cloudI } return nil, false } - -func (r *PodReplicaSet) addCache(dbItems []*mysql.PodReplicaSet) { - r.cache.AddPodReplicaSets(dbItems) -} - -func (r *PodReplicaSet) updateCache(cloudItem *cloudmodel.PodReplicaSet, diffBase *cache.PodReplicaSet) { - diffBase.Update(cloudItem) -} - -func (r *PodReplicaSet) deleteCache(lcuuids []string) { - r.cache.DeletePodReplicaSets(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_service.go b/server/controller/recorder/updater/pod_service.go index 7aae2b56a48..713bed0a850 100644 --- a/server/controller/recorder/updater/pod_service.go +++ b/server/controller/recorder/updater/pod_service.go @@ -38,7 +38,6 @@ func NewPodService(wholeCache *cache.Cache, cloudData []cloudmodel.PodService) * }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -146,16 +145,3 @@ func (s *PodService) generateUpdateInfo(diffBase *cache.PodService, cloudItem *c } return nil, false } - -func (s *PodService) addCache(dbItems []*mysql.PodService) { - s.cache.AddPodServices(dbItems) -} - -func (s *PodService) updateCache(cloudItem *cloudmodel.PodService, diffBase *cache.PodService) { - diffBase.Update(cloudItem) - s.cache.UpdatePodService(cloudItem) -} - -func (s *PodService) deleteCache(lcuuids []string) { - s.cache.DeletePodServices(lcuuids) -} diff --git a/server/controller/recorder/updater/pod_service_port.go b/server/controller/recorder/updater/pod_service_port.go index a484fdc47c7..d4497116cbb 100644 --- a/server/controller/recorder/updater/pod_service_port.go +++ b/server/controller/recorder/updater/pod_service_port.go @@ -38,7 +38,6 @@ func NewPodServicePort(wholeCache *cache.Cache, cloudData []cloudmodel.PodServic }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -81,15 +80,3 @@ func (p *PodServicePort) generateUpdateInfo(diffBase *cache.PodServicePort, clou } return nil, false } - -func (p *PodServicePort) addCache(dbItems []*mysql.PodServicePort) { - p.cache.AddPodServicePorts(dbItems) -} - -func (p *PodServicePort) updateCache(cloudItem *cloudmodel.PodServicePort, diffBase *cache.PodServicePort) { - diffBase.Update(cloudItem) -} - -func (p *PodServicePort) deleteCache(lcuuids []string) { - p.cache.DeletePodServicePorts(lcuuids) -} diff --git a/server/controller/recorder/updater/process.go b/server/controller/recorder/updater/process.go index 406e2b42479..27e0200db51 100644 --- a/server/controller/recorder/updater/process.go +++ b/server/controller/recorder/updater/process.go @@ -37,7 +37,6 @@ func NewProcess(wholeCache *cache.Cache, cloudData []cloudmodel.Process) *Proces }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -82,15 +81,3 @@ func (p *Process) generateUpdateInfo(diffBase *cache.Process, cloudItem *cloudmo } return nil, false } - -func (p *Process) addCache(dbItems []*mysql.Process) { - p.cache.AddProcesses(dbItems) -} - -func (p *Process) updateCache(cloudItem *cloudmodel.Process, diffBase *cache.Process) { - diffBase.Update(cloudItem) -} - -func (p *Process) deleteCache(lcuuids []string) { - p.cache.DeleteProcesses(lcuuids) -} diff --git a/server/controller/recorder/updater/prometheus_target.go b/server/controller/recorder/updater/prometheus_target.go index 5f664dd4880..67c5bffe9e3 100644 --- a/server/controller/recorder/updater/prometheus_target.go +++ b/server/controller/recorder/updater/prometheus_target.go @@ -37,7 +37,6 @@ func NewPrometheusTarget(wholeCache *cache.Cache, cloudData []cloudmodel.Prometh }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -82,15 +81,3 @@ func (p *PrometheusTarget) generateUpdateInfo(diffBase *cache.PrometheusTarget, } return nil, false } - -func (p *PrometheusTarget) addCache(dbItems []*mysql.PrometheusTarget) { - p.cache.AddPrometheusTarget(dbItems) -} - -func (p *PrometheusTarget) updateCache(cloudItem *cloudmodel.PrometheusTarget, diffBase *cache.PrometheusTarget) { - diffBase.Update(cloudItem) -} - -func (p *PrometheusTarget) deleteCache(lcuuids []string) { - p.cache.DeletePrometheusTarget(lcuuids) -} diff --git a/server/controller/recorder/updater/rds_instance.go b/server/controller/recorder/updater/rds_instance.go index 01c0d326f70..28d04ff9367 100644 --- a/server/controller/recorder/updater/rds_instance.go +++ b/server/controller/recorder/updater/rds_instance.go @@ -38,7 +38,6 @@ func NewRDSInstance(wholeCache *cache.Cache, cloudData []cloudmodel.RDSInstance) }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -100,16 +99,3 @@ func (r *RDSInstance) generateUpdateInfo(diffBase *cache.RDSInstance, cloudItem } return nil, false } - -func (r *RDSInstance) addCache(dbItems []*mysql.RDSInstance) { - r.cache.AddRDSInstances(dbItems) -} - -func (r *RDSInstance) updateCache(cloudItem *cloudmodel.RDSInstance, diffBase *cache.RDSInstance) { - diffBase.Update(cloudItem) - r.cache.UpdateRDSInstance(cloudItem) -} - -func (r *RDSInstance) deleteCache(lcuuids []string) { - r.cache.DeleteRDSInstances(lcuuids) -} diff --git a/server/controller/recorder/updater/redis_instance.go b/server/controller/recorder/updater/redis_instance.go index 7677d8f8dfd..271d423e68b 100644 --- a/server/controller/recorder/updater/redis_instance.go +++ b/server/controller/recorder/updater/redis_instance.go @@ -38,7 +38,6 @@ func NewRedisInstance(wholeCache *cache.Cache, cloudData []cloudmodel.RedisInsta }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -96,16 +95,3 @@ func (r *RedisInstance) generateUpdateInfo(diffBase *cache.RedisInstance, cloudI } return nil, false } - -func (r *RedisInstance) addCache(dbItems []*mysql.RedisInstance) { - r.cache.AddRedisInstances(dbItems) -} - -func (r *RedisInstance) updateCache(cloudItem *cloudmodel.RedisInstance, diffBase *cache.RedisInstance) { - diffBase.Update(cloudItem) - r.cache.UpdateRedisInstance(cloudItem) -} - -func (r *RedisInstance) deleteCache(lcuuids []string) { - r.cache.DeleteRedisInstances(lcuuids) -} diff --git a/server/controller/recorder/updater/region.go b/server/controller/recorder/updater/region.go index 0ca90befee3..515a7af4c02 100644 --- a/server/controller/recorder/updater/region.go +++ b/server/controller/recorder/updater/region.go @@ -37,7 +37,6 @@ func NewRegion(wholeCache *cache.Cache, cloudData []cloudmodel.Region) *Region { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -68,15 +67,3 @@ func (r *Region) generateUpdateInfo(diffBase *cache.Region, cloudItem *cloudmode } return nil, false } - -func (r *Region) addCache(dbItems []*mysql.Region) { - r.cache.AddRegions(dbItems) -} - -func (r *Region) updateCache(cloudItem *cloudmodel.Region, diffBase *cache.Region) { - diffBase.Update(cloudItem) -} - -func (r *Region) deleteCache(lcuuids []string) { - r.cache.DeleteRegions(lcuuids) -} diff --git a/server/controller/recorder/updater/routing_table.go b/server/controller/recorder/updater/routing_table.go index f98cb274a48..721323bcfa9 100644 --- a/server/controller/recorder/updater/routing_table.go +++ b/server/controller/recorder/updater/routing_table.go @@ -38,7 +38,6 @@ func NewRoutingTable(wholeCache *cache.Cache, cloudData []cloudmodel.RoutingTabl }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -83,15 +82,3 @@ func (t *RoutingTable) generateUpdateInfo(diffBase *cache.RoutingTable, cloudIte } return nil, false } - -func (t *RoutingTable) addCache(dbItems []*mysql.RoutingTable) { - t.cache.AddRoutingTables(dbItems) -} - -func (t *RoutingTable) updateCache(cloudItem *cloudmodel.RoutingTable, diffBase *cache.RoutingTable) { - diffBase.Update(cloudItem) -} - -func (t *RoutingTable) deleteCache(lcuuids []string) { - t.cache.DeleteRoutingTables(lcuuids) -} diff --git a/server/controller/recorder/updater/security_group.go b/server/controller/recorder/updater/security_group.go index 93d4ba96546..dbb1bce3836 100644 --- a/server/controller/recorder/updater/security_group.go +++ b/server/controller/recorder/updater/security_group.go @@ -38,7 +38,6 @@ func NewSecurityGroup(wholeCache *cache.Cache, cloudData []cloudmodel.SecurityGr }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -86,15 +85,3 @@ func (g *SecurityGroup) generateUpdateInfo(diffBase *cache.SecurityGroup, cloudI } return nil, false } - -func (g *SecurityGroup) addCache(dbItems []*mysql.SecurityGroup) { - g.cache.AddSecurityGroups(dbItems) -} - -func (g *SecurityGroup) updateCache(cloudItem *cloudmodel.SecurityGroup, diffBase *cache.SecurityGroup) { - diffBase.Update(cloudItem) -} - -func (g *SecurityGroup) deleteCache(lcuuids []string) { - g.cache.DeleteSecurityGroups(lcuuids) -} diff --git a/server/controller/recorder/updater/security_group_rule.go b/server/controller/recorder/updater/security_group_rule.go index 14d4008ac25..789bf099b01 100644 --- a/server/controller/recorder/updater/security_group_rule.go +++ b/server/controller/recorder/updater/security_group_rule.go @@ -38,7 +38,6 @@ func NewSecurityGroupRule(wholeCache *cache.Cache, cloudData []cloudmodel.Securi }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -96,15 +95,3 @@ func (r *SecurityGroupRule) generateUpdateInfo(diffBase *cache.SecurityGroupRule } return nil, false } - -func (r *SecurityGroupRule) addCache(dbItems []*mysql.SecurityGroupRule) { - r.cache.AddSecurityGroupRules(dbItems) -} - -func (r *SecurityGroupRule) updateCache(cloudItem *cloudmodel.SecurityGroupRule, diffBase *cache.SecurityGroupRule) { - diffBase.Update(cloudItem) -} - -func (r *SecurityGroupRule) deleteCache(lcuuids []string) { - r.cache.DeleteSecurityGroupRules(lcuuids) -} diff --git a/server/controller/recorder/updater/sub_domain.go b/server/controller/recorder/updater/sub_domain.go index 9e2aeacd8f5..ad95702bcf7 100644 --- a/server/controller/recorder/updater/sub_domain.go +++ b/server/controller/recorder/updater/sub_domain.go @@ -37,7 +37,6 @@ func NewSubDomain(wholeCache *cache.Cache, cloudData []cloudmodel.SubDomain) *Su }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -65,15 +64,3 @@ func (d *SubDomain) generateUpdateInfo(diffBase *cache.SubDomain, cloudItem *clo } return updateInfo, len(updateInfo) > 0 } - -func (d *SubDomain) addCache(dbItems []*mysql.SubDomain) { - d.cache.AddSubDomains(dbItems) -} - -func (d *SubDomain) updateCache(cloudItem *cloudmodel.SubDomain, diffBase *cache.SubDomain) { - diffBase.Update(cloudItem) -} - -func (d *SubDomain) deleteCache(lcuuids []string) { - d.cache.DeleteSubDomains(lcuuids) -} diff --git a/server/controller/recorder/updater/subnet.go b/server/controller/recorder/updater/subnet.go index 622b2ff6892..67bfd44f76d 100644 --- a/server/controller/recorder/updater/subnet.go +++ b/server/controller/recorder/updater/subnet.go @@ -38,7 +38,6 @@ func NewSubnet(wholeCache *cache.Cache, cloudData []cloudmodel.Subnet) *Subnet { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -88,15 +87,3 @@ func (s *Subnet) generateUpdateInfo(diffBase *cache.Subnet, cloudItem *cloudmode } return nil, false } - -func (s *Subnet) addCache(dbItems []*mysql.Subnet) { - s.cache.AddSubnets(dbItems) -} - -func (s *Subnet) updateCache(cloudItem *cloudmodel.Subnet, diffBase *cache.Subnet) { - diffBase.Update(cloudItem) -} - -func (s *Subnet) deleteCache(lcuuids []string) { - s.cache.DeleteSubnets(lcuuids) -} diff --git a/server/controller/recorder/updater/updatable_field.go b/server/controller/recorder/updater/updatable_field.go deleted file mode 100644 index b5a419d54d9..00000000000 --- a/server/controller/recorder/updater/updatable_field.go +++ /dev/null @@ -1,290 +0,0 @@ -/* - * Copyright (c) 2023 Yunshan Networks - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package updater - -var ResourceTypeToUpdatableFields = map[string][]string{ - "region": {"name", "label"}, - "az": {"name", "label", "region"}, - "sub_domain": {}, - "host": {"name", "region", "az", "ip", "htype", "vcpu_num", "mem_total", "extra_info"}, - "vm": {"name", "state", "launch_server", "epc_id", "az", "region", "htype", "label"}, - "vpc": {"name", "cidr", "label", "tunnel_id", "region"}, - "network": {"name", "label", "segmentation_id", "region", "az", "epc_id", "net_type", "tunnel_id"}, - "subnet": {"name", "label"}, - "vrouter": {"name", "label", "epc_id", "region"}, - "routing_table": {"destination", "nexthop_type", "nexthop"}, - "dhcp_port": {"name", "region", "az"}, - "vinterface": {"name", "subnetid", "tap_mac", "region"}, - "wan_ip": {"region"}, - "floating_ip": {"region"}, - "security_group": {"name", "label", "region"}, - "security_group_rule": {"priority", "ethertype", "remote_port_range", "remote", "local"}, - "vm_security_group": {"priority"}, - "nat_gateway": {"name", "floating_ips", "region"}, - "lb": {"name", "model", "vip", "region"}, - "lb_listener": {"name", "port", "protocol", "ips", "snat_ips"}, - "lb_target_server": {"port", "protocol", "ip"}, - "peer_connection": {"name", "remote_region_id", "local_region_id"}, - "cen": {"name", "epc_ids"}, - "rds_instance": {"name", "state", "series", "model", "region"}, - "redis_instance": {"name", "state", "public_host", "region"}, - "pod_cluser": {"name", "region", "az", "cluster_name"}, - "pod_node": {"state", "az", "region", "vcpu_num", "mem_total"}, - "pod_namespace": {"region", "az"}, - "pod_ingress": {"name", "region", "az"}, - "pod_service": {"name", "selector", "pod_ingress_id", "service_cluster_ip", "region", "az"}, - "pod_service_port": {"name"}, - "pod_group": {"name", "pod_num", "label", "region", "az", "type"}, - "pod_group_port": {"name"}, - "pod_replica_set": {"name", "pod_num", "region", "az"}, - "pod": {"name", "state", "region", "az", "epc_id", "pod_rs_id", "pod_node_id", "created_at"}, -} - -// xxxUpdatableStructFieldToDBField -// cloud/diff_base 结构体字段到数据库字段的映射，用于清晰实现检查更新的逻辑 - -var regionUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Label": "label", -} - -var azUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Label": "label", - "RegionLcuuid": "region", -} - -var hostUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "IP": "ip", - "HType": "htype", - "VCPUNum": "vcpu_num", - "MemTotal": "mem_total", - "ExtraInfo": "extra_info", -} - -var vmUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "State": "state", - "LaunchServer": "launch_server", - "VPCLcuuid": "epc_id", - "AZLcuuid": "az", - "RegionLcuuid": "region", - "HType": "htype", - "Label": "label", -} - -var vpcUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "CIDR": "cidr", - "Label": "label", - "TunnelID": "tunnel_id", - "RegionLcuuid": "region", -} - -var networkUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Label": "label", - "SegmentationID": "segmentation_id", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "VPCLcuuid": "epc_id", - "NetType": "net_type", - "TunnelID": "tunnel_id", -} - -var subnetUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Label": "label", -} - -var vrouterUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Label": "label", - "VPCLcuuid": "epc_id", - "RegionLcuuid": "region", -} - -var routingTableUpdatableStructFieldToDBField = map[string]string{ - "Destination": "destination", - "NexthopType": "nexthop_type", - "Nexthop": "nexthop", -} - -var dhcpPortUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", -} - -var vinterfaceUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "SubnetLcuuid": "subnetid", - "TapMac": "tap_mac", - "RegionLcuuid": "region", -} - -var wanIpUpdatableStructFieldToDBField = map[string]string{ - "RegionLcuuid": "region", -} - -var floatingIpUpdatableStructFieldToDBField = map[string]string{ - "RegionLcuuid": "region", -} - -var securityGroupUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Label": "label", - "RegionLcuuid": "region", -} - -var securityGroupRuleUpdatableStructFieldToDBField = map[string]string{ - "Priority": "priority", - "Ethertype": "ethertype", - "RemotePortRange": "remote_port_range", - "Remote": "remote", - "Local": "local", -} - -var vmSecurityGroupUpdatableStructFieldToDBField = map[string]string{ - "Priority": "priority", -} - -var natGatewayUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "FloatingIPs": "floating_ips", - "RegionLcuuid": "region", -} - -var lbUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Model": "model", - "VIP": "vip", - "RegionLcuuid": "region", -} - -var lbListenerUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "Protocol": "protocol", - "Port": "port", - "IPs": "ips", - "SNATIPs": "snat_ips", -} - -var lbTargetServerUpdatableStructFieldToDBField = map[string]string{ - "IP": "ip", - "Port": "port", - "Protocol": "protocol", -} - -var peerConnectionUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RemoteRegionLcuuid": "remote_region_lcuuid", - "LocalRegionLcuuid": "local_region_lcuuid", -} - -var cenUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "VPCLcuuids": "epc_ids", -} - -var rdsInstanceUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "State": "state", - "Series": "series", - "Model": "model", -} - -var redisInstanceUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "State": "state", - "PublicHost": "public_host", -} - -var podClusterUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "ClusterName": "cluster_name", -} - -var podNodeUpdatableStructFieldToDBField = map[string]string{ - "State": "state", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "VPCUNum": "vcpu_num", - "MemTotal": "mem_total", -} - -var podNamespaceUpdatableStructFieldToDBField = map[string]string{ - "RegionLcuuid": "region", - "AZLcuuid": "az", -} - -var podIngressUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", -} - -var podServiceUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "Selector": "selector", - "PodIngressLcuuid": "pod_ingress_id", - "ServiceClusterIP": "service_cluster_ip", -} - -var podServicePortUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", -} - -var podGroupUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "PodNum": "pod_num", - "Label": "label", - "Type": "type", -} - -var podGroupPortUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", -} - -var podReplicaSetUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "PodNum": "pod_num", -} - -var podUpdatableStructFieldToDBField = map[string]string{ - "Name": "name", - "RegionLcuuid": "region", - "AZLcuuid": "az", - "State": "state", - "VPCLcuuid": "epc_id", - "PodReplicaSetLcuuid": "pod_rs_id", - "PodNodeLcuuid": "pod_node_id", - "CreatedAt": "created_at", -} diff --git a/server/controller/recorder/updater/updater.go b/server/controller/recorder/updater/updater.go index 2e5fd6dcb39..957d73385b9 100644 --- a/server/controller/recorder/updater/updater.go +++ b/server/controller/recorder/updater/updater.go @@ -20,6 +20,7 @@ import ( "github.com/deepflowio/deepflow/server/controller/recorder/cache" "github.com/deepflowio/deepflow/server/controller/recorder/constraint" "github.com/deepflowio/deepflow/server/controller/recorder/db" + "github.com/deepflowio/deepflow/server/controller/recorder/listener" ) // ResourceUpdater 实现资源进行新旧数据比对，并根据比对结果增删改资源 @@ -42,31 +43,32 @@ type DataGenerator[CT constraint.CloudModel, MT constraint.MySQLModel, BT constr generateUpdateInfo(BT, *CT) (map[string]interface{}, bool) } -type CacheHandler[CT constraint.CloudModel, MT constraint.MySQLModel, BT constraint.DiffBase[MT]] interface { - // 根据新增的db数据，更新cache - addCache([]*MT) - // 根据更新的db数据，更新cache - updateCache(*CT, BT) - // 根据删除的db数据，更新cache - deleteCache([]string) -} +// type Callbacks[CT constraint.CloudModel, MT constraint.MySQLModel, BT constraint.DiffBase[MT]] struct { +// onAdded func(addedDBItems []*MT) +// onUpdated func(cloudItem *CT, diffBaseItem BT) +// onDeleted func(lcuuids []string) +// } -type Callbacks[CT constraint.CloudModel, MT constraint.MySQLModel, BT constraint.DiffBase[MT]] struct { - onAdded func(addedDBItems []*MT) - onUpdated func(cloudItem *CT, diffBaseItem BT) - onDeleted func(lcuuids []string) +type UpdaterBase[CT constraint.CloudModel, MT constraint.MySQLModel, BT constraint.DiffBase[MT]] struct { + cache *cache.Cache // 基于 Domain 或者 SubDomain 范围构造 + domainToolDataSet *cache.ToolDataSet // 基于 Domain 构造，仅当 Updater 资源属于 SubDomain 时使用 + dbOperator db.Operator[MT] // 数据库操作对象 + diffBaseData map[string]BT // 用于比对的旧资源数据 + cloudData []CT // 定时获取的新资源数据 + dataGenerator DataGenerator[CT, MT, BT] // 提供各类数据生成的方法 + listeners []listener.Listener[CT, MT, BT] // 关注 Updater 的增删改操作行为及详情的监听器 + // callbacks Callbacks[CT, MT, BT] } -type UpdaterBase[CT constraint.CloudModel, MT constraint.MySQLModel, BT constraint.DiffBase[MT]] struct { - cache *cache.Cache // 基于 Domain 或者 SubDomain 范围构造 - domainToolDataSet *cache.ToolDataSet // TODO ugly 基于 Domain 构造，仅当 Updater 资源属于 SubDomain 时使用 - dbOperator db.Operator[MT] // 数据库操作对象 - diffBaseData map[string]BT // 用于比对的旧资源数据 - cloudData []CT // 定时获取的新资源数据 - dataGenerator DataGenerator[CT, MT, BT] // 提供各类数据生成的方法 - // TODO 移出updater - cacheHandler CacheHandler[CT, MT, BT] // 提供处理cache中特定资源的方法 - callbacks Callbacks[CT, MT, BT] +// func (u *UpdaterBase[CT, MT, BT]) RegisterCallbacks(onAdded func(addedDBItems []*MT), onUpdated func(cloudItem *CT, diffBaseItem BT), onDeleted func(lcuuids []string)) { +// u.callbacks.onAdded = onAdded +// u.callbacks.onUpdated = onUpdated +// u.callbacks.onDeleted = onDeleted +// } + +func (u *UpdaterBase[CT, MT, BT]) RegisterListener(listener listener.Listener[CT, MT, BT]) ResourceUpdater { + u.listeners = append(u.listeners, listener) + return u } func (u *UpdaterBase[CT, MT, BT]) HandleAddAndUpdate() { @@ -106,13 +108,6 @@ func (u *UpdaterBase[CT, MT, BT]) HandleDelete() { } } -func (u *UpdaterBase[CT, MT, BT]) RegisterCallbacks(onAdded func(addedDBItems []*MT), onUpdated func(cloudItem *CT, diffBaseItem BT), onDeleted func(lcuuids []string)) { - u.callbacks.onAdded = onAdded - u.callbacks.onUpdated = onUpdated - u.callbacks.onDeleted = onDeleted -} - -// 创建资源，按序操作DB、cache、资源变更事件 func (u *UpdaterBase[CT, MT, BT]) add(dbItemsToAdd []*MT) { count := len(dbItemsToAdd) offset := 1000 @@ -131,27 +126,17 @@ func (u *UpdaterBase[CT, MT, BT]) add(dbItemsToAdd []*MT) { } func (u *UpdaterBase[CT, MT, BT]) addPage(dbItemsToAdd []*MT) { - addedDBItems, ok := u.dbOperator.AddBatch(dbItemsToAdd) - if ok { - u.cacheHandler.addCache(addedDBItems) - if u.callbacks.onAdded != nil { - u.callbacks.onAdded(addedDBItems) - } + if addedDBItems, ok := u.dbOperator.AddBatch(dbItemsToAdd); ok { + u.notifyOnAdded(addedDBItems) } } -// 更新资源，按序操作DB、cache、资源变更事件 func (u *UpdaterBase[CT, MT, BT]) update(cloudItem *CT, diffBase BT, updateInfo map[string]interface{}) { - _, ok := u.dbOperator.Update(diffBase.GetLcuuid(), updateInfo) - if ok { - if u.callbacks.onUpdated != nil { - u.callbacks.onUpdated(cloudItem, diffBase) - } - u.cacheHandler.updateCache(cloudItem, diffBase) + if _, ok := u.dbOperator.Update(diffBase.GetLcuuid(), updateInfo); ok { + u.notifyOnUpdated(cloudItem, diffBase) } } -// 删除资源，按序操作DB、cache、资源变更事件 func (u *UpdaterBase[CT, MT, BT]) delete(lcuuids []string) { count := len(lcuuids) offset := 1000 @@ -171,9 +156,27 @@ func (u *UpdaterBase[CT, MT, BT]) delete(lcuuids []string) { func (u *UpdaterBase[CT, MT, BT]) deletePage(lcuuids []string) { if u.dbOperator.DeleteBatch(lcuuids) { - if u.callbacks.onDeleted != nil { - u.callbacks.onDeleted(lcuuids) - } - u.cacheHandler.deleteCache(lcuuids) + u.notifyOnDeleted(lcuuids) + } +} + +func (u *UpdaterBase[CT, MT, BT]) notifyOnAdded(addedDBItems []*MT) { + // u.callbacks.onAdded(addedDBItems) + for _, l := range u.listeners { + l.OnUpdaterAdded(addedDBItems) + } +} + +func (u *UpdaterBase[CT, MT, BT]) notifyOnUpdated(cloudItem *CT, diffBaseItem BT) { + // u.callbacks.onUpdated(cloudItem, diffBaseItem) + for _, l := range u.listeners { + l.OnUpdaterUpdated(cloudItem, diffBaseItem) + } +} + +func (u *UpdaterBase[CT, MT, BT]) notifyOnDeleted(lcuuids []string) { + // u.callbacks.onDeleted(lcuuids) + for _, l := range u.listeners { + l.OnUpdaterDeleted(lcuuids) } } diff --git a/server/controller/recorder/updater/vinterface.go b/server/controller/recorder/updater/vinterface.go index c7a95414d94..c02d217ea48 100644 --- a/server/controller/recorder/updater/vinterface.go +++ b/server/controller/recorder/updater/vinterface.go @@ -41,7 +41,6 @@ func NewVInterface(wholeCache *cache.Cache, cloudData []cloudmodel.VInterface, d }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -133,16 +132,3 @@ func (i *VInterface) generateUpdateInfo(diffBase *cache.VInterface, cloudItem *c } return updateInfo, len(updateInfo) > 0 } - -func (i *VInterface) addCache(dbItems []*mysql.VInterface) { - i.cache.AddVInterfaces(dbItems) -} - -func (i *VInterface) updateCache(cloudItem *cloudmodel.VInterface, diffBase *cache.VInterface) { - diffBase.Update(cloudItem) - i.cache.UpdateVInterface(cloudItem) -} - -func (i *VInterface) deleteCache(lcuuids []string) { - i.cache.DeleteVInterfaces(lcuuids) -} diff --git a/server/controller/recorder/updater/vm.go b/server/controller/recorder/updater/vm.go index 2977e932b58..b9cac963cfb 100644 --- a/server/controller/recorder/updater/vm.go +++ b/server/controller/recorder/updater/vm.go @@ -38,7 +38,6 @@ func NewVM(wholeCache *cache.Cache, cloudData []cloudmodel.VM) *VM { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -119,16 +118,3 @@ func (m *VM) generateUpdateInfo(diffBase *cache.VM, cloudItem *cloudmodel.VM) (m } return updateInfo, false } - -func (m *VM) addCache(dbItems []*mysql.VM) { - m.cache.AddVMs(dbItems) -} - -func (m *VM) updateCache(cloudItem *cloudmodel.VM, diffBase *cache.VM) { - diffBase.Update(cloudItem) - m.cache.UpdateVM(cloudItem) -} - -func (m *VM) deleteCache(lcuuids []string) { - m.cache.DeleteVMs(lcuuids) -} diff --git a/server/controller/recorder/updater/vm_pod_node_connection.go b/server/controller/recorder/updater/vm_pod_node_connection.go index 12f0a81f131..adb4e56d367 100644 --- a/server/controller/recorder/updater/vm_pod_node_connection.go +++ b/server/controller/recorder/updater/vm_pod_node_connection.go @@ -38,7 +38,6 @@ func NewVMPodNodeConnection(wholeCache *cache.Cache, cloudData []cloudmodel.VMPo }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -79,15 +78,3 @@ func (c *VMPodNodeConnection) generateDBItemToAdd(cloudItem *cloudmodel.VMPodNod func (c *VMPodNodeConnection) generateUpdateInfo(diffBase *cache.VMPodNodeConnection, cloudItem *cloudmodel.VMPodNodeConnection) (map[string]interface{}, bool) { return nil, false } - -func (c *VMPodNodeConnection) addCache(dbItems []*mysql.VMPodNodeConnection) { - c.cache.AddVMPodNodeConnections(dbItems) -} - -// 保留接口 -func (c *VMPodNodeConnection) updateCache(cloudItem *cloudmodel.VMPodNodeConnection, diffBase *cache.VMPodNodeConnection) { -} - -func (c *VMPodNodeConnection) deleteCache(lcuuids []string) { - c.cache.DeleteVMPodNodeConnections(lcuuids) -} diff --git a/server/controller/recorder/updater/vm_security_group.go b/server/controller/recorder/updater/vm_security_group.go index 4033f00a605..f5acbfeae5b 100644 --- a/server/controller/recorder/updater/vm_security_group.go +++ b/server/controller/recorder/updater/vm_security_group.go @@ -38,7 +38,6 @@ func NewVMSecurityGroup(wholeCache *cache.Cache, cloudData []cloudmodel.VMSecuri }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -85,15 +84,3 @@ func (v *VMSecurityGroup) generateUpdateInfo(diffBase *cache.VMSecurityGroup, cl } return nil, false } - -func (v *VMSecurityGroup) addCache(dbItems []*mysql.VMSecurityGroup) { - v.cache.AddVMSecurityGroups(dbItems) -} - -func (v *VMSecurityGroup) updateCache(cloudItem *cloudmodel.VMSecurityGroup, diffBase *cache.VMSecurityGroup) { - diffBase.Update(cloudItem) -} - -func (v *VMSecurityGroup) deleteCache(lcuuids []string) { - v.cache.DeleteVMSecurityGroups(lcuuids) -} diff --git a/server/controller/recorder/updater/vpc.go b/server/controller/recorder/updater/vpc.go index b3c8fb3b688..2912b24f6bf 100644 --- a/server/controller/recorder/updater/vpc.go +++ b/server/controller/recorder/updater/vpc.go @@ -38,7 +38,6 @@ func NewVPC(wholeCache *cache.Cache, cloudData []cloudmodel.VPC) *VPC { }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -85,15 +84,3 @@ func (v *VPC) generateUpdateInfo(diffBase *cache.VPC, cloudItem *cloudmodel.VPC) } return nil, false } - -func (v *VPC) addCache(dbItems []*mysql.VPC) { - v.cache.AddVPCs(dbItems) -} - -func (v *VPC) updateCache(cloudItem *cloudmodel.VPC, diffBase *cache.VPC) { - diffBase.Update(cloudItem) -} - -func (v *VPC) deleteCache(lcuuids []string) { - v.cache.DeleteVPCs(lcuuids) -} diff --git a/server/controller/recorder/updater/vrouter.go b/server/controller/recorder/updater/vrouter.go index 813e190e5e0..60f3c2a4c3e 100644 --- a/server/controller/recorder/updater/vrouter.go +++ b/server/controller/recorder/updater/vrouter.go @@ -38,7 +38,6 @@ func NewVRouter(wholeCache *cache.Cache, cloudData []cloudmodel.VRouter) *VRoute }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -97,16 +96,3 @@ func (r *VRouter) generateUpdateInfo(diffBase *cache.VRouter, cloudItem *cloudmo } return nil, false } - -func (r *VRouter) addCache(dbItems []*mysql.VRouter) { - r.cache.AddVRouters(dbItems) -} - -func (r *VRouter) updateCache(cloudItem *cloudmodel.VRouter, diffBase *cache.VRouter) { - diffBase.Update(cloudItem) - r.cache.UpdateVRouter(cloudItem) -} - -func (r *VRouter) deleteCache(lcuuids []string) { - r.cache.DeleteVRouters(lcuuids) -} diff --git a/server/controller/recorder/updater/wan_ip.go b/server/controller/recorder/updater/wan_ip.go index 0fab61270be..acec572c86e 100644 --- a/server/controller/recorder/updater/wan_ip.go +++ b/server/controller/recorder/updater/wan_ip.go @@ -41,7 +41,6 @@ func NewWANIP(wholeCache *cache.Cache, domainToolDataSet *cache.ToolDataSet) *WA }, } updater.dataGenerator = updater - updater.cacheHandler = updater return updater } @@ -125,15 +124,3 @@ func (i *WANIP) generateUpdateInfo(diffBase *cache.WANIP, cloudItem *cloudmodel. return updateInfo, len(updateInfo) > 0 } - -func (i *WANIP) addCache(dbItems []*mysql.WANIP) { - i.cache.AddWANIPs(dbItems) -} - -func (i *WANIP) updateCache(cloudItem *cloudmodel.IP, diffBase *cache.WANIP) { - diffBase.Update(cloudItem) -} - -func (i *WANIP) deleteCache(lcuuids []string) { - i.cache.DeleteWANIPs(lcuuids) -}