in pkg/plugins/resources/traditional/store.go [604:840]
func (c *traditionalStore) Get(_ context.Context, resource core_model.Resource, fs ...store.GetOptionsFunc) error {
opts := store.NewGetOptions(fs...)
name := opts.Name
switch resource.Descriptor().Name {
case mesh.DataplaneType:
// 根据 address 匹配
instances := c.appContext.GetAllInstances()
for appName, i2 := range instances {
for _, ins := range i2 {
resourceMeta := &resourceMetaObject{
Name: ins.GetAddress(),
Mesh: opts.Mesh,
Labels: make(map[string]string),
}
resourceMeta.Labels[mesh_proto.Application] = appName
resourceMeta.Labels[mesh_proto.Revision] = ins.GetMetadata()[dubboconstant.ExportedServicesRevisionPropertyName]
resource.SetMeta(resourceMeta)
dataplaneResource := resource.(*mesh.DataplaneResource)
dataplaneResource.Spec.Networking = &mesh_proto.Dataplane_Networking{}
dataplaneResource.Spec.Extensions = map[string]string{}
dataplaneResource.Spec.Extensions[mesh_proto.Application] = appName
dataplaneResource.Spec.Extensions[mesh_proto.Revision] = ins.GetMetadata()[dubboconstant.ExportedServicesRevisionPropertyName]
dataplaneResource.Spec.Networking.Address = ins.GetAddress()
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)
if opts.Predicate(resource) {
return nil
}
}
}
case mesh.TagRouteType:
labels := opts.Labels
base := mesh_proto.Base{
Application: labels[mesh_proto.Application],
Service: labels[mesh_proto.Service],
ID: labels[mesh_proto.ID],
ServiceVersion: labels[mesh_proto.ServiceVersion],
ServiceGroup: labels[mesh_proto.ServiceGroup],
}
id := mesh_proto.BuildServiceKey(base)
path := mesh_proto.GetRoutePath(id, consts.TagRoute)
cfg, err := c.governance.GetConfig(path)
if err != nil {
return err
}
if cfg != "" {
res := &mesh_proto.TagRoute{}
if err := core_model.FromYAML([]byte(cfg), res); err != nil {
return fmt.Errorf("failed to unmarshal tag route from yaml %s, %s", cfg, err.Error())
}
err = resource.SetSpec(res)
if err != nil {
panic(err)
}
} else {
return core_store.ErrorResourceNotFound(resource.Descriptor().Name, opts.Name, opts.Mesh)
}
resource.SetMeta(&resourceMetaObject{
Name: path,
Mesh: opts.Mesh,
})
case mesh.ConditionRouteType:
labels := opts.Labels
base := mesh_proto.Base{
Application: labels[mesh_proto.Application],
Service: labels[mesh_proto.Service],
ID: labels[mesh_proto.ID],
ServiceVersion: labels[mesh_proto.ServiceVersion],
ServiceGroup: labels[mesh_proto.ServiceGroup],
}
id := mesh_proto.BuildServiceKey(base)
path := mesh_proto.GetRoutePath(id, consts.ConditionRoute)
cfg, err := c.governance.GetConfig(path)
if err != nil {
return err
}
if cfg != "" {
res, err := mesh_proto.ConditionRouteDecodeFromYAML([]byte(cfg))
if err != nil {
return fmt.Errorf("failed to unmarshal condition route from yaml %s, %s", cfg, err.Error())
}
err = resource.SetSpec(res)
if err != nil {
panic(err)
}
} else {
return core_store.ErrorResourceNotFound(resource.Descriptor().Name, opts.Name, opts.Mesh)
}
resource.SetMeta(&resourceMetaObject{
Name: path,
Mesh: opts.Mesh,
})
case mesh.DynamicConfigType:
labels := opts.Labels
base := mesh_proto.Base{
Application: labels[mesh_proto.Application],
Service: labels[mesh_proto.Service],
ID: labels[mesh_proto.ID],
ServiceVersion: labels[mesh_proto.ServiceVersion],
ServiceGroup: labels[mesh_proto.ServiceGroup],
}
key := mesh_proto.BuildServiceKey(base)
path := mesh_proto.GetOverridePath(key)
cfg, err := c.governance.GetConfig(path)
if err != nil {
return err
}
if cfg != "" {
dc := &mesh_proto.DynamicConfig{}
err := core_model.FromYAML([]byte(cfg), dc)
if err != nil {
return fmt.Errorf("failed to umarshal configurator from yaml %s, %s", cfg, err.Error())
}
err = resource.SetSpec(dc)
if err != nil {
return err
}
} else {
return core_store.ErrorResourceNotFound(resource.Descriptor().Name, opts.Name, opts.Mesh)
}
resource.SetMeta(&resourceMetaObject{
Name: path,
Mesh: opts.Mesh,
})
case mesh.AffinityRouteType:
labels := opts.Labels
base := mesh_proto.Base{
Application: labels[mesh_proto.Application],
Service: labels[mesh_proto.Service],
ID: labels[mesh_proto.ID],
ServiceVersion: labels[mesh_proto.ServiceVersion],
ServiceGroup: labels[mesh_proto.ServiceGroup],
}
key := mesh_proto.BuildServiceKey(base)
path := mesh_proto.GetRoutePath(key, consts.AffinityRoute)
cfg, err := c.governance.GetConfig(path)
if err != nil {
return err
}
if cfg != "" {
data := &mesh_proto.AffinityRoute{}
if err := core_model.FromYAML([]byte(cfg), data); err != nil {
return fmt.Errorf("failed to umarshal affinity route from yaml %s, %s", cfg, err.Error())
}
err = resource.SetSpec(data)
if err != nil {
panic(err)
}
} else {
return core_store.ErrorResourceNotFound(resource.Descriptor().Name, opts.Name, opts.Mesh)
}
resource.SetMeta(&resourceMetaObject{
Name: path,
Mesh: opts.Mesh,
})
case mesh.MappingType:
// Get通过Key获取, 不设置listener
mappings := c.appContext.GetMapping()
meta := &resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
}
resource.SetMeta(meta)
mapping := resource.GetSpec().(*mesh_proto.Mapping)
mapping.Zone = "default"
mapping.InterfaceName = name
var items []string
for k := range mappings[name].Items {
items = append(items, fmt.Sprintf("%v", k))
}
mapping.ApplicationNames = items
resource.SetMeta(&resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
})
case mesh.MetaDataType:
// 拆分name得到revision和app
revision, err2 := extractRevision(name, opts, c)
if err2 != nil {
return err2
}
var appMetadata *info.MetadataInfo
if opts.Type == "interface" {
appMetadata = c.infContext.GetMetadata(revision)
} else {
appMetadata = c.appContext.GetRevisionToMetadata(revision)
}
if appMetadata == nil {
return nil
}
metaData := resource.GetSpec().(*mesh_proto.MetaData)
metaData.App = appMetadata.App
metaData.Revision = appMetadata.Revision
service := map[string]*mesh_proto.ServiceInfo{}
for key, serviceInfo := range appMetadata.Services {
var params map[string]string
if serviceInfo.URL != nil {
params = serviceInfo.URL.ToMap()
} else {
params = serviceInfo.Params
}
service[key] = &mesh_proto.ServiceInfo{
Name: serviceInfo.Name,
Group: serviceInfo.Group,
Version: serviceInfo.Version,
Protocol: serviceInfo.Protocol,
Path: serviceInfo.Path,
Params: params,
}
}
metaData.Services = service
resource.SetMeta(&resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
})
default:
path := GenerateCpGroupPath(string(resource.Descriptor().Name), name)
value, err := c.regClient.GetContent(path)
if err != nil {
return err
}
if err := core_model.FromYAML(value, resource.GetSpec()); err != nil {
return err
}
resource.SetMeta(&resourceMetaObject{
Name: name,
Mesh: opts.Mesh,
})
}
return nil
}