go.ligato.io/vpp-agent/v3@v3.5.0/cmd/agentctl/client/model.go (about)

     1  package client
     2  
     3  import (
     4  	"context"
     5  	"sort"
     6  
     7  	"github.com/sirupsen/logrus"
     8  	"google.golang.org/protobuf/encoding/prototext"
     9  
    10  	"go.ligato.io/vpp-agent/v3/cmd/agentctl/api/types"
    11  	"go.ligato.io/vpp-agent/v3/pkg/debug"
    12  	"go.ligato.io/vpp-agent/v3/pkg/models"
    13  )
    14  
    15  func (c *Client) ModelList(ctx context.Context, opts types.ModelListOptions) ([]types.Model, error) {
    16  	cfgClient, err := c.GenericClient()
    17  	if err != nil {
    18  		return nil, err
    19  	}
    20  	knownModels, err := cfgClient.KnownModels(opts.Class)
    21  	if err != nil {
    22  		return nil, err
    23  	}
    24  	for _, km := range knownModels {
    25  		kmSpec := models.ToSpec(km.GetSpec())
    26  		if _, err = models.DefaultRegistry.GetModel(kmSpec.ModelName()); err != nil {
    27  			if _, err = models.DefaultRegistry.Register(km, kmSpec); err != nil {
    28  				return nil, err
    29  			}
    30  		}
    31  	}
    32  	logrus.Debugf("retrieved %d known models", len(knownModels))
    33  	if debug.IsEnabledFor("models") {
    34  		for _, km := range knownModels {
    35  			logrus.Trace(" - ", prototext.Format(km))
    36  		}
    37  	}
    38  	allModels := convertModels(knownModels)
    39  
    40  	return sortModels(allModels), nil
    41  }
    42  
    43  // sortModels sorts models in this order:
    44  //	Class > Name > Version
    45  func sortModels(list []types.Model) []types.Model {
    46  	sort.Slice(list, func(i, j int) bool {
    47  		if list[i].Class != list[j].Class {
    48  			return list[i].Class < list[j].Class
    49  		}
    50  		if list[i].Name != list[j].Name {
    51  			return list[i].Name < list[j].Name
    52  		}
    53  		return list[i].Version < list[j].Version
    54  	})
    55  	return list
    56  }
    57  
    58  func convertModels(knownModels []*models.ModelInfo) []types.Model {
    59  	allModels := make([]types.Model, len(knownModels))
    60  	for i, m := range knownModels {
    61  		spec := models.ToSpec(m.Spec)
    62  
    63  		protoName := m.GetProtoName()
    64  		keyPrefix := spec.KeyPrefix()
    65  
    66  		var (
    67  			nameTemplate string
    68  			goType       string
    69  			pkgPath      string
    70  			protoFile    string
    71  		)
    72  		for _, o := range m.Options {
    73  			if o.GetKey() == "nameTemplate" && len(o.Values) > 0 {
    74  				nameTemplate = o.Values[0]
    75  			}
    76  			if o.GetKey() == "goType" && len(o.Values) > 0 {
    77  				goType = o.Values[0]
    78  			}
    79  			if o.GetKey() == "pkgPath" && len(o.Values) > 0 {
    80  				pkgPath = o.Values[0]
    81  			}
    82  			if o.GetKey() == "protoFile" && len(o.Values) > 0 {
    83  				protoFile = o.Values[0]
    84  			}
    85  		}
    86  		// fix key prefixes for models with no template
    87  		if nameTemplate == "" {
    88  			km, err := models.GetModel(spec.ModelName())
    89  			if err == nil && km.KeyPrefix() != keyPrefix {
    90  				logrus.Debugf("key prefix for model %v fixed from %q to %q", spec.ModelName(), keyPrefix, km.KeyPrefix())
    91  				keyPrefix = km.KeyPrefix()
    92  			}
    93  		}
    94  		model := types.Model{
    95  			Name:         spec.ModelName(),
    96  			Module:       spec.Module,
    97  			Version:      spec.Version,
    98  			Type:         spec.Type,
    99  			Class:        spec.Class,
   100  			KeyPrefix:    keyPrefix,
   101  			ProtoName:    protoName,
   102  			ProtoFile:    protoFile,
   103  			NameTemplate: nameTemplate,
   104  			GoType:       goType,
   105  			PkgPath:      pkgPath,
   106  		}
   107  		allModels[i] = model
   108  	}
   109  	return allModels
   110  }