506 lines
15 KiB
Go
Executable File
506 lines
15 KiB
Go
Executable File
package resources
|
|
|
|
import (
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"reflect"
|
|
"slices"
|
|
"strings"
|
|
|
|
"cloud.o-forge.io/core/oc-lib/dbs"
|
|
"cloud.o-forge.io/core/oc-lib/models/common/pricing"
|
|
"cloud.o-forge.io/core/oc-lib/models/utils"
|
|
"cloud.o-forge.io/core/oc-lib/tools"
|
|
)
|
|
|
|
/*
|
|
* DynamicResource is a struct that represents a data resource
|
|
* it defines the resource data
|
|
*/
|
|
type DynamicResource struct {
|
|
AbstractResource
|
|
Type tools.DataType `bson:"type,omitempty" json:"type,omitempty"`
|
|
Filters dbs.Filters `bson:"filters,omitempty" json:"filters,omitempty"`
|
|
SortRules map[string]string `bson:"rules,omitempty" json:"rules,omitempty"`
|
|
|
|
PeerIds map[int]string `bson:"peer_ids,omitempty" json:"peer_ids,omitempty"`
|
|
ResourceIds map[int]string `bson:"resource_ids,omitempty" json:"resource_ids,omitempty"`
|
|
|
|
SelectedIndex int `bson:"selected_index,omitempty" json:"selected_index,omitempty"`
|
|
SelectedPartnershipIndex *int `bson:"selected_partnership_index,omitempty" json:"selected_partnership_index,omitempty"`
|
|
|
|
SelectedBuyingStrategy int `bson:"selected_buying_strategy" json:"selected_buying_strategy,omitempty"`
|
|
SelectedPricingStrategy int `bson:"selected_pricing_strategy" json:"selected_pricing_strategy,omitempty"`
|
|
|
|
Instances []ResourceInstanceITF `bson:"instances,omitempty" json:"instances,omitempty"`
|
|
WatchedDynamicResource []string `bson:"watched_dynamic_resource,omitempty" json:"watched_dynamic_resource,omitempty"`
|
|
}
|
|
|
|
// WorkspaceCandidatesProvider can be set by the workspace package to supply
|
|
// contextual workspace resources for a given DataType and request without
|
|
// creating a circular import (workspace → resources → workspace).
|
|
// When set, SetAllowedInstances uses workspace-scoped resources instead of
|
|
// the full catalog for requests that carry a username.
|
|
var WorkspaceCandidatesProvider func(dt tools.DataType, request *tools.APIRequest) []ResourceInterface
|
|
|
|
func (d *DynamicResource) GetAccessor(request *tools.APIRequest) utils.Accessor {
|
|
return nil
|
|
}
|
|
|
|
func (d *DynamicResource) SetAllowedInstances(request *tools.APIRequest, instance_id ...string) []ResourceInstanceITF {
|
|
if WorkspaceCandidatesProvider != nil {
|
|
candidates := WorkspaceCandidatesProvider(d.Type, request)
|
|
return d.SetAllowedInstancesFromSet(candidates, request, instance_id...)
|
|
}
|
|
d.Instances = []ResourceInstanceITF{}
|
|
d.sortAndResetInstances()
|
|
return d.Instances
|
|
}
|
|
|
|
// SetAllowedInstancesFromSet fills d.Instances from a pre-loaded workspace resource set
|
|
// instead of querying the catalog. Filters are applied in-memory against the candidates.
|
|
// Called by WorkspaceResourceSet.Fill so dynamic resources only see workspace-scoped resources.
|
|
func (d *DynamicResource) SetAllowedInstancesFromSet(candidates []ResourceInterface, request *tools.APIRequest, instance_id ...string) []ResourceInstanceITF {
|
|
d.Instances = []ResourceInstanceITF{}
|
|
d.PeerIds = map[int]string{}
|
|
d.ResourceIds = map[int]string{}
|
|
for _, res := range candidates {
|
|
if !d.matchesFilters(res) {
|
|
continue
|
|
}
|
|
for _, i := range res.SetAllowedInstances(request, instance_id...) {
|
|
d.PeerIds[len(d.Instances)] = res.GetCreatorID()
|
|
d.ResourceIds[len(d.Instances)] = res.GetID()
|
|
d.Instances = append(d.Instances, i)
|
|
}
|
|
}
|
|
d.sortAndResetInstances()
|
|
return d.Instances
|
|
}
|
|
|
|
func (d *DynamicResource) sortAndResetInstances() {
|
|
if d.SortRules != nil {
|
|
sorted := make([]ResourceInstanceITF, len(d.Instances))
|
|
copy(sorted, d.Instances)
|
|
slices.SortStableFunc(sorted, func(a, b ResourceInstanceITF) int {
|
|
d.SortRules["partnerships"] = "%v not contains 2"
|
|
return d.compareByRules(a, b, d.SortRules)
|
|
})
|
|
d.Instances = sorted
|
|
}
|
|
d.WatchedDynamicResource = []string{}
|
|
}
|
|
|
|
// matchesFilters applies d.Filters in-memory against a serialized resource.
|
|
// Keys in d.Filters are JSON tag names; Serialize returns JSON tag names — no bson conversion needed.
|
|
func (d *DynamicResource) matchesFilters(res ResourceInterface) bool {
|
|
if len(d.Filters.And) == 0 && len(d.Filters.Or) == 0 {
|
|
return true
|
|
}
|
|
m := res.Serialize(res)
|
|
for field, fs := range d.Filters.And {
|
|
vals := nestedVals(m, strings.Split(field, "."))
|
|
for _, f := range fs {
|
|
if !anyMatchesOp(vals, f) {
|
|
return false
|
|
}
|
|
}
|
|
}
|
|
if len(d.Filters.Or) > 0 {
|
|
matched := false
|
|
for field, fs := range d.Filters.Or {
|
|
vals := nestedVals(m, strings.Split(field, "."))
|
|
for _, f := range fs {
|
|
if anyMatchesOp(vals, f) {
|
|
matched = true
|
|
break
|
|
}
|
|
}
|
|
if matched {
|
|
break
|
|
}
|
|
}
|
|
if !matched {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// nestedVals navigates a dot-path into m and collects all leaf values.
|
|
// Arrays at any level are expanded: each element is recursed into.
|
|
func nestedVals(m map[string]interface{}, path []string) []interface{} {
|
|
if len(path) == 0 || m == nil {
|
|
return nil
|
|
}
|
|
val, ok := m[path[0]]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
if len(path) == 1 {
|
|
if arr, ok := val.([]interface{}); ok {
|
|
return arr
|
|
}
|
|
return []interface{}{val}
|
|
}
|
|
rest := path[1:]
|
|
switch v := val.(type) {
|
|
case map[string]interface{}:
|
|
return nestedVals(v, rest)
|
|
case []interface{}:
|
|
var out []interface{}
|
|
for _, elem := range v {
|
|
if em, ok := elem.(map[string]interface{}); ok {
|
|
out = append(out, nestedVals(em, rest)...)
|
|
}
|
|
}
|
|
return out
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// anyMatchesOp returns true if at least one value in vals satisfies filter f.
|
|
func anyMatchesOp(vals []interface{}, f dbs.Filter) bool {
|
|
if f.Operator == dbs.EXISTS.String() {
|
|
exists := len(vals) > 0 && vals[0] != nil
|
|
want := true
|
|
if b, ok := f.Value.(bool); ok {
|
|
want = b
|
|
}
|
|
return exists == want
|
|
}
|
|
if f.Operator == dbs.IN.String() {
|
|
list, ok := f.Value.([]interface{})
|
|
if !ok {
|
|
return false
|
|
}
|
|
for _, v := range vals {
|
|
sv := fmt.Sprintf("%v", v)
|
|
for _, item := range list {
|
|
if sv == fmt.Sprintf("%v", item) {
|
|
return true
|
|
}
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
for _, v := range vals {
|
|
if opMatches(v, f) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
func opMatches(val interface{}, f dbs.Filter) bool {
|
|
switch f.Operator {
|
|
case dbs.EQUAL.String():
|
|
return fmt.Sprintf("%v", val) == fmt.Sprintf("%v", f.Value)
|
|
case dbs.NOT.String():
|
|
return fmt.Sprintf("%v", val) != fmt.Sprintf("%v", f.Value)
|
|
case dbs.LIKE.String():
|
|
return strings.Contains(strings.ToLower(fmt.Sprintf("%v", val)), strings.ToLower(fmt.Sprintf("%v", f.Value)))
|
|
case dbs.GT.String(), dbs.GTE.String(), dbs.LT.String(), dbs.LTE.String():
|
|
return numericCmp(val, f.Value, f.Operator)
|
|
case dbs.ELEMMATCH.String():
|
|
arr, ok := val.([]interface{})
|
|
if !ok {
|
|
return false
|
|
}
|
|
sub, ok := f.Value.(map[string]interface{})
|
|
if !ok {
|
|
return false
|
|
}
|
|
for _, elem := range arr {
|
|
em, ok := elem.(map[string]interface{})
|
|
if !ok {
|
|
continue
|
|
}
|
|
allOk := true
|
|
for k, sv := range sub {
|
|
if fmt.Sprintf("%v", em[k]) != fmt.Sprintf("%v", sv) {
|
|
allOk = false
|
|
break
|
|
}
|
|
}
|
|
if allOk {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
return false
|
|
}
|
|
|
|
func numericCmp(a, b interface{}, op string) bool {
|
|
fa, aOk := toFloat64(a)
|
|
fb, bOk := toFloat64(b)
|
|
if !aOk || !bOk {
|
|
sa, sb := fmt.Sprintf("%v", a), fmt.Sprintf("%v", b)
|
|
switch op {
|
|
case dbs.GT.String():
|
|
return sa > sb
|
|
case dbs.GTE.String():
|
|
return sa >= sb
|
|
case dbs.LT.String():
|
|
return sa < sb
|
|
case dbs.LTE.String():
|
|
return sa <= sb
|
|
}
|
|
return false
|
|
}
|
|
switch op {
|
|
case dbs.GT.String():
|
|
return fa > fb
|
|
case dbs.GTE.String():
|
|
return fa >= fb
|
|
case dbs.LT.String():
|
|
return fa < fb
|
|
case dbs.LTE.String():
|
|
return fa <= fb
|
|
}
|
|
return false
|
|
}
|
|
|
|
func toFloat64(v interface{}) (float64, bool) {
|
|
switch n := v.(type) {
|
|
case float64:
|
|
return n, true
|
|
case float32:
|
|
return float64(n), true
|
|
case int:
|
|
return float64(n), true
|
|
case int32:
|
|
return float64(n), true
|
|
case int64:
|
|
return float64(n), true
|
|
}
|
|
return 0, false
|
|
}
|
|
|
|
|
|
func (d *DynamicResource) AddInstances(instance ResourceInstanceITF) {
|
|
d.Instances = append(d.Instances, instance)
|
|
}
|
|
|
|
func (d *DynamicResource) GetSelectedInstance(index *int) ResourceInstanceITF {
|
|
if len(d.Instances) == 0 {
|
|
return nil
|
|
}
|
|
for i, inst := range d.Instances {
|
|
if slices.Contains(d.WatchedDynamicResource, inst.GetID()) {
|
|
continue
|
|
}
|
|
d.WatchedDynamicResource = append(d.WatchedDynamicResource, inst.GetID())
|
|
d.SelectedIndex = i
|
|
|
|
for i := range inst.GetPartnerships() {
|
|
fmt.Println(inst.GetProfile(d.PeerIds[i], &i, &d.SelectedBuyingStrategy, &d.SelectedPricingStrategy), d.PeerIds[i], &i, &d.SelectedBuyingStrategy, &d.SelectedPricingStrategy)
|
|
if inst.GetProfile(d.PeerIds[i], &i, &d.SelectedBuyingStrategy, &d.SelectedPricingStrategy) != nil {
|
|
d.SelectedPartnershipIndex = &i
|
|
break
|
|
}
|
|
}
|
|
if d.SelectedPartnershipIndex == nil {
|
|
i := 0
|
|
d.SelectedPartnershipIndex = &i
|
|
}
|
|
return inst
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// compareByRules orders instances so those satisfying more sort rules come first.
|
|
// When both satisfy a rule, the one with the lower first-attribute value wins (ASC strict).
|
|
// Key format: "attrA" for single-%s rules, "attrA,attrB" for two-%s rules.
|
|
func (ri *DynamicResource) compareByRules(a, b ResourceInstanceITF, rules map[string]string) int {
|
|
ma := a.Serialize(a)
|
|
mb := b.Serialize(b)
|
|
for attrs, rule := range rules {
|
|
attrPaths := strings.Split(attrs, ",")
|
|
|
|
aOk, aFirst := ri.ruleMatchesAny(rule, attrPaths, ma)
|
|
bOk, bFirst := ri.ruleMatchesAny(rule, attrPaths, mb)
|
|
|
|
if aOk && !bOk {
|
|
return -1
|
|
}
|
|
if !aOk && bOk {
|
|
return 1
|
|
}
|
|
if aOk && bOk {
|
|
if aFirst < bFirst {
|
|
return -1
|
|
}
|
|
if aFirst > bFirst {
|
|
return 1
|
|
}
|
|
}
|
|
}
|
|
|
|
return 0
|
|
}
|
|
|
|
// ruleMatchesAny checks if any value (or combination for 2-%s rules) satisfies rule.
|
|
// Arrays at any path level are iterated. Returns (matched, firstMatchingValue).
|
|
func (ri *DynamicResource) ruleMatchesAny(rule string, attrPaths []string, m map[string]interface{}) (bool, string) {
|
|
placeholders := strings.Count(rule, "%s")
|
|
if placeholders == 0 {
|
|
return false, ""
|
|
}
|
|
valsA := ri.getVals(strings.Split(strings.TrimSpace(attrPaths[0]), "."), m)
|
|
if placeholders == 1 {
|
|
for _, v := range valsA {
|
|
if ri.byRules(rule, v) {
|
|
return true, fmt.Sprintf("%v", v)
|
|
}
|
|
}
|
|
return false, ""
|
|
}
|
|
if len(attrPaths) < 2 {
|
|
return false, ""
|
|
}
|
|
valsB := ri.getVals(strings.Split(strings.TrimSpace(attrPaths[1]), "."), m)
|
|
for _, a := range valsA {
|
|
for _, b := range valsB {
|
|
if ri.byRules(rule, a, b) {
|
|
return true, fmt.Sprintf("%v", a)
|
|
}
|
|
}
|
|
}
|
|
return false, ""
|
|
}
|
|
|
|
// getVals navigates attrs into m, collecting all leaf values.
|
|
// At each level it detects whether the value is a dict (map) or an array and acts accordingly:
|
|
// - array of maps → recurse into each element with the remaining path
|
|
// - array of scalars (leaf) → collect all as strings
|
|
// - map → recurse with the remaining path
|
|
func (ri *DynamicResource) getVals(attrs []string, m map[string]interface{}) []interface{} {
|
|
if len(attrs) == 0 {
|
|
return nil
|
|
}
|
|
attr := attrs[0]
|
|
if attr == "" || m[attr] == nil {
|
|
return nil
|
|
}
|
|
b, err := json.Marshal(m[attr])
|
|
if err != nil {
|
|
return nil
|
|
}
|
|
// Leaf level: detect array vs scalar.
|
|
if len(attrs) == 1 {
|
|
var arr []interface{}
|
|
if err := json.Unmarshal(b, &arr); err == nil {
|
|
results := []interface{}{}
|
|
for _, v := range arr {
|
|
results = append(results, fmt.Sprintf("%v", v))
|
|
}
|
|
return results
|
|
}
|
|
return []interface{}{m[attr]}
|
|
}
|
|
// Intermediate level: detect array of maps vs single map.
|
|
var arrMaps []map[string]interface{}
|
|
if err := json.Unmarshal(b, &arrMaps); err == nil {
|
|
results := []interface{}{}
|
|
for _, item := range arrMaps {
|
|
results = append(results, ri.getVals(attrs[1:], item)...)
|
|
}
|
|
return results
|
|
}
|
|
nm := map[string]interface{}{}
|
|
if err := json.Unmarshal(b, &nm); err != nil {
|
|
return nil
|
|
}
|
|
return ri.getVals(attrs[1:], nm)
|
|
}
|
|
|
|
func (ri *DynamicResource) byRules(rule string, vals ...interface{}) bool {
|
|
if len(vals) == 0 {
|
|
return false
|
|
}
|
|
formatted := fmt.Sprintf(rule, vals...)
|
|
// hm hm
|
|
switch {
|
|
case strings.Contains(rule, "not contains"):
|
|
a := strings.Split(formatted, " not contains ")
|
|
if reflect.TypeOf(vals[0]).Kind() == reflect.Map {
|
|
return vals[0].(map[string]interface{})[fmt.Sprintf("%v", a[1])] != nil
|
|
}
|
|
return strings.Contains(a[0], a[1])
|
|
case strings.Contains(rule, "contains"):
|
|
a := strings.Split(formatted, " contains ")
|
|
if reflect.TypeOf(vals[0]).Kind() == reflect.Map {
|
|
return vals[0].(map[string]interface{})[fmt.Sprintf("%v", a[1])] != nil
|
|
}
|
|
return strings.Contains(a[0], a[1])
|
|
case strings.Contains(rule, "<="):
|
|
a := strings.Split(formatted, " <= ")
|
|
return len(a) > 1 && a[0] <= a[1]
|
|
case strings.Contains(rule, ">="):
|
|
a := strings.Split(formatted, " >= ")
|
|
return len(a) > 1 && a[0] >= a[1]
|
|
case strings.Contains(rule, "<>"), strings.Contains(rule, "not like"):
|
|
if strings.Contains(rule, "<>") {
|
|
a := strings.Split(formatted, " <> ")
|
|
return len(a) > 1 && !strings.Contains(a[0], a[1]) && !strings.Contains(a[1], a[0])
|
|
}
|
|
a := strings.Split(formatted, " not like ")
|
|
return len(a) > 1 && !strings.Contains(a[0], a[1]) && !strings.Contains(a[1], a[0])
|
|
case strings.Contains(rule, "<"):
|
|
a := strings.Split(formatted, " < ")
|
|
return len(a) > 1 && a[0] < a[1]
|
|
case strings.Contains(rule, ">"):
|
|
a := strings.Split(formatted, " > ")
|
|
return len(a) > 1 && a[0] > a[1]
|
|
case strings.Contains(rule, "=="):
|
|
a := strings.Split(formatted, " == ")
|
|
return len(a) > 1 && a[0] == a[1]
|
|
case strings.Contains(rule, "!="):
|
|
a := strings.Split(formatted, " != ")
|
|
return len(a) > 1 && a[0] != a[1]
|
|
case strings.Contains(rule, "like"):
|
|
a := strings.Split(formatted, " like ")
|
|
return len(a) > 1 && (strings.Contains(a[0], a[1]) || strings.Contains(a[1], a[0]))
|
|
}
|
|
return false
|
|
}
|
|
|
|
func (r *DynamicResource) GetType() string {
|
|
return tools.DYNAMIC_RESOURCE.String()
|
|
}
|
|
|
|
func (abs *DynamicResource) ConvertToPricedResource(t tools.DataType, selectedInstance *int, selectedPartnership *int, selectedBuyingStrategy *int, selectedStrategy *int, selectedBookingModeIndex *int, request *tools.APIRequest) (pricing.PricedItemITF, error) {
|
|
var p pricing.PricedItemITF
|
|
var err error
|
|
for _, v := range []tools.DataType{
|
|
tools.COMPUTE_RESOURCE,
|
|
tools.DATA_RESOURCE,
|
|
tools.STORAGE_RESOURCE,
|
|
tools.PROCESSING_RESOURCE,
|
|
tools.WORKFLOW_RESOURCE,
|
|
} {
|
|
switch v {
|
|
case tools.COMPUTE_RESOURCE:
|
|
if p, err = ConvertToPricedResource[*ComputeResourcePricingProfile](t, selectedInstance, selectedPartnership, selectedBuyingStrategy, selectedStrategy, selectedBookingModeIndex, abs, request); err == nil {
|
|
return p.(*PricedResource[*ProcessingResourcePricingProfile]), nil
|
|
}
|
|
case tools.DATA_RESOURCE:
|
|
if p, err = ConvertToPricedResource[*DataResourcePricingProfile](t, selectedInstance, selectedPartnership, selectedBuyingStrategy, selectedStrategy, selectedBookingModeIndex, abs, request); err == nil {
|
|
return p.(*PricedResource[*DataResourcePricingProfile]), nil
|
|
}
|
|
case tools.STORAGE_RESOURCE:
|
|
if p, err = ConvertToPricedResource[*StorageResourcePricingProfile](t, selectedInstance, selectedPartnership, selectedBuyingStrategy, selectedStrategy, selectedBookingModeIndex, abs, request); err == nil {
|
|
return p.(*PricedResource[*StorageResourcePricingProfile]), nil
|
|
}
|
|
case tools.PROCESSING_RESOURCE:
|
|
if p, err = ConvertToPricedResource[*ProcessingResourcePricingProfile](t, selectedInstance, selectedPartnership, selectedBuyingStrategy, selectedStrategy, selectedBookingModeIndex, abs, request); err == nil {
|
|
return p.(*PricedResource[*ProcessingResourcePricingProfile]), nil
|
|
}
|
|
}
|
|
}
|
|
return nil, errors.New("can't convert priced resource")
|
|
}
|