in pkg/plugins/resources/traditional/store.go [858:1095]
func (c *traditionalStore) List(_ context.Context, resources core_model.ResourceList, fs ...store.ListOptionsFunc) error {
opts := store.NewListOptions(fs...)
switch resources.GetItemType() {
case mesh.DataplaneType:
appInstances := c.appContext.GetAllInstances()
infInstances := c.infContext.GetAllInstances()
allInstances := registry.MergeInstances(appInstances, infInstances)
// iterator services key set
for _, instances := range allInstances {
for _, ins := range instances {
key := ins.GetServiceName()
item := resources.NewItem()
dataplaneResource := item.(*mesh.DataplaneResource)
resourceMeta := &resourceMetaObject{
Name: ins.GetAddress(),
Mesh: core_model.DefaultMesh,
Labels: make(map[string]string),
}
resourceMeta.Labels[mesh_proto.Application] = key
resourceMeta.Labels[mesh_proto.Revision] = ins.GetMetadata()[dubboconstant.ExportedServicesRevisionPropertyName]
dataplaneResource.SetMeta(resourceMeta)
dataplaneResource.Spec.Networking = &mesh_proto.Dataplane_Networking{}
dataplaneResource.Spec.Extensions = map[string]string{}
dataplaneResource.Spec.Extensions[mesh_proto.Application] = key
dataplaneResource.Spec.Extensions[mesh_proto.Revision] = ins.GetMetadata()[dubboconstant.ExportedServicesRevisionPropertyName]
for k, v := range ins.GetMetadata() {
dataplaneResource.Spec.Extensions[k] = v
}
inbound := &mesh_proto.Dataplane_Networking_Inbound{
Port: uint32(ins.GetPort()),
Address: ins.GetAddress(),
Tags: ins.GetMetadata(),
}
dataplaneResource.Spec.Networking.Inbound = append(dataplaneResource.Spec.Networking.Inbound, inbound)
dataplaneResource.Spec.Networking.Address = ins.GetAddress()
if opts.Predicate(item) {
err := resources.AddItem(item)
if err != nil {
return err
}
}
}
}
case mesh.MappingType:
appMappings := c.appContext.GetMapping()
infMappings := c.infContext.GetMapping()
mappings := registry.MergeMapping(appMappings, infMappings)
for key, set := range mappings {
meta := &resourceMetaObject{
Name: key,
}
item := resources.NewItem()
item.SetMeta(meta)
mapping := item.GetSpec().(*mesh_proto.Mapping)
mapping.Zone = "default"
mapping.InterfaceName = key
var items []string
for k := range set.Items {
items = append(items, fmt.Sprintf("%v", k))
}
mapping.ApplicationNames = items
if opts.Predicate(item) {
err := resources.AddItem(item)
if err != nil {
return err
}
}
}
case mesh.MetaDataType:
// app metadata
// inf metadata
// 1. 获取到所有的key, key是application(应用名)
for app, instances := range c.appContext.GetAllInstances() {
// 2. 获取到该应用名下所有的revision
revisions := make(map[string]struct{})
for _, instance := range instances {
revisions[instance.GetMetadata()[dubboconstant.ExportedServicesRevisionPropertyName]] = struct{}{}
}
for revision := range revisions {
appMetadata := c.appContext.GetRevisionToMetadata(revision)
if appMetadata == nil {
log.Error(nil, "Err loading app metadata with id %s", app+dubboconstant.DotSeparator+revision)
continue
}
item := resources.NewItem()
metaData := item.GetSpec().(*mesh_proto.MetaData)
metaData.App = appMetadata.App
metaData.Revision = appMetadata.Revision
service := map[string]*mesh_proto.ServiceInfo{}
for key, serviceInfo := range appMetadata.Services {
service[key] = &mesh_proto.ServiceInfo{
Name: serviceInfo.Name,
Group: serviceInfo.Group,
Version: serviceInfo.Version,
Protocol: serviceInfo.Protocol,
Path: serviceInfo.Path,
Params: serviceInfo.Params,
}
}
metaData.Services = service
resourceMeta := &resourceMetaObject{
Name: app,
Version: revision,
}
resourceMeta.Labels[mesh_proto.Application] = app
resourceMeta.Labels[mesh_proto.Revision] = revision
item.SetMeta(resourceMeta)
if opts.Predicate(item) {
err := resources.AddItem(item)
if err != nil {
return err
}
}
}
}
case mesh.DynamicConfigType:
cfg, err := c.governance.GetList(consts.ConfiguratorRuleSuffix)
if err != nil {
return err
}
for name, rule := range cfg {
newIt := resources.NewItem()
dc := &mesh_proto.DynamicConfig{}
err := core_model.FromYAML([]byte(rule), dc)
if err != nil {
logger.Errorf("failed to unmarshal dynamic config from yaml %s, %s", rule, err.Error())
continue
}
_ = newIt.SetSpec(dc)
meta := &resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
Labels: maps.Clone(opts.Labels),
}
newIt.SetMeta(meta)
_ = resources.AddItem(newIt)
}
case mesh.TagRouteType:
cfg, err := c.governance.GetList(consts.TagRuleSuffix)
if err != nil {
return err
}
for name, rule := range cfg {
newIt := resources.NewItem()
ConfiguratorCfg, err := parseTagConfig(rule)
_ = newIt.SetSpec(ConfiguratorCfg)
meta := &resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
Labels: maps.Clone(opts.Labels),
}
if err != nil {
logger.Errorf("failed to unmarshal tag rule from yaml %s, %s", rule, err.Error())
continue
}
newIt.SetMeta(meta)
_ = resources.AddItem(newIt)
}
case mesh.ConditionRouteType:
cfg, err := c.governance.GetList(consts.ConditionRuleSuffix)
if err != nil {
return err
}
for name, rule := range cfg {
newIt := resources.NewItem()
ConfiguratorCfg, err := parseConditionConfig(rule)
if err != nil {
logger.Errorf("failed to unmarshal condition rule from yaml %s, %s", rule, err.Error())
continue
} else {
_ = newIt.SetSpec(ConfiguratorCfg)
meta := &resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
Labels: maps.Clone(opts.Labels),
}
newIt.SetMeta(meta)
_ = resources.AddItem(newIt)
}
}
case mesh.AffinityRouteType:
cfg, err := c.governance.GetList(consts.AffinityRuleSuffix)
if err != nil {
return err
}
for name, rule := range cfg {
newIt := resources.NewItem()
ConfiguratorCfg, err := parseAffinityConfig(rule)
if err != nil {
logger.Errorf("failed to unmarshal condition rule from yaml %s, %s", rule, err.Error())
continue
} else {
_ = newIt.SetSpec(ConfiguratorCfg)
meta := &resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
Labels: maps.Clone(opts.Labels),
}
newIt.SetMeta(meta)
_ = resources.AddItem(newIt)
}
}
default:
rootDir := getDubboCpPath(string(resources.GetItemType()))
names, err := c.regClient.GetChildren(rootDir)
if err != nil {
return err
}
for _, name := range names {
path := getDubboCpPath(string(resources.GetItemType()), name)
bytes, err := c.regClient.GetContent(path)
if err != nil {
return err
}
item := resources.NewItem()
if err = core_model.FromYAML(bytes, item.GetSpec()); err != nil {
return err
}
item.SetMeta(&resourceMetaObject{
Name: name,
Labels: maps.Clone(opts.Labels),
})
err = resources.AddItem(item)
if err != nil {
return err
}
}
}
return nil
}