clone from danieldin95

vendor/github.com/ovn-org/libovsdb/model/database.go

@@ -0,0 +1,118 @@
+package model
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/ovn-org/libovsdb/mapper"
+	"github.com/ovn-org/libovsdb/ovsdb"
+)
+
+// A DatabaseModel represents libovsdb's metadata about the database.
+// It's the result of combining the client's ClientDBModel and the server's Schema
+type DatabaseModel struct {
+	client   ClientDBModel
+	Schema   ovsdb.DatabaseSchema
+	Mapper   mapper.Mapper
+	metadata map[reflect.Type]mapper.Metadata
+}
+
+// NewDatabaseModel returns a new DatabaseModel
+func NewDatabaseModel(schema ovsdb.DatabaseSchema, client ClientDBModel) (DatabaseModel, []error) {
+	dbModel := &DatabaseModel{
+		Schema: schema,
+		client: client,
+	}
+	errs := client.validate(schema)
+	if len(errs) > 0 {
+		return DatabaseModel{}, errs
+	}
+	dbModel.Mapper = mapper.NewMapper(schema)
+	var metadata map[reflect.Type]mapper.Metadata
+	metadata, errs = generateModelInfo(schema, client.types)
+	if len(errs) > 0 {
+		return DatabaseModel{}, errs
+	}
+	dbModel.metadata = metadata
+	return *dbModel, nil
+}
+
+// NewPartialDatabaseModel returns a DatabaseModel what does not have a schema yet
+func NewPartialDatabaseModel(client ClientDBModel) DatabaseModel {
+	return DatabaseModel{
+		client: client,
+	}
+}
+
+// Valid returns whether the DatabaseModel is fully functional
+func (db DatabaseModel) Valid() bool {
+	return !reflect.DeepEqual(db.Schema, ovsdb.DatabaseSchema{})
+}
+
+// Client returns the DatabaseModel's client dbModel
+func (db DatabaseModel) Client() ClientDBModel {
+	return db.client
+}
+
+// NewModel returns a new instance of a model from a specific string
+func (db DatabaseModel) NewModel(table string) (Model, error) {
+	mtype, ok := db.client.types[table]
+	if !ok {
+		return nil, fmt.Errorf("table %s not found in database model", string(table))
+	}
+	model := reflect.New(mtype.Elem())
+	return model.Interface().(Model), nil
+}
+
+// Types returns the DatabaseModel Types
+// the DatabaseModel types is a map of reflect.Types indexed by string
+// The reflect.Type is a pointer to a struct that contains 'ovs' tags
+// as described above. Such pointer to struct also implements the Model interface
+func (db DatabaseModel) Types() map[string]reflect.Type {
+	return db.client.types
+}
+
+// FindTable returns the string associated with a reflect.Type or ""
+func (db DatabaseModel) FindTable(mType reflect.Type) string {
+	for table, tType := range db.client.types {
+		if tType == mType {
+			return table
+		}
+	}
+	return ""
+}
+
+// generateModelMetadata creates metadata objects from all models included in the
+// database and caches them for future re-use
+func generateModelInfo(dbSchema ovsdb.DatabaseSchema, modelTypes map[string]reflect.Type) (map[reflect.Type]mapper.Metadata, []error) {
+	errors := []error{}
+	metadata := make(map[reflect.Type]mapper.Metadata, len(modelTypes))
+	for tableName, tType := range modelTypes {
+		tableSchema := dbSchema.Table(tableName)
+		if tableSchema == nil {
+			errors = append(errors, fmt.Errorf("database Model contains model for table %s which is not present in schema", tableName))
+			continue
+		}
+
+		obj := reflect.New(tType.Elem()).Interface().(Model)
+		info, err := mapper.NewInfo(tableName, tableSchema, obj)
+		if err != nil {
+			errors = append(errors, err)
+			continue
+		}
+		metadata[tType] = info.Metadata
+	}
+	return metadata, errors
+}
+
+// NewModelInfo returns a mapper.Info object based on a provided model
+func (db DatabaseModel) NewModelInfo(obj interface{}) (*mapper.Info, error) {
+	meta, ok := db.metadata[reflect.TypeOf(obj)]
+	if !ok {
+		return nil, ovsdb.NewErrWrongType("NewModelInfo", "type that is part of the DatabaseModel", obj)
+	}
+	return &mapper.Info{
+		Obj:      obj,
+		Metadata: meta,
+	}, nil
+}