parasite log

entrypoint.go

@@ -65,6 +65,8 @@ const (
 	NATIVE_TOOL                        = tools.NATIVE_TOOL
 	EXECUTION_VERIFICATION             = tools.EXECUTION_VERIFICATION
 	ALLOWED_IMAGE                      = tools.ALLOWED_IMAGE
+	SERVICE_RESOURCE                   = tools.SERVICE_RESOURCE
+	LIVE_SERVICE                       = tools.LIVE_SERVICE
 )
 
 func FiltersFromFlatMap(flatMap map[string]interface{}, target interface{}) *dbs.Filters {
@@ -219,7 +221,6 @@ func GetExtend(obj utils.DBObject, extends map[string][]tools.DataType, cache ma
 		}
 		for _, vv := range v {
 			if cache[vv] != nil && cache[vv][fmt.Sprintf("%v", base[k+"_id"])] != nil {
-				fmt.Println("FOUND", vv, k, cache[vv][fmt.Sprintf("%v", base[k+"_id"])])
 				base[k] = cache[vv][fmt.Sprintf("%v", base[k+"_id"])]
 				continue
 			}
@@ -241,6 +242,14 @@ func GetExtend(obj utils.DBObject, extends map[string][]tools.DataType, cache ma
 	return base
 }
 
+func ExtractTokenInfoWs(request http.Request) (string, string, []string) {
+	reqToken := request.Header.Get("Sec-WebSocket-Protocol")
+	if reqToken != "" {
+		return extractFromToken(reqToken, "user_id"), extractFromToken(reqToken, "peer_id"), strings.Split(extractFromToken(reqToken, "groups"), ",")
+	}
+	return "", "", []string{}
+}
+
 func ExtractTokenInfo(request http.Request) (string, string, []string) {
 	reqToken := request.Header.Get("Authorization")
 	splitToken := strings.Split(reqToken, "Bearer ")

models/booking/planner/planner.go

@@ -8,16 +8,18 @@ import (
 	"cloud.o-forge.io/core/oc-lib/dbs"
 	"cloud.o-forge.io/core/oc-lib/models/booking"
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
+	"cloud.o-forge.io/core/oc-lib/models/live"
 	"cloud.o-forge.io/core/oc-lib/models/resources"
 	"cloud.o-forge.io/core/oc-lib/tools"
 )
 
 // InstanceCapacity holds the maximum available resources of a single resource instance.
 type InstanceCapacity struct {
-	CPUCores  map[string]float64 `json:"cpu_cores,omitempty"`  // model -> total cores
+	CPUCores      map[string]float64 `json:"cpu_cores,omitempty"`   // model -> total cores
-	GPUMemGB  map[string]float64 `json:"gpu_mem_gb,omitempty"` // model -> total memory GB
+	GPUMemGB      map[string]float64 `json:"gpu_mem_gb,omitempty"`  // model -> total memory GB
-	RAMGB     float64            `json:"ram_gb,omitempty"`     // total RAM GB
+	RAMGB         float64            `json:"ram_gb,omitempty"`      // total RAM GB
-	StorageGB float64            `json:"storage_gb,omitempty"` // total storage GB
+	StorageGB     float64            `json:"storage_gb,omitempty"`  // total storage GB
+	MaxConcurrent float64            `json:"max_concurrent,omitempty"` // HOSTED service: max simultaneous callers
 }
 
 // ResourceRequest describes the resource amounts needed for a prospective booking.
@@ -47,11 +49,14 @@ type PlannerITF interface {
 }
 
 // Planner is a volatile (non-persisted) object that organises bookings by resource.
-// Only ComputeResource and StorageResource bookings appear in the schedule.
+// ComputeResource, StorageResource and HOSTED ServiceResource bookings appear in the schedule.
+// BlockedResources marks resources for which no matching Live was found at generation time:
+// any availability check against a blocked resource returns false immediately.
 type Planner struct {
-	GeneratedAt time.Time                               `json:"generated_at"`
+	GeneratedAt      time.Time                               `json:"generated_at"`
-	Schedule    map[string][]*PlannerSlot               `json:"schedule"`   // resource_id -> slots
+	Schedule         map[string][]*PlannerSlot               `json:"schedule"`           // resource_id -> slots
-	Capacities  map[string]map[string]*InstanceCapacity `json:"capacities"` // resource_id -> instance_id -> max capacity
+	Capacities       map[string]map[string]*InstanceCapacity `json:"capacities"`         // resource_id -> instance_id -> max capacity
+	BlockedResources map[string]bool                         `json:"blocked_resources,omitempty"` // resource_id -> no Live found
 }
 
 // Generate builds a full Planner from all active bookings.
@@ -86,9 +91,10 @@ func generate(request *tools.APIRequest, shallow bool) (*Planner, error) {
 	bookings := append(confirmed, drafts...)
 
 	p := &Planner{
-		GeneratedAt: time.Now(),
+		GeneratedAt:      time.Now(),
-		Schedule:    map[string][]*PlannerSlot{},
+		Schedule:         map[string][]*PlannerSlot{},
-		Capacities:  map[string]map[string]*InstanceCapacity{},
+		Capacities:       map[string]map[string]*InstanceCapacity{},
+		BlockedResources: map[string]bool{},
 	}
 
 	for _, b := range bookings {
@@ -100,8 +106,10 @@ func generate(request *tools.APIRequest, shallow bool) (*Planner, error) {
 			continue
 		}
 
-		// Only compute and storage resources are eligible
+		// Eligible resource types: compute, storage, and HOSTED services.
-		if bk.ResourceType != tools.COMPUTE_RESOURCE && bk.ResourceType != tools.STORAGE_RESOURCE {
+		if bk.ResourceType != tools.COMPUTE_RESOURCE &&
+			bk.ResourceType != tools.STORAGE_RESOURCE &&
+			bk.ResourceType != tools.SERVICE_RESOURCE {
 			continue
 		}
 
@@ -111,7 +119,11 @@ func generate(request *tools.APIRequest, shallow bool) (*Planner, error) {
 			end = &e
 		}
 
-		instanceID, usage, cap := extractSlotData(bk, request)
+		instanceID, usage, cap, blocked := extractSlotData(bk, request)
+		if blocked {
+			p.BlockedResources[bk.ResourceID] = true
+			continue
+		}
 		if instanceID == "" {
 			instanceID = bk.InstanceID
 		}
@@ -151,6 +163,9 @@ func generate(request *tools.APIRequest, shallow bool) (*Planner, error) {
 // Slots targeting other instances are ignored.
 // If no capacity is known for this instance (never booked), it is fully available.
 func (p *Planner) Check(resourceID string, instanceID string, req *ResourceRequest, start time.Time, end *time.Time) bool {
+	if p.BlockedResources[resourceID] {
+		return false // no Live found at generation time — cannot book
+	}
 	if end == nil {
 		e := start.Add(5 * time.Minute)
 		end = &e
@@ -265,6 +280,11 @@ func toPercentages(req *ResourceRequest, cap *InstanceCapacity) map[string]float
 		pct["storage"] = (*req.StorageGB / cap.StorageGB) * 100.0
 	}
 
+	// HOSTED service: each booking consumes one call slot.
+	if cap.MaxConcurrent > 0 {
+		pct["calls"] = (1.0 / cap.MaxConcurrent) * 100.0
+	}
+
 	return pct
 }
 
@@ -272,9 +292,11 @@ func toPercentages(req *ResourceRequest, cap *InstanceCapacity) map[string]float
 // Internal helpers
 // ---------------------------------------------------------------------------
 
-// extractSlotData parses the booking's PricedItem, loads the corresponding resource,
+// extractSlotData parses the booking's PricedItem, loads the corresponding Live resource
-// and returns the instance ID, usage percentages, and instance capacity in a single pass.
+// as the authoritative capacity source, and returns the instance ID, usage percentages,
-func extractSlotData(bk *booking.Booking, request *tools.APIRequest) (instanceID string, usage map[string]float64, cap *InstanceCapacity) {
+// capacity, and whether a matching Live was found.
+// blocked=true means no Live exists for this resource; the resource must not be scheduled.
+func extractSlotData(bk *booking.Booking, request *tools.APIRequest) (instanceID string, usage map[string]float64, cap *InstanceCapacity, blocked bool) {
 	usage = map[string]float64{}
 	if len(bk.PricedItem) == 0 {
 		return
@@ -289,6 +311,8 @@ func extractSlotData(bk *booking.Booking, request *tools.APIRequest) (instanceID
 		instanceID, usage, cap = extractComputeSlot(b, bk.ResourceID, request)
 	case tools.STORAGE_RESOURCE:
 		instanceID, usage, cap = extractStorageSlot(b, bk.ResourceID, request)
+	case tools.SERVICE_RESOURCE:
+		instanceID, usage, cap, blocked = extractServiceSlot(b, bk.ResourceID, request)
 	}
 	return
 }
@@ -381,6 +405,51 @@ func extractStorageSlot(pricedJSON []byte, resourceID string, request *tools.API
 	return
 }
 
+// extractServiceSlot extracts the instance ID, usage, and capacity for a HOSTED service booking.
+// The LiveService is the authoritative source for MaxConcurrent — the ServiceResource is not trusted.
+// If no LiveService references this resourceID, blocked=true signals the resource cannot be scheduled.
+func extractServiceSlot(pricedJSON []byte, resourceID string, request *tools.APIRequest) (instanceID string, usage map[string]float64, cap *InstanceCapacity, blocked bool) {
+	usage = map[string]float64{}
+
+	var priced resources.PricedServiceResource
+	if err := json.Unmarshal(pricedJSON, &priced); err != nil {
+		blocked = true
+		return
+	}
+
+	// LiveService is the authoritative capacity source — look it up by resources_id.
+	liveResults, _, err := (&live.LiveService{}).GetAccessor(request).Search(
+		&dbs.Filters{
+			And: map[string][]dbs.Filter{
+				"resources_id": {{Operator: dbs.EQUAL.String(), Value: resourceID}},
+			},
+		}, "*", false, 0, 1)
+	if err != nil || len(liveResults) == 0 {
+		blocked = true // no Live → cannot schedule
+		return
+	}
+	ls := liveResults[0].(*live.LiveService)
+	if ls.MaxConcurrent <= 0 {
+		blocked = true
+		return
+	}
+
+	// Instance ID: use the first instance referenced by the priced item.
+	instanceID = priced.GetID()
+	if instanceID == "" {
+		instanceID = resourceID // fallback: treat the resource itself as the instance key
+	}
+
+	maxC := float64(ls.MaxConcurrent)
+	cap = &InstanceCapacity{
+		CPUCores:      map[string]float64{},
+		GPUMemGB:      map[string]float64{},
+		MaxConcurrent: maxC,
+	}
+	usage["calls"] = (1.0 / maxC) * 100.0
+	return
+}
+
 // findComputeInstance returns the instance referenced by the priced item's InstancesRefs,
 // falling back to the first available instance.
 func findComputeInstance(compute *resources.ComputeResource, refs map[string]string) *resources.ComputeResourceInstance {

models/common/planner.go

@@ -27,16 +27,18 @@ func GetPlannerNearestStart(start time.Time, planned map[tools.DataType]map[stri
 	return near
 }
 
-// GetPlannerLongestTime returns the sum of all processing durations (conservative estimate).
+// GetPlannerLongestTime returns the sum of all processing+service durations.
-// Returns -1 if any processing is a service (open-ended).
+// Returns -1 if any item is open-ended (no deadline).
 func GetPlannerLongestTime(planned map[tools.DataType]map[string]pricing.PricedItemITF) float64 {
 	longestTime := float64(0)
-	for _, priced := range planned[tools.PROCESSING_RESOURCE] {
+	for _, dt := range []tools.DataType{tools.PROCESSING_RESOURCE, tools.SERVICE_RESOURCE} {
-		d := priced.GetExplicitDurationInS()
+		for _, priced := range planned[dt] {
-		if d < 0 {
+			d := priced.GetExplicitDurationInS()
-			return -1 // service present: booking is open-ended
+			if d < 0 {
+				return -1
+			}
+			longestTime += d
 		}
-		longestTime += d
 	}
 	return longestTime
 }

models/live/interfaces.go

@@ -1,18 +1,13 @@
 package live
 
 import (
-	"cloud.o-forge.io/core/oc-lib/models/resources"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
-	"cloud.o-forge.io/core/oc-lib/tools"
 )
 
 type LiveInterface interface {
 	utils.DBObject
+	IsCompatible(service map[string]interface{}) bool
 	GetMonitorPath() string
 	GetResourcesID() []string
 	SetResourcesID(string)
-	GetResourceAccessor(request *tools.APIRequest) utils.Accessor
-	GetResource() resources.ResourceInterface
-	GetResourceInstance() resources.ResourceInstanceITF
-	SetResourceInstance(res resources.ResourceInterface, i resources.ResourceInstanceITF) resources.ResourceInterface
 }

models/live/live.go

@@ -3,7 +3,6 @@ package live
 import (
 	"slices"
 
-	"cloud.o-forge.io/core/oc-lib/models/resources"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
 	"github.com/biter777/countries"
@@ -32,13 +31,17 @@ type LiveCerts struct {
 }
 
 // TODO in the future multiple type of certs depending of infra type
+type GeoPoint struct {
+	Latitude  float64 `json:"latitude,omitempty" bson:"latitude,omitempty"`
+	Longitude float64 `json:"longitude,omitempty" bson:"longitude,omitempty"`
+}
 
 type AbstractLive struct {
 	utils.AbstractObject
 	Certs LiveCerts `json:"certs,omitempty" bson:"certs,omitempty"`
 
 	MonitorPath    string                `json:"monitor_path,omitempty" bson:"monitor_path,omitempty"`
-	Location       resources.GeoPoint    `json:"location,omitempty" bson:"location,omitempty"`
+	Location       GeoPoint              `json:"location,omitempty" bson:"location,omitempty"`
 	Country        countries.CountryCode `json:"country,omitempty" bson:"country,omitempty"`
 	AccessProtocol string                `json:"access_protocol,omitempty" bson:"access_protocol,omitempty"`
 	ResourcesID    []string              `json:"resources_id" bson:"resources_id"`
@@ -71,9 +74,9 @@ func (d *AbstractLive) GetResourcesID() []string {
 	return d.ResourcesID
 }
 
-func (d *AbstractLive) SetResourcesID(id string) {
+func (d *AbstractLive) SetResourcesID(resourcesid string) {
-	if !slices.Contains(d.ResourcesID, id) {
+	if slices.Contains(d.ResourcesID, resourcesid) {
-		d.ResourcesID = append(d.ResourcesID, id)
+		d.ResourcesID = append(d.ResourcesID, resourcesid)
 	}
 }
 

models/live/live_datacenter.go

@@ -3,7 +3,6 @@ package live
 import (
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
 	"cloud.o-forge.io/core/oc-lib/models/common/models"
-	"cloud.o-forge.io/core/oc-lib/models/resources"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
 )
@@ -12,39 +11,34 @@ import (
 * LiveDatacenter is a struct that represents a compute units in your datacenters
  */
 
+type ComputeNode struct {
+	Name     string           `json:"name,omitempty" bson:"name,omitempty"`
+	Quantity int64            `json:"quantity" bson:"quantity" default:"1"`
+	RAM      *models.RAM      `bson:"ram,omitempty" json:"ram,omitempty"`   // RAM is the RAM
+	CPUs     map[string]int64 `bson:"cpus,omitempty" json:"cpus,omitempty"` // CPUs is the list of CPUs key is model
+	GPUs     map[string]int64 `bson:"gpus,omitempty" json:"gpus,omitempty"` // GPUs is the list of GPUs key is model
+}
 type LiveDatacenter struct {
 	AbstractLive
 
 	StorageType enum.StorageType `bson:"storage_type" json:"storage_type" default:"-1"` // Type is the type of the storage
 	Acronym     string           `bson:"acronym,omitempty" json:"acronym,omitempty"`    // Acronym is the acronym of the storage
 
-	Architecture       string                   `json:"architecture,omitempty" bson:"architecture,omitempty"` // Architecture is the architecture
+	Architecture       string                  `json:"architecture,omitempty" bson:"architecture,omitempty"` // Architecture is the architecture
-	Infrastructure     enum.InfrastructureType  `json:"infrastructure" bson:"infrastructure" default:"-1"`    // Infrastructure is the infrastructure
+	Infrastructure     enum.InfrastructureType `json:"infrastructure" bson:"infrastructure" default:"-1"`    // Infrastructure is the infrastructure
-	Source             string                   `json:"source,omitempty" bson:"source,omitempty"`             // Source is the source of the resource
+	Source             string                  `json:"source,omitempty" bson:"source,omitempty"`             // Source is the source of the resource
-	SecurityLevel      string                   `json:"security_level,omitempty" bson:"security_level,omitempty"`
+	SecurityLevel      string                  `json:"security_level,omitempty" bson:"security_level,omitempty"`
-	PowerSources       []string                 `json:"power_sources,omitempty" bson:"power_sources,omitempty"`
+	PowerSources       []string                `json:"power_sources,omitempty" bson:"power_sources,omitempty"`
-	AnnualCO2Emissions float64                  `json:"annual_co2_emissions,omitempty" bson:"co2_emissions,omitempty"`
+	AnnualCO2Emissions float64                 `json:"annual_co2_emissions,omitempty" bson:"co2_emissions,omitempty"`
-	CPUs               map[string]*models.CPU   `bson:"cpus,omitempty" json:"cpus,omitempty"` // CPUs is the list of CPUs key is model
+	CPUs               map[string]*models.CPU  `bson:"cpus,omitempty" json:"cpus,omitempty"` // CPUs is the list of CPUs key is model
-	GPUs               map[string]*models.GPU   `bson:"gpus,omitempty" json:"gpus,omitempty"` // GPUs is the list of GPUs key is model
+	GPUs               map[string]*models.GPU  `bson:"gpus,omitempty" json:"gpus,omitempty"` // GPUs is the list of GPUs key is model
-	Nodes              []*resources.ComputeNode `json:"nodes,omitempty" bson:"nodes,omitempty"`
+	Nodes              []*ComputeNode          `json:"nodes,omitempty" bson:"nodes,omitempty"`
+}
+
+func (r *LiveDatacenter) IsCompatible(service map[string]interface{}) bool {
+	return service["infrastructure"] == r.Infrastructure && service["architecture"] == r.Architecture
 }
 
 func (d *LiveDatacenter) GetAccessor(request *tools.APIRequest) utils.Accessor {
 	return NewAccessor[*LiveDatacenter](tools.LIVE_DATACENTER, request) // Create a new instance of the accessor
 }
-func (d *LiveDatacenter) GetResourceAccessor(request *tools.APIRequest) utils.Accessor {
-	return resources.NewAccessor[*resources.ComputeResource](tools.COMPUTE_RESOURCE, request)
-}
-
-func (d *LiveDatacenter) GetResource() resources.ResourceInterface {
-	return &resources.ComputeResource{}
-}
-func (d *LiveDatacenter) GetResourceInstance() resources.ResourceInstanceITF {
-	return &resources.ComputeResourceInstance{}
-}
-
-func (d *LiveDatacenter) SetResourceInstance(res resources.ResourceInterface, i resources.ResourceInstanceITF) resources.ResourceInterface {
-	r := res.(*resources.ComputeResource)
-	r.Instances = append(r.Instances, i.(*resources.ComputeResourceInstance))
-	return r
-}

models/live/live_mongo_accessor.go

@@ -1,9 +1,6 @@
 package live
 
 import (
-	"encoding/json"
-	"errors"
-
 	"cloud.o-forge.io/core/oc-lib/dbs"
 	"cloud.o-forge.io/core/oc-lib/logs"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
@@ -27,70 +24,16 @@ func NewAccessor[T LiveInterface](t tools.DataType, request *tools.APIRequest) *
 					return &LiveDatacenter{}
 				case tools.LIVE_STORAGE:
 					return &LiveStorage{}
+				case tools.LIVE_SERVICE:
+					return &LiveService{}
 				}
 				return &LiveDatacenter{}
 			},
+			NotImplemented: []string{"CopyOne"},
 		},
 	}
 }
 
-/*
-* Nothing special here, just the basic CRUD operations
- */
-func (a *liveMongoAccessor[T]) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
-	// is a publisher... that become a resources.
-	if data.IsDrafted() {
-		return nil, 422, errors.New("can't publish a drafted compute units")
-	}
-	live := data.(T)
-	/*if live.GetMonitorPath() == "" || live.GetID() != "" {
-		return nil, 422, errors.New("publishing is only allowed is it can be monitored and be accessible")
-	}*/
-	if res, code, err := a.LoadOne(live.GetID()); err != nil {
-		return nil, code, err
-	} else {
-		live = res.(T)
-	}
-	resAccess := live.GetResourceAccessor(a.Request)
-	instance := live.GetResourceInstance()
-	b, _ := json.Marshal(live)
-	json.Unmarshal(b, instance)
-
-	if len(live.GetResourcesID()) > 0 {
-		for _, r := range live.GetResourcesID() {
-			res, code, err := resAccess.LoadOne(r)
-			if err == nil {
-				return nil, code, err
-			}
-			existingResource := live.GetResource()
-			b, _ := json.Marshal(res)
-			json.Unmarshal(b, existingResource)
-			live.SetResourceInstance(existingResource, instance)
-			resAccess.UpdateOne(existingResource.Serialize(existingResource), existingResource.GetID())
-		}
-		if live.GetID() != "" {
-			return a.LoadOne(live.GetID())
-		} else {
-			return a.StoreOne(live)
-		}
-	} else {
-		r := live.GetResource()
-		b, _ := json.Marshal(live)
-		json.Unmarshal(b, &r)
-		live.SetResourceInstance(r, instance)
-		res, code, err := utils.GenericStoreOne(r, resAccess)
-		if err != nil {
-			return nil, code, err
-		}
-		live.SetResourcesID(res.GetID())
-		if live.GetID() != "" {
-			return a.UpdateOne(live.Serialize(live), live.GetID())
-		} else {
-			return a.StoreOne(live)
-		}
-	}
-}
-
 func (wfa *liveMongoAccessor[T]) LoadAll(isDraft bool, offset int64, limit int64) ([]utils.ShallowDBObject, int, error) {
 	return utils.GenericLoadAll[T](wfa.GetExec(isDraft), isDraft, wfa, offset, limit)
 }

models/live/live_service.go

@@ -0,0 +1,42 @@
+package live
+
+import (
+	"cloud.o-forge.io/core/oc-lib/models/common/enum"
+	"cloud.o-forge.io/core/oc-lib/models/utils"
+	"cloud.o-forge.io/core/oc-lib/tools"
+)
+
+type ServiceProtocol int
+
+const (
+	HTTP ServiceProtocol = iota
+	GRPC
+	WEBSOCKET
+	TCP
+)
+
+func (p ServiceProtocol) String() string {
+	return [...]string{"HTTP", "GRPC", "WEBSOCKET", "TCP"}[p]
+}
+
+// LiveService is the authoritative description of a hosted service run by the peer.
+// MaxConcurrent is the only capacity dimension that matters for scheduling:
+// it caps the number of simultaneous callers the service can accept.
+// All other service metadata (endpoint, protocol) is live-verified here
+// rather than trusted from the ServiceResource, which may be stale.
+type LiveService struct {
+	AbstractLive
+	MaxConcurrent   int                       `json:"max_concurrent" bson:"max_concurrent"`
+	Protocol        ServiceProtocol `json:"protocol" bson:"protocol" default:"0"`
+	EndpointPattern string                    `json:"endpoint_pattern,omitempty" bson:"endpoint_pattern,omitempty"`
+	HealthCheckPath string                    `json:"health_check_path,omitempty" bson:"health_check_path,omitempty"`
+	Infrastructure  enum.InfrastructureType   `json:"infrastructure" bson:"infrastructure" default:"-1"` // Infrastructure is the infrastructure
+}
+
+func (d *LiveService) GetAccessor(request *tools.APIRequest) utils.Accessor {
+	return NewAccessor[*LiveService](tools.LIVE_SERVICE, request)
+}
+
+func (r *LiveService) IsCompatible(service map[string]interface{}) bool {
+	return service["infrastructure"] == r.Infrastructure
+}

models/live/live_storage.go

@@ -2,7 +2,6 @@ package live
 
 import (
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
-	"cloud.o-forge.io/core/oc-lib/models/resources"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
 )
@@ -14,6 +13,7 @@ import (
 type LiveStorage struct {
 	AbstractLive
 
+	StorageType   enum.StorageType `bson:"storage_type" json:"storage_type" default:"-1"`
 	Source        string           `bson:"source,omitempty" json:"source,omitempty"` // Source is the source of the storage
 	Path          string           `bson:"path,omitempty" json:"path,omitempty"`     // Path is the store folders in the source
 	Local         bool             `bson:"local" json:"local"`
@@ -25,22 +25,10 @@ type LiveStorage struct {
 	Throughput    string           `bson:"throughput,omitempty" json:"throughput,omitempty"` // Throughput is the throughput of the storage
 }
 
+func (r *LiveStorage) IsCompatible(service map[string]interface{}) bool {
+	return service["storage_type"] == r.StorageType
+}
+
 func (d *LiveStorage) GetAccessor(request *tools.APIRequest) utils.Accessor {
 	return NewAccessor[*LiveStorage](tools.LIVE_STORAGE, request) // Create a new instance of the accessor
 }
-func (d *LiveStorage) GetResourceAccessor(request *tools.APIRequest) utils.Accessor {
-	return resources.NewAccessor[*resources.StorageResource](tools.STORAGE_RESOURCE, request)
-}
-
-func (d *LiveStorage) GetResource() resources.ResourceInterface {
-	return &resources.StorageResource{}
-}
-func (d *LiveStorage) GetResourceInstance() resources.ResourceInstanceITF {
-	return &resources.StorageResourceInstance{}
-}
-
-func (d *LiveStorage) SetResourceInstance(res resources.ResourceInterface, i resources.ResourceInstanceITF) resources.ResourceInterface {
-	r := res.(*resources.StorageResource)
-	r.Instances = append(r.Instances, i.(*resources.StorageResourceInstance))
-	return r
-}

models/live/tests/live_test.go

@@ -79,18 +79,6 @@ func TestLiveDatacenter_GetAccessor_NilRequest(t *testing.T) {
 	assert.NotNil(t, acc)
 }
 
-func TestLiveDatacenter_GetResource(t *testing.T) {
-	dc := &live.LiveDatacenter{}
-	res := dc.GetResource()
-	assert.NotNil(t, res)
-}
-
-func TestLiveDatacenter_GetResourceInstance(t *testing.T) {
-	dc := &live.LiveDatacenter{}
-	inst := dc.GetResourceInstance()
-	assert.NotNil(t, inst)
-}
-
 func TestLiveDatacenter_IDAndName(t *testing.T) {
 	dc := &live.LiveDatacenter{}
 	dc.AbstractLive.AbstractObject = utils.AbstractObject{UUID: "dc-id", Name: "dc-name"}
@@ -124,18 +112,6 @@ func TestLiveStorage_GetAccessor(t *testing.T) {
 	assert.NotNil(t, acc)
 }
 
-func TestLiveStorage_GetResource(t *testing.T) {
-	s := &live.LiveStorage{}
-	res := s.GetResource()
-	assert.NotNil(t, res)
-}
-
-func TestLiveStorage_GetResourceInstance(t *testing.T) {
-	s := &live.LiveStorage{}
-	inst := s.GetResourceInstance()
-	assert.NotNil(t, inst)
-}
-
 func TestLiveStorage_SetResourcesID_NoDuplication(t *testing.T) {
 	s := &live.LiveStorage{}
 	s.SetResourcesID("storage-1")

models/models.go

@@ -46,6 +46,7 @@ var ModelsCatalog = map[string]func() utils.DBObject{
 	tools.PURCHASE_RESOURCE.String():      func() utils.DBObject { return &purchase_resource.PurchaseResource{} },
 	tools.LIVE_DATACENTER.String():        func() utils.DBObject { return &live.LiveDatacenter{} },
 	tools.LIVE_STORAGE.String():           func() utils.DBObject { return &live.LiveStorage{} },
+	tools.LIVE_SERVICE.String():           func() utils.DBObject { return &live.LiveService{} },
 	tools.BILL.String():                   func() utils.DBObject { return &bill.Bill{} },
 	tools.EXECUTION_VERIFICATION.String(): func() utils.DBObject { return &execution_verification.ExecutionVerification{} },
 	tools.ALLOWED_IMAGE.String():          func() utils.DBObject { return &allowed_image.AllowedImage{} },

models/resources/compute.go

@@ -9,6 +9,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
 	"cloud.o-forge.io/core/oc-lib/models/common/models"
 	"cloud.o-forge.io/core/oc-lib/models/common/pricing"
+	"cloud.o-forge.io/core/oc-lib/models/live"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
 	"github.com/google/uuid"
@@ -46,14 +47,6 @@ func (abs *ComputeResource) ConvertToPricedResource(t tools.DataType, selectedIn
 	}, nil
 }
 
-type ComputeNode struct {
-	Name     string           `json:"name,omitempty" bson:"name,omitempty"`
-	Quantity int64            `json:"quantity" bson:"quantity" default:"1"`
-	RAM      *models.RAM      `bson:"ram,omitempty" json:"ram,omitempty"`   // RAM is the RAM
-	CPUs     map[string]int64 `bson:"cpus,omitempty" json:"cpus,omitempty"` // CPUs is the list of CPUs key is model
-	GPUs     map[string]int64 `bson:"gpus,omitempty" json:"gpus,omitempty"` // GPUs is the list of GPUs key is model
-}
-
 type ComputeResourceInstance struct {
 	ResourceInstance[*ComputeResourcePartnership]
 	Source             string                 `json:"source,omitempty" bson:"source,omitempty"`
@@ -62,7 +55,7 @@ type ComputeResourceInstance struct {
 	AnnualCO2Emissions float64                `json:"annual_co2_emissions,omitempty" bson:"co2_emissions,omitempty"`
 	CPUs               map[string]*models.CPU `bson:"cpus,omitempty" json:"cpus,omitempty"`
 	GPUs               map[string]*models.GPU `bson:"gpus,omitempty" json:"gpus,omitempty"`
-	Nodes              []*ComputeNode         `json:"nodes,omitempty" bson:"nodes,omitempty"`
+	Nodes              []*live.ComputeNode    `json:"nodes,omitempty" bson:"nodes,omitempty"`
 	// AvailableStorages lists storage capabilities activatable on this compute unit (e.g. Minio, local volumes).
 	// These are shallow StorageResource entries — not independent catalog items — but carry full pricing structure.
 	AvailableStorages []*StorageResource `json:"available_storages,omitempty" bson:"available_storages,omitempty"`

models/resources/dynamic.go

@@ -0,0 +1,298 @@
+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   map[string]interface{} `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"`
+}
+
+func (d *DynamicResource) GetAccessor(request *tools.APIRequest) utils.Accessor {
+	return nil
+}
+
+func (d *DynamicResource) SetAllowedInstances(request *tools.APIRequest, instance_id ...string) []ResourceInstanceITF {
+	d.Instances = []ResourceInstanceITF{}
+	for k, v := range map[tools.DataType]ResourceInterface{
+		tools.COMPUTE_RESOURCE:    &ComputeResource{},
+		tools.DATA_RESOURCE:       &DataResource{},
+		tools.STORAGE_RESOURCE:    &StorageResource{},
+		tools.PROCESSING_RESOURCE: &ProcessingResource{},
+		tools.WORKFLOW_RESOURCE:   &WorkflowResource{}} {
+		if d.Type != k {
+			continue
+		}
+		access := NewAccessor[*DynamicResource](k, request)
+		a, _, _ := access.Search(dbs.FiltersFromFlatMap(d.Filters, v), "", false, 0, 100000)
+		d.PeerIds = map[int]string{}
+		d.ResourceIds = map[int]string{}
+		for _, res := range a {
+			for _, i := range res.(ResourceInterface).SetAllowedInstances(request, instance_id...) {
+				d.PeerIds[len(d.Instances)] = res.GetCreatorID()
+				d.ResourceIds[len(d.Instances)] = res.GetID()
+				d.Instances = append(d.Instances, i)
+			}
+		}
+		break
+	}
+	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.WatchedDynamicResource = []string{}
+	return d.Instances
+}
+
+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() {
+			if inst.GetProfile(d.PeerIds[i], &i, &d.SelectedBuyingStrategy, &d.SelectedPricingStrategy) != nil {
+				d.SelectedPartnershipIndex = &i
+				break
+			}
+		}
+		if d.SelectedPartnershipIndex == nil {
+			continue
+		}
+		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")
+}

models/resources/interfaces.go

@@ -42,6 +42,7 @@ type ResourceInstanceITF interface {
 	GetPricingsProfiles(peerID string, groups []string) []pricing.PricingProfileITF
 	GetPeerGroups() ([]ResourcePartnerITF, []map[string][]string)
 	ClearPeerGroups()
+	GetPartnerships() []ResourcePartnerITF
 	GetAverageDurationS() float64
 	UpdateAverageDuration(actualS float64)
 }

models/resources/models.go

@@ -13,7 +13,10 @@ type ResourceSet struct {
 	Workflows   []string `bson:"workflows,omitempty" json:"workflows,omitempty"`
 	NativeTool  []string `bson:"native,omitempty" json:"native,omitempty"`
 	Services    []string `bson:"services,omitempty" json:"services,omitempty"`
+	Dynamics    []string `bson:"dynamics,omitempty" json:"dynamics,omitempty"`
 
+	// DynamicResources are stored inline — no DB collection, resolved at runtime via SetAllowedInstances.
+	DynamicResources    []*DynamicResource    `bson:"-" json:"dynamic_resources,omitempty"`
 	DataResources       []*DataResource       `bson:"-" json:"data_resources,omitempty"`
 	StorageResources    []*StorageResource    `bson:"-" json:"storage_resources,omitempty"`
 	ProcessingResources []*ProcessingResource `bson:"-" json:"processing_resources,omitempty"`
@@ -30,6 +33,7 @@ func (r *ResourceSet) Clear() {
 	r.ComputeResources = nil
 	r.WorkflowResources = nil
 	r.ServiceResources = nil
+	r.DynamicResources = nil
 }
 
 func (r *ResourceSet) Fill(request *tools.APIRequest) {
@@ -41,6 +45,7 @@ func (r *ResourceSet) Fill(request *tools.APIRequest) {
 		(&ProcessingResource{}): r.Processings,
 		(&WorkflowResource{}):   r.Workflows,
 		(&ServiceResource{}):    r.Services,
+		(&DynamicResource{}):    r.Dynamics,
 	} {
 		for _, id := range v {
 			d, _, e := k.GetAccessor(request).LoadOne(id)
@@ -58,10 +63,15 @@ func (r *ResourceSet) Fill(request *tools.APIRequest) {
 					r.WorkflowResources = append(r.WorkflowResources, d.(*WorkflowResource))
 				case *ServiceResource:
 					r.ServiceResources = append(r.ServiceResources, d.(*ServiceResource))
+				case *DynamicResource:
+					r.DynamicResources = append(r.DynamicResources, d.(*DynamicResource))
 				}
 			}
 		}
 	}
+	for _, d := range r.DynamicResources {
+		d.SetAllowedInstances(request)
+	}
 }
 
 type ItemResource struct {
@@ -72,4 +82,5 @@ type ItemResource struct {
 	Workflow   *WorkflowResource   `bson:"workflow,omitempty" json:"workflow,omitempty"`
 	NativeTool *NativeTool         `bson:"native_tools,omitempty" json:"native_tools,omitempty"`
 	Service    *ServiceResource    `bson:"service,omitempty" json:"service,omitempty"`
+	Dynamic    *DynamicResource    `bson:"dynamic,omitempty" json:"dynamic,omitempty"`
 }

models/resources/processing.go

@@ -28,7 +28,6 @@ type ProcessingUsage struct {
  */
 type ProcessingResource struct {
 	AbstractInstanciatedResource[*ProcessingInstance]
-	IsEvent        bool                    `json:"is_event,omitempty" bson:"is_event,omitempty"`
 	Infrastructure enum.InfrastructureType `json:"infrastructure" bson:"infrastructure" default:"-1"`
 	Usage          *ProcessingUsage        `bson:"usage,omitempty" json:"usage,omitempty"`
 	OpenSource     bool                    `json:"open_source" bson:"open_source" default:"false"`

models/resources/purchase_resource/purchase_resource_accessor.go

@@ -1,7 +1,6 @@
 package purchase_resource
 
 import (
-	"fmt"
 	"time"
 
 	"cloud.o-forge.io/core/oc-lib/logs"
@@ -30,7 +29,6 @@ func NewAccessor(request *tools.APIRequest) *PurchaseResourceMongoAccessor {
  */
 func (a *PurchaseResourceMongoAccessor) LoadOne(id string) (utils.DBObject, int, error) {
 	return utils.GenericLoadOne(id, a.New(), func(d utils.DBObject) (utils.DBObject, int, error) {
-		fmt.Println("FOUND PURCHASE", d)
 		if d.(*PurchaseResource).EndDate != nil && time.Now().UTC().After(*d.(*PurchaseResource).EndDate) {
 			utils.GenericDelete(d, a)
 			return nil, 404, nil

models/resources/resource.go

@@ -11,6 +11,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/booking"
 	"cloud.o-forge.io/core/oc-lib/models/common/models"
 	"cloud.o-forge.io/core/oc-lib/models/common/pricing"
+	"cloud.o-forge.io/core/oc-lib/models/live"
 	"cloud.o-forge.io/core/oc-lib/models/peer"
 	"cloud.o-forge.io/core/oc-lib/models/resources/purchase_resource"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
@@ -19,6 +20,10 @@ import (
 	"github.com/google/uuid"
 )
 
+func FiltersFromFlatMap(flatMap map[string]interface{}, target interface{}) *dbs.Filters {
+	return dbs.FiltersFromFlatMap(flatMap, target)
+}
+
 // AbstractResource is the struct containing all of the attributes commons to all ressources
 type AbstractResource struct {
 	utils.AbstractObject                                                   // AbstractObject contains the basic fields of an object (id, name)
@@ -246,17 +251,12 @@ func VerifyAuthAction[T ResourceInstanceITF](baseInstance []T, request *tools.AP
 	return instances
 }
 
-type GeoPoint struct {
-	Latitude  float64 `json:"latitude,omitempty" bson:"latitude,omitempty"`
-	Longitude float64 `json:"longitude,omitempty" bson:"longitude,omitempty"`
-}
-
 type ResourceInstance[T ResourcePartnerITF] struct {
 	utils.AbstractObject
 	ContentType    string                `json:"content_type,omitempty" bson:"content_type,omitempty"`
 	LastUpdate     time.Time             `json:"last_update,omitempty" bson:"last_update,omitempty"`
 	Origin         OriginMeta            `json:"origin,omitempty" bson:"origin,omitempty"`
-	Location       GeoPoint              `json:"location,omitempty" bson:"location,omitempty"`
+	Location       live.GeoPoint         `json:"location,omitempty" bson:"location,omitempty"`
 	Country        countries.CountryCode `json:"country,omitempty" bson:"country,omitempty"`
 	AccessProtocol string                `json:"access_protocol,omitempty" bson:"access_protocol,omitempty"`
 
@@ -381,6 +381,14 @@ func (ri *ResourceInstance[T]) UpdateAverageDuration(actualS float64) {
 	ri.AverageDurationSamples++
 }
 
+func (ri *ResourceInstance[T]) GetPartnerships() []ResourcePartnerITF {
+	rt := []ResourcePartnerITF{}
+	for _, p := range ri.Partnerships {
+		rt = append(rt, p)
+	}
+	return rt
+}
+
 type ResourcePartnerShip[T pricing.PricingProfileITF] struct {
 	Namespace       string              `json:"namespace" bson:"namespace" default:"default-namespace"`
 	PeerGroups      map[string][]string `json:"peer_groups,omitempty" bson:"peer_groups,omitempty"`

models/resources/resource_accessor.go

@@ -2,10 +2,12 @@ package resources
 
 import (
 	"errors"
+	"fmt"
 	"slices"
 
 	"cloud.o-forge.io/core/oc-lib/dbs"
 	"cloud.o-forge.io/core/oc-lib/logs"
+	"cloud.o-forge.io/core/oc-lib/models/live"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
 )
@@ -67,7 +69,12 @@ func (dca *ResourceMongoAccessor[T]) LoadOne(id string) (utils.DBObject, int, er
 
 func (dca *ResourceMongoAccessor[T]) UpdateOne(set map[string]interface{}, id string) (utils.DBObject, int, error) {
 	if dca.GetType() == tools.COMPUTE_RESOURCE {
-		return nil, 404, errors.New("can't update a non existing computing units resource not reported onto compute units catalog")
+		delete(set, "architecture")
+		delete(set, "infrastructure")
+	} else if dca.GetType() == tools.SERVICE_RESOURCE {
+		delete(set, "infrastructure")
+	} else if dca.GetType() == tools.STORAGE_RESOURCE {
+		delete(set, "storage_type")
 	}
 	return utils.GenericUpdateOne(set, id, dca)
 }
@@ -77,16 +84,66 @@ func (dca *ResourceMongoAccessor[T]) ShouldVerifyAuth() bool {
 }
 
 func (dca *ResourceMongoAccessor[T]) StoreOne(data utils.DBObject) (utils.DBObject, int, error) {
+	var i string
+	idsToUpdate := []string{}
+	var a utils.Accessor
 	if dca.GetType() == tools.COMPUTE_RESOURCE {
-		return nil, 404, errors.New("can't create a non existing computing units resource not reported onto compute units catalog")
+		r := data.(*ComputeResource)
+		if len(r.Instances) == 0 {
+			return nil, 404, errors.New("can't create a non existing computing units resource with no instances")
+		}
+		a = live.NewAccessor[*live.LiveDatacenter](tools.LIVE_DATACENTER, &tools.APIRequest{Admin: true})
+		res, _, _ := a.LoadOne(r.Instances[0].GetID())
+		if res == nil {
+			return nil, 404, errors.New("can't create a non existing computing units resource not reported onto compute units catalog")
+		}
+		if !res.(*live.LiveDatacenter).IsCompatible(data.Serialize(data)) {
+			return nil, 404, errors.New("live computing units  target is not compatible")
+		}
+		i = res.GetID()
+		idsToUpdate = res.(*live.LiveDatacenter).ResourcesID
+	} else if dca.GetType() == tools.SERVICE_RESOURCE {
+		r := data.(*ServiceResource)
+		if len(r.Instances) == 0 {
+			return nil, 404, errors.New("can't create a non existing service resource with no instances")
+		}
+		a = live.NewAccessor[*live.LiveService](tools.LIVE_SERVICE, &tools.APIRequest{Admin: true})
+		res, _, _ := a.LoadOne(r.Instances[0].GetID())
+		if res == nil {
+			return nil, 404, errors.New("can't create a non existing service resource not reported onto compute units catalog")
+		}
+		if !res.(*live.LiveService).IsCompatible(data.Serialize(data)) {
+			return nil, 404, errors.New("live service target is not compatible")
+		}
+		i = res.GetID()
+		idsToUpdate = res.(*live.LiveService).ResourcesID
+	} else if dca.GetType() == tools.STORAGE_RESOURCE {
+		r := data.(*StorageResource)
+		if len(r.Instances) == 0 {
+			return nil, 404, errors.New("can't create a non existing storage resource with no instances")
+		}
+		a = live.NewAccessor[*live.LiveStorage](tools.LIVE_STORAGE, &tools.APIRequest{Admin: true})
+		res, _, _ := a.LoadOne(r.Instances[0].GetID())
+		if res == nil {
+			return nil, 404, errors.New("can't create a non existing storage resource not reported onto compute units catalog")
+		}
+		if !res.(*live.LiveStorage).IsCompatible(data.Serialize(data)) {
+			return nil, 404, errors.New("live storage target is not compatible")
+		}
+		i = res.GetID()
+		idsToUpdate = res.(*live.LiveStorage).ResourcesID
 	}
-	return utils.GenericStoreOne(data, dca)
+	res, code, err := utils.GenericStoreOne(data, dca)
+	if res != nil && i != "" {
+		idsToUpdate = append(idsToUpdate, res.GetID())
+		a.UpdateOne(map[string]interface{}{
+			"resources_id": idsToUpdate,
+		}, i)
+	}
+	return res, code, err
 }
 
 func (dca *ResourceMongoAccessor[T]) CopyOne(data utils.DBObject) (utils.DBObject, int, error) {
-	if dca.GetType() == tools.COMPUTE_RESOURCE {
-		return nil, 404, errors.New("can't copy/publish a non existing computing units resource not reported onto compute units catalog")
-	}
 	return dca.StoreOne(data)
 }
 
@@ -97,8 +154,10 @@ func (wfa *ResourceMongoAccessor[T]) LoadAll(isDraft bool, offset int64, limit i
 func (wfa *ResourceMongoAccessor[T]) Search(filters *dbs.Filters, search string, isDraft bool, offset int64, limit int64) ([]utils.ShallowDBObject, int, error) {
 	if filters == nil && search == "*" {
 		return utils.GenericLoadAll[T](func(d utils.DBObject) utils.ShallowDBObject {
+			fmt.Println("Search", d)
 			d.(T).VerifyBuy()
 			d.(T).SetAllowedInstances(wfa.Request)
+			fmt.Println("Search2", d)
 			return d
 		}, isDraft, wfa, offset, limit)
 	}

models/resources/service.go

@@ -7,6 +7,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
 	"cloud.o-forge.io/core/oc-lib/models/common/models"
 	"cloud.o-forge.io/core/oc-lib/models/common/pricing"
+	"cloud.o-forge.io/core/oc-lib/models/live"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/tools"
 	"github.com/google/uuid"
@@ -23,19 +24,6 @@ func (m ServiceMode) String() string {
 	return [...]string{"DEPLOYMENT", "HOSTED"}[m]
 }
 
-type ServiceProtocol int
-
-const (
-	HTTP      ServiceProtocol = iota
-	GRPC
-	WEBSOCKET
-	TCP
-)
-
-func (p ServiceProtocol) String() string {
-	return [...]string{"HTTP", "GRPC", "WEBSOCKET", "TCP"}[p]
-}
-
 type ServiceUsage struct {
 	CPUs         map[string]*models.CPU `bson:"cpus,omitempty" json:"cpus,omitempty"`
 	GPUs         map[string]*models.GPU `bson:"gpus,omitempty" json:"gpus,omitempty"`
@@ -48,10 +36,10 @@ type ServiceUsage struct {
 // ServiceResourceAccess describes how to reach the service once running.
 // Populated for HOSTED instances (endpoint already known) and as a template for DEPLOYMENT.
 type ServiceResourceAccess struct {
-	Container       *models.Container `json:"container,omitempty" bson:"container,omitempty"`
+	Container       *models.Container    `json:"container,omitempty" bson:"container,omitempty"`
-	Protocol        ServiceProtocol   `json:"protocol" bson:"protocol" default:"0"`
+	Protocol        live.ServiceProtocol `json:"protocol" bson:"protocol" default:"0"`
-	EndpointPattern string            `json:"endpoint_pattern,omitempty" bson:"endpoint_pattern,omitempty"`
+	EndpointPattern string               `json:"endpoint_pattern,omitempty" bson:"endpoint_pattern,omitempty"`
-	HealthCheckPath string            `json:"health_check_path,omitempty" bson:"health_check_path,omitempty"`
+	HealthCheckPath string               `json:"health_check_path,omitempty" bson:"health_check_path,omitempty"`
 }
 
 type ServiceResource struct {
@@ -85,8 +73,9 @@ func (abs *ServiceResource) ConvertToPricedResource(t tools.DataType, selectedIn
 
 type ServiceInstance struct {
 	ResourceInstance[*ServiceResourcePartnership]
-	Mode   ServiceMode            `json:"mode" bson:"mode" default:"0"`
+	Mode          ServiceMode            `json:"mode" bson:"mode" default:"0"`
-	Access *ServiceResourceAccess `json:"access,omitempty" bson:"access,omitempty"`
+	Access        *ServiceResourceAccess `json:"access,omitempty" bson:"access,omitempty"`
+	MaxConcurrent int                    `json:"max_concurrent,omitempty" bson:"max_concurrent,omitempty"`
 }
 
 func (ri *ServiceInstance) IsPeerless() bool { return false }
@@ -110,7 +99,7 @@ type ServiceResourcePartnership struct {
 //   - DEPLOYMENT: uptime billing via ExploitPricingProfile (pay while service is up)
 //   - HOSTED:     per-call billing via AccessPricingProfile (pay per request)
 type ServiceResourcePricingProfile struct {
-	Mode          ServiceMode                                                  `json:"mode" bson:"mode"`
+	Mode          ServiceMode                                                 `json:"mode" bson:"mode"`
 	UptimePricing *pricing.ExploitPricingProfile[pricing.TimePricingStrategy] `json:"uptime_pricing,omitempty" bson:"uptime_pricing,omitempty"`
 	AccessPricing *pricing.AccessPricingProfile[pricing.TimePricingStrategy]  `json:"access_pricing,omitempty" bson:"access_pricing,omitempty"`
 }
@@ -203,7 +192,7 @@ func (a *PricedServiceResource) GetExplicitDurationInS() float64 {
 		return a.BookingConfiguration.ExplicitBookingDurationS
 	}
 	if a.BookingConfiguration.UsageStart == nil || a.BookingConfiguration.UsageEnd == nil {
-		return (5 * time.Minute).Seconds()
+		return -1 // no deadline specified: open-ended
 	}
 	return a.BookingConfiguration.UsageEnd.Sub(*a.BookingConfiguration.UsageStart).Seconds()
 }

models/resources/storage.go

@@ -12,6 +12,17 @@ import (
 	"github.com/google/uuid"
 )
 
+// EmbeddedStorageSelection records which storage capability was activated on a
+// compute unit graph node, and which pricing options were selected for it.
+// Key in WorkflowExecution.SelectedEmbeddedStorages is the compute graph node ID.
+// A nil/absent entry means no storage was activated on that compute unit.
+type EmbeddedStorageSelection struct {
+	StorageIndex     int `json:"storage_index" bson:"storage_index"`         // index in ComputeResourceInstance.AvailableStorages
+	PartnershipIndex int `json:"partnership_index" bson:"partnership_index"` // index in the storage's partnerships
+	BuyingIndex      int `json:"buying_index" bson:"buying_index"`
+	StrategyIndex    int `json:"strategy_index" bson:"strategy_index"`
+}
+
 /*
 * StorageResource is a struct that represents a storage resource
 * it defines the resource storage

models/workflow/graph/graph.go

@@ -69,6 +69,10 @@ func (wf *Graph) IsWorkflow(item GraphItem) bool {
 	return item.Workflow != nil
 }
 
+func (wf *Graph) IsDynamic(item GraphItem) bool {
+	return item.Dynamic != nil
+}
+
 func (g *Graph) GetAverageTimeRelatedToProcessingActivity(processings []*resources.ProcessingResource, resource resources.ResourceInterface,
 	f func(GraphItem) resources.ResourceInterface, instance int, partnership int, buying int, strategy int, bookingMode int, request *tools.APIRequest) (float64, float64, error) {
 	oneIsInfinite := false

models/workflow/graph/item.go

@@ -29,6 +29,8 @@ func (g *GraphItem) GetResource() (tools.DataType, resources.ResourceInterface)
 		return tools.NATIVE_TOOL, g.NativeTool
 	} else if g.Service != nil {
 		return tools.SERVICE_RESOURCE, g.Service
+	} else if g.Dynamic != nil {
+		return tools.DYNAMIC_RESOURCE, g.Dynamic
 	}
 	return tools.INVALID, nil
 }
@@ -40,4 +42,5 @@ func (g *GraphItem) Clear() {
 	g.Processing = nil
 	g.Storage = nil
 	g.Service = nil
+	g.Dynamic = nil
 }

models/workflow/workflow.go

@@ -47,11 +47,12 @@ type Workflow struct {
 	// Schedule       *WorkflowSchedule `bson:"schedule,omitempty" json:"schedule,omitempty"` // Schedule is the schedule of the workflow
 	Shared []string `json:"shared,omitempty" bson:"shared,omitempty"` // Shared is the ID of the shared workflow     // AbstractWorkflow contains the basic fields of a workflow
 
-	Env     map[string][]models.Param  `json:"env" bson:"env"`
+	Env                      map[string][]models.Param                      `json:"env" bson:"env"`
-	Inputs  map[string][]models.Param  `json:"inputs" bson:"inputs"`
+	Inputs                   map[string][]models.Param                      `json:"inputs" bson:"inputs"`
-	Outputs map[string][]models.Param  `json:"outputs" bson:"outputs"`
+	Outputs                  map[string][]models.Param                      `json:"outputs" bson:"outputs"`
-	Args    map[string][]string        `json:"args" bson:"args"`
+	Args                     map[string][]string                            `json:"args" bson:"args"`
-	Exposes map[string][]models.Expose `bson:"exposes" json:"exposes"` // Expose is the execution
+	Exposes                  map[string][]models.Expose                     `bson:"exposes" json:"exposes"` // Expose is the execution
+	SelectedEmbeddedStorages map[string]*resources.EmbeddedStorageSelection `json:"selected_embedded_storages,omitempty"`
 }
 
 func (d *Workflow) GetAccessor(request *tools.APIRequest) utils.Accessor {
@@ -96,7 +97,13 @@ func (d *Workflow) GetResources(dt tools.DataType) []resources.ResourceInterface
 			itf = append(itf, d)
 		}
 		return itf
+	case tools.DYNAMIC_RESOURCE:
+		for _, d := range d.DynamicResources {
+			itf = append(itf, d)
+		}
+		return itf
 	}
+
 	return itf
 }
 
@@ -112,12 +119,16 @@ func (d *Workflow) ExtractFromPlantUML(plantUML multipart.File, request *tools.A
 	d.Processings = []string{}
 	d.Computes = []string{}
 	d.Workflows = []string{}
+	d.Dynamics = []string{}
+	d.Services = []string{}
 
 	d.DataResources = []*resources.DataResource{}
 	d.StorageResources = []*resources.StorageResource{}
 	d.ProcessingResources = []*resources.ProcessingResource{}
 	d.ComputeResources = []*resources.ComputeResource{}
 	d.WorkflowResources = []*resources.WorkflowResource{}
+	d.DynamicResources = []*resources.DynamicResource{}
+	d.ServiceResources = []*resources.ServiceResource{}
 
 	d.Graph = graph.NewGraph()
 	resourceCatalog := map[string]func() resources.ResourceInterface{
@@ -149,6 +160,16 @@ func (d *Workflow) ExtractFromPlantUML(plantUML multipart.File, request *tools.A
 				},
 			}
 		},
+		"Service": func() resources.ResourceInterface {
+			return &resources.ServiceResource{
+				AbstractInstanciatedResource: resources.AbstractInstanciatedResource[*resources.ServiceInstance]{
+					Instances: []*resources.ServiceInstance{},
+				},
+			}
+		},
+		"Dynamic": func() resources.ResourceInterface {
+			return &resources.DynamicResource{}
+		},
 		// WorkflowEvent creates a NativeTool of Kind=WORKFLOW_EVENT directly,
 		// without DB lookup. It has no user-defined instance.
 		"WorkflowEvent": func() resources.ResourceInterface {
@@ -238,6 +259,8 @@ func (d *Workflow) ExtractFromPlantUML(plantUML multipart.File, request *tools.A
 	d.generateResource(d.GetResources(tools.STORAGE_RESOURCE), request)
 	d.generateResource(d.GetResources(tools.COMPUTE_RESOURCE), request)
 	d.generateResource(d.GetResources(tools.WORKFLOW_RESOURCE), request)
+	d.generateResource(d.GetResources(tools.SERVICE_RESOURCE), request)
+	d.generateResource(d.GetResources(tools.DYNAMIC_RESOURCE), request)
 	d.Graph.Items = graphVarName
 	return d, nil
 }
@@ -416,6 +439,14 @@ func (d *Workflow) getNewGraphItem(dataName string, resource resources.ResourceI
 		d.Processings = append(d.Processings, resource.GetID())
 		d.ProcessingResources = append(d.ProcessingResources, resource.(*resources.ProcessingResource))
 		graphItem.Processing = resource.(*resources.ProcessingResource)
+	case "Service":
+		d.Services = append(d.Services, resource.GetID())
+		d.ServiceResources = append(d.ServiceResources, resource.(*resources.ServiceResource))
+		graphItem.Service = resource.(*resources.ServiceResource)
+	case "Dynamic":
+		d.Dynamics = append(d.Dynamics, resource.GetID())
+		d.DynamicResources = append(d.DynamicResources, resource.(*resources.DynamicResource))
+		graphItem.Dynamic = resource.(*resources.DynamicResource)
 	case "WorkflowEvent":
 		// The resource is already a *NativeTool with Kind=WORKFLOW_EVENT set by the
 		// catalog factory. We use it directly without any DB lookup.
@@ -447,6 +478,8 @@ func (d *Workflow) getNewInstance(dataName string, name string, peerID string) r
 		return resources.NewStorageResourceInstance(name, peerID)
 	case "ComputeUnit":
 		return resources.NewComputeResourceInstance(name, peerID)
+	case "Service":
+		return resources.NewServiceInstance(name, peerID)
 	default:
 		return nil
 	}
@@ -820,6 +853,7 @@ func (w *Workflow) GetItemsByResources() map[tools.DataType]map[string][]string
 		tools.PROCESSING_RESOURCE: func() []graph.GraphItem { return w.GetGraphItems(w.Graph.IsProcessing) },
 		tools.SERVICE_RESOURCE:    func() []graph.GraphItem { return w.GetGraphItems(w.Graph.IsService) },
 		tools.WORKFLOW_RESOURCE:   func() []graph.GraphItem { return w.GetGraphItems(w.Graph.IsWorkflow) },
+		tools.DYNAMIC_RESOURCE:    func() []graph.GraphItem { return w.GetGraphItems(w.Graph.IsDynamic) },
 	}
 
 	for dt, meth := range dtMethodMap {

models/workflow_execution/workflow_execution.go

@@ -9,6 +9,7 @@ import (
 	"cloud.o-forge.io/core/oc-lib/models/booking"
 	"cloud.o-forge.io/core/oc-lib/models/common/enum"
 	"cloud.o-forge.io/core/oc-lib/models/common/pricing"
+	"cloud.o-forge.io/core/oc-lib/models/resources"
 	"cloud.o-forge.io/core/oc-lib/models/resources/purchase_resource"
 	"cloud.o-forge.io/core/oc-lib/models/utils"
 	"cloud.o-forge.io/core/oc-lib/models/workflow"
@@ -17,17 +18,6 @@ import (
 	"go.mongodb.org/mongo-driver/bson/primitive"
 )
 
-// EmbeddedStorageSelection records which storage capability was activated on a
-// compute unit graph node, and which pricing options were selected for it.
-// Key in WorkflowExecution.SelectedEmbeddedStorages is the compute graph node ID.
-// A nil/absent entry means no storage was activated on that compute unit.
-type EmbeddedStorageSelection struct {
-	StorageIndex     int `json:"storage_index" bson:"storage_index"`         // index in ComputeResourceInstance.AvailableStorages
-	PartnershipIndex int `json:"partnership_index" bson:"partnership_index"` // index in the storage's partnerships
-	BuyingIndex      int `json:"buying_index" bson:"buying_index"`
-	StrategyIndex    int `json:"strategy_index" bson:"strategy_index"`
-}
-
 // BookingState tracks the reservation and completion status of a single booking
 // within a workflow execution.
 //   - IsBooked: true while the resource is actively reserved (set on WORKFLOW_STARTED_EVENT,
@@ -71,7 +61,7 @@ type WorkflowExecution struct {
 	// SelectedEmbeddedStorages records which storage capability was activated on
 	// each compute unit graph node (key = compute graph node ID).
 	// Populated by oc-scheduler, consumed by oc-monitord's argo builder.
-	SelectedEmbeddedStorages map[string]*EmbeddedStorageSelection `json:"selected_embedded_storages,omitempty" bson:"selected_embedded_storages,omitempty"`
+	SelectedEmbeddedStorages map[string]*resources.EmbeddedStorageSelection `json:"selected_embedded_storages,omitempty" bson:"selected_embedded_storages,omitempty"`
 }
 
 func (ri *WorkflowExecution) Extend(typ ...string) map[string][]tools.DataType {
@@ -176,6 +166,7 @@ use of a datacenter or storage can't be buy for permanent access.
 func (d *WorkflowExecution) Buy(bs pricing.BillingStrategy, executionsID string, wfID string, priceds map[tools.DataType]map[string]pricing.PricedItemITF) []*purchase_resource.PurchaseResource {
 	purchases := d.buyEach(bs, executionsID, wfID, tools.PROCESSING_RESOURCE, priceds[tools.PROCESSING_RESOURCE])
 	purchases = append(purchases, d.buyEach(bs, executionsID, wfID, tools.DATA_RESOURCE, priceds[tools.DATA_RESOURCE])...)
+	purchases = append(purchases, d.buyEach(bs, executionsID, wfID, tools.SERVICE_RESOURCE, priceds[tools.SERVICE_RESOURCE])...)
 	d.PurchasesState = map[string]bool{}
 	for _, p := range purchases {
 		d.PurchasesState[p.GetID()] = false
@@ -205,7 +196,11 @@ func (d *WorkflowExecution) buyEach(bs pricing.BillingStrategy, executionsID str
 		var m map[string]interface{}
 		b, _ := json.Marshal(priced)
 		json.Unmarshal(b, &m)
-		end := start.Add(time.Duration(priced.GetExplicitDurationInS()) * time.Second)
+		var endDate *time.Time
+		if durS := priced.GetExplicitDurationInS(); durS > 0 {
+			e := start.Add(time.Duration(durS) * time.Second)
+			endDate = &e
+		}
 		bookingItem := &purchase_resource.PurchaseResource{
 			AbstractObject: utils.AbstractObject{
 				UUID:    uuid.New().String(),
@@ -219,7 +214,7 @@ func (d *WorkflowExecution) buyEach(bs pricing.BillingStrategy, executionsID str
 			ResourceID:   priced.GetID(),
 			InstanceID:   priced.GetInstanceID(),
 			ResourceType: dt,
-			EndDate:      &end,
+			EndDate:      endDate,
 		}
 		items = append(items, bookingItem)
 		d.PeerBuyByGraph[priced.GetCreatorID()][itemID] = append(
@@ -231,6 +226,7 @@ func (d *WorkflowExecution) buyEach(bs pricing.BillingStrategy, executionsID str
 func (d *WorkflowExecution) Book(executionsID string, wfID string, priceds map[tools.DataType]map[string]pricing.PricedItemITF) []*booking.Booking {
 	booking := d.bookEach(executionsID, wfID, tools.STORAGE_RESOURCE, priceds[tools.STORAGE_RESOURCE])
 	booking = append(booking, d.bookEach(executionsID, wfID, tools.PROCESSING_RESOURCE, priceds[tools.PROCESSING_RESOURCE])...)
+	booking = append(booking, d.bookEach(executionsID, wfID, tools.SERVICE_RESOURCE, priceds[tools.SERVICE_RESOURCE])...)
 	booking = append(booking, d.bookEach(executionsID, wfID, tools.COMPUTE_RESOURCE, priceds[tools.COMPUTE_RESOURCE])...)
 	booking = append(booking, d.bookEach(executionsID, wfID, tools.DATA_RESOURCE, priceds[tools.DATA_RESOURCE])...)
 	for _, p := range booking {

tools/enums.go

@@ -34,6 +34,8 @@ const (
 	EXECUTION_VERIFICATION
 	ALLOWED_IMAGE
 	SERVICE_RESOURCE
+	DYNAMIC_RESOURCE
+	LIVE_SERVICE
 )
 
 var NOAPI = func() string {
@@ -92,6 +94,8 @@ var InnerDefaultAPI = [...]func() string{
 	SCHEDULERAPI,
 	DATACENTERAPI,
 	CATALOGAPI,
+	CATALOGAPI,
+	DATACENTERAPI,
 }
 
 // Bind the standard data name to the data type
@@ -120,6 +124,8 @@ var Str = [...]string{
 	"execution_verification",
 	"allowed_image",
 	"service_resource",
+	"dynamic_resource",
+	"live_service",
 }
 
 func FromString(comp string) int {
@@ -155,7 +161,7 @@ func DataTypeList() []DataType {
 	return []DataType{DATA_RESOURCE, PROCESSING_RESOURCE, STORAGE_RESOURCE, COMPUTE_RESOURCE, WORKFLOW_RESOURCE,
 		WORKFLOW, WORKFLOW_EXECUTION, WORKSPACE, PEER, COLLABORATIVE_AREA, RULE, BOOKING, WORKFLOW_HISTORY, WORKSPACE_HISTORY,
 		ORDER, PURCHASE_RESOURCE,
-		LIVE_DATACENTER, LIVE_STORAGE, BILL, NATIVE_TOOL, EXECUTION_VERIFICATION, ALLOWED_IMAGE, SERVICE_RESOURCE}
+		LIVE_DATACENTER, LIVE_STORAGE, BILL, NATIVE_TOOL, EXECUTION_VERIFICATION, ALLOWED_IMAGE, SERVICE_RESOURCE, DYNAMIC_RESOURCE, LIVE_SERVICE}
 }
 
 type PropalgationMessage struct {