PR comments and reorg (9a36a3c4) · Commits · MEC - Multi-access Edge Computing / ETSI MEC Sandbox

go-apps/meep-sandbox-ctrl/server/sandbox-ctrl.go

+25 −160

Original line number	Diff line number	Diff line
		@@ -21,6 +21,7 @@ import (
		"errors"
		"fmt"
		"net/http"
		"net/url"
		"os"
		"sort"
		"strconv"
		@@ -416,19 +417,10 @@ func ceGetActiveScenario(w http.ResponseWriter, r *http.Request) {
		fmt.Fprint(w, string(scenario))
		}

		// Retrieves the active scenario domains
		// GET /active/domains
		func ceGetActiveScenarioDomain(w http.ResponseWriter, r *http.Request) {
		log.Debug("CEGetActiveScenarioDomain")

		if sbxCtrl.activeModel == nil \|\| !sbxCtrl.activeModel.Active {
		http.Error(w, "No scenario is active", http.StatusNotFound)
		return
		}
		func getNodeFilterFromQueryParams(query url.Values) mod.NodeFindFilter {

		//Retrieve query parameters and populate filter
		var filter mod.NodeFindFilter
		query := r.URL.Query()
		minimizeStr := query.Get("minimize")
		if minimizeStr == "true" {
		filter.Minimize = true
		@@ -452,22 +444,24 @@ func ceGetActiveScenarioDomain(w http.ResponseWriter, r *http.Request) {
		filter.ProcessName = query.Get("process")
		filter.ProcessType = query.Get("processType")

		log.Info("SIMON NEW")
		nodeList := sbxCtrl.activeModel.GetDomainNodesByFilter(&filter)
		var domains dataModel.Domains
		return filter
		}

		//var domains dataModel.Domains
		filteredList := new([]dataModel.Domain)
		for _, node := range nodeList {
		currentDomain := node.(*dataModel.Domain)
		// if children == "false" {
		// currentDomain.Zones = nil
		// }
		log.Info("SIMON domain active:", currentDomain.Name)
		filteredList = append(filteredList, *currentDomain)
		domains.Domains = append(domains.Domains, *currentDomain)
		// Retrieves the active scenario domains
		// GET /active/domains
		func ceGetActiveScenarioDomain(w http.ResponseWriter, r *http.Request) {
		log.Debug("CEGetActiveScenarioDomain")

		if sbxCtrl.activeModel == nil \|\| !sbxCtrl.activeModel.Active {
		http.Error(w, "No scenario is active", http.StatusNotFound)
		return
		}

		//Retrieve query parameters and populate filter
		filter := getNodeFilterFromQueryParams(r.URL.Query())

		domains := sbxCtrl.activeModel.GetDomainNodesByFilter(&filter)

		// Send response
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		if len(domains.Domains) == 0 {
		@@ -499,42 +493,9 @@ func ceGetActiveScenarioZone(w http.ResponseWriter, r *http.Request) {
		}

		//Retrieve query parameters and populate filter
		var filter mod.NodeFindFilter
		query := r.URL.Query()
		minimizeStr := query.Get("minimize")
		if minimizeStr == "true" {
		filter.Minimize = true
		} else {
		filter.Minimize = false
		}
		childrenStr := query.Get("children")
		if childrenStr == "true" {
		filter.Children = true
		} else {
		filter.Children = false
		}

		filter.DomainName = query.Get("domain")
		filter.DomainType = query.Get("domainType")
		filter.ZoneName = query.Get("zone")
		filter.NetworkLocationName = query.Get("networkLocation")
		filter.NetworkLocationType = query.Get("networkLocationType")
		filter.PhysicalLocationName = query.Get("physicalLocation")
		filter.PhysicalLocationType = query.Get("physicalLocationType")
		filter.ProcessName = query.Get("process")
		filter.ProcessType = query.Get("processType")
		filter := getNodeFilterFromQueryParams(r.URL.Query())

		log.Info("SIMON NEW")
		nodeList := sbxCtrl.activeModel.GetZoneNodesByFilter(&filter)
		var zones dataModel.Zones

		//var domains dataModel.Domains
		filteredList := new([]dataModel.Zone)
		for _, node := range nodeList {
		currentZone := node.(*dataModel.Zone)
		filteredList = append(filteredList, *currentZone)
		zones.Zones = append(zones.Zones, *currentZone)
		}
		zones := sbxCtrl.activeModel.GetZoneNodesByFilter(&filter)

		// Send response
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		@@ -565,42 +526,9 @@ func ceGetActiveScenarioNetworkLocation(w http.ResponseWriter, r *http.Request)
		}

		//Retrieve query parameters and populate filter
		var filter mod.NodeFindFilter
		query := r.URL.Query()
		minimizeStr := query.Get("minimize")
		if minimizeStr == "true" {
		filter.Minimize = true
		} else {
		filter.Minimize = false
		}
		childrenStr := query.Get("children")
		if childrenStr == "true" {
		filter.Children = true
		} else {
		filter.Children = false
		}

		filter.DomainName = query.Get("domain")
		filter.DomainType = query.Get("domainType")
		filter.ZoneName = query.Get("zone")
		filter.NetworkLocationName = query.Get("networkLocation")
		filter.NetworkLocationType = query.Get("networkLocationType")
		filter.PhysicalLocationName = query.Get("physicalLocation")
		filter.PhysicalLocationType = query.Get("physicalLocationType")
		filter.ProcessName = query.Get("process")
		filter.ProcessType = query.Get("processType")
		filter := getNodeFilterFromQueryParams(r.URL.Query())

		log.Info("SIMON NEW")
		nodeList := sbxCtrl.activeModel.GetNetworkLocationNodesByFilter(&filter)
		var networkLocations dataModel.NetworkLocations

		//var domains dataModel.Domains
		filteredList := new([]dataModel.NetworkLocation)
		for _, node := range nodeList {
		currentNetworkLocation := node.(*dataModel.NetworkLocation)
		filteredList = append(filteredList, *currentNetworkLocation)
		networkLocations.NetworkLocations = append(networkLocations.NetworkLocations, *currentNetworkLocation)
		}
		networkLocations := sbxCtrl.activeModel.GetNetworkLocationNodesByFilter(&filter)

		// Send response
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		@@ -631,41 +559,9 @@ func ceGetActiveScenarioPhysicalLocation(w http.ResponseWriter, r *http.Request)
		}

		//Retrieve query parameters and populate filter
		var filter mod.NodeFindFilter
		query := r.URL.Query()
		minimizeStr := query.Get("minimize")
		if minimizeStr == "true" {
		filter.Minimize = true
		} else {
		filter.Minimize = false
		}
		childrenStr := query.Get("children")
		if childrenStr == "true" {
		filter.Children = true
		} else {
		filter.Children = false
		}
		filter := getNodeFilterFromQueryParams(r.URL.Query())

		filter.DomainName = query.Get("domain")
		filter.DomainType = query.Get("domainType")
		filter.ZoneName = query.Get("zone")
		filter.NetworkLocationName = query.Get("networkLocation")
		filter.NetworkLocationType = query.Get("networkLocationType")
		filter.PhysicalLocationName = query.Get("physicalLocation")
		filter.PhysicalLocationType = query.Get("physicalLocationType")
		filter.ProcessName = query.Get("process")
		filter.ProcessType = query.Get("processType")

		nodeList := sbxCtrl.activeModel.GetPhysicalLocationNodesByFilter(&filter)
		var physicalLocations dataModel.PhysicalLocations

		//var domains dataModel.Domains
		filteredList := new([]dataModel.PhysicalLocation)
		for _, node := range nodeList {
		currentPhysicalLocation := node.(*dataModel.PhysicalLocation)
		filteredList = append(filteredList, *currentPhysicalLocation)
		physicalLocations.PhysicalLocations = append(physicalLocations.PhysicalLocations, *currentPhysicalLocation)
		}
		physicalLocations := sbxCtrl.activeModel.GetPhysicalLocationNodesByFilter(&filter)

		// Send response
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		@@ -696,40 +592,9 @@ func ceGetActiveScenarioProcess(w http.ResponseWriter, r *http.Request) {
		}

		//Retrieve query parameters and populate filter
		var filter mod.NodeFindFilter
		query := r.URL.Query()
		minimizeStr := query.Get("minimize")
		if minimizeStr == "true" {
		filter.Minimize = true
		} else {
		filter.Minimize = false
		}
		childrenStr := query.Get("children")
		if childrenStr == "true" {
		filter.Children = true
		} else {
		filter.Children = false
		}

		filter.DomainName = query.Get("domain")
		filter.DomainType = query.Get("domainType")
		filter.ZoneName = query.Get("zone")
		filter.NetworkLocationName = query.Get("networkLocation")
		filter.NetworkLocationType = query.Get("networkLocationType")
		filter.PhysicalLocationName = query.Get("physicalLocation")
		filter.PhysicalLocationType = query.Get("physicalLocationType")
		filter.ProcessName = query.Get("process")
		filter.ProcessType = query.Get("processType")
		filter := getNodeFilterFromQueryParams(r.URL.Query())

		nodeList := sbxCtrl.activeModel.GetProcessNodesByFilter(&filter)
		var processes dataModel.Processes

		filteredList := new([]dataModel.Process)
		for _, node := range nodeList {
		currentProcess := node.(*dataModel.Process)
		filteredList = append(filteredList, *currentProcess)
		processes.Processes = append(processes.Processes, *currentProcess)
		}
		processes := sbxCtrl.activeModel.GetProcessNodesByFilter(&filter)

		// Send response
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")

go-packages/meep-model/minimize.go

+88 −0

Original line number	Diff line number	Diff line
		@@ -60,3 +60,91 @@ func minimizeScenario(scenario *dataModel.Scenario) error {
		}
		return nil
		}

		// minimizeDomain - Minimizes domain
		func minimizeDomain(domain *dataModel.Domain) error {
		// Zones
		for iZone := range domain.Zones {
		zone := &domain.Zones[iZone]

		// Network Locations
		for iNL := range zone.NetworkLocations {
		nl := &zone.NetworkLocations[iNL]

		// Remove geodata
		nl.GeoData = nil

		// Physical Locations
		for iPL := range nl.PhysicalLocations {
		pl := &nl.PhysicalLocations[iPL]

		// Remove geodata
		pl.GeoData = nil

		// // Processes
		// for iProc := range pl.Processes {
		// proc := &pl.Processes[iProc]
		// }
		}
		}
		}
		return nil
		}

		// minimizeZone - Minimizes zone
		func minimizeZone(zone *dataModel.Zone) error {
		// Network Locations
		for iNL := range zone.NetworkLocations {
		nl := &zone.NetworkLocations[iNL]

		// Remove geodata
		nl.GeoData = nil

		// Physical Locations
		for iPL := range nl.PhysicalLocations {
		pl := &nl.PhysicalLocations[iPL]

		// Remove geodata
		pl.GeoData = nil

		// // Processes
		// for iProc := range pl.Processes {
		// proc := &pl.Processes[iProc]
		// }
		}
		}
		return nil
		}

		// minimizeNetLoc - Minimizes network location
		func minimizeNetLoc(nl *dataModel.NetworkLocation) error {
		// Remove geodata
		nl.GeoData = nil

		// Physical Locations
		for iPL := range nl.PhysicalLocations {
		pl := &nl.PhysicalLocations[iPL]

		// Remove geodata
		pl.GeoData = nil

		// // Processes
		// for iProc := range pl.Processes {
		// proc := &pl.Processes[iProc]
		// }
		}
		return nil
		}

		// minimizePlyLoc - Minimizes physical location
		func minimizePhyLoc(pl *dataModel.PhysicalLocation) error {
		// Remove geodata
		pl.GeoData = nil

		// // Processes
		// for iProc := range pl.Processes {
		// proc := &pl.Processes[iProc]
		// }
		return nil
		}

go-packages/meep-model/model.go

+406 −534

File changed.

Preview size limit exceeded, changes collapsed.

go-packages/meep-model/model_test.go

+88 −0

Original line number	Diff line number	Diff line
		@@ -124,6 +124,94 @@ func TestGetSetScenario(t *testing.T) {
		}
		}

		func TestGetSetActiveElements(t *testing.T) {
		fmt.Println("--- ", t.Name())
		log.MeepTextLogInit(t.Name())

		// Switch to a different table for testing
		redisTable = modelRedisTestTable

		cfg := ModelCfg{Name: modelName, Namespace: moduleNamespace, Module: "test-mod", DbAddr: modelRedisAddr}
		m, err := NewModel(cfg)
		if err != nil {
		t.Fatalf("Unable to create model")
		}

		fmt.Println("Set Model")
		err = m.SetScenario([]byte(testScenario))
		if err != nil {
		t.Fatalf("Error setting model")
		}
		if m.scenario.Name != "demo1" {
		t.Fatalf("SetScenario failed")
		}

		var filter, badFilter NodeFindFilter
		filter.ZoneName = "zone1"
		badFilter.ZoneName = "DO NOT EXIST"
		filter.ProcessType = "EDGE-APP"

		//success path
		fmt.Println("Get Domains")
		respDomain := m.GetDomainNodesByFilter(&filter)
		if len(respDomain.Domains) != 1 {
		t.Fatalf("Failed to get expected number of domains")
		}

		fmt.Println("Get Zones")
		respZone := m.GetZoneNodesByFilter(&filter)
		if len(respZone.Zones) != 1 {
		t.Fatalf("Failed to get expected number of zones")
		}

		fmt.Println("Get Network Locations")
		respNl := m.GetNetworkLocationNodesByFilter(&filter)
		if len(respNl.NetworkLocations) != 2 {
		t.Fatalf("Failed to get expected number of network locations")
		}

		fmt.Println("Get Physical Locations")
		respPl := m.GetPhysicalLocationNodesByFilter(&filter)
		if len(respPl.PhysicalLocations) != 2 {
		t.Fatalf("Failed to get expected number of physical locations")
		}
		fmt.Println("Get Processes")
		respProc := m.GetProcessNodesByFilter(&filter)
		if len(respProc.Processes) != 4 {
		t.Fatalf("Failed to get expected number of processes")
		}

		//failure path
		fmt.Println("Get Domains")
		respDomain = m.GetDomainNodesByFilter(&badFilter)
		if len(respDomain.Domains) != 0 {
		t.Fatalf("Failed to get expected number of domains")
		}

		fmt.Println("Get Zones")
		respZone = m.GetZoneNodesByFilter(&badFilter)
		if len(respZone.Zones) != 0 {
		t.Fatalf("Failed to get expected number of zones")
		}

		fmt.Println("Get Network Locations")
		respNl = m.GetNetworkLocationNodesByFilter(&badFilter)
		if len(respNl.NetworkLocations) != 0 {
		t.Fatalf("Failed to get expected number of network locations")
		}

		fmt.Println("Get Physical Locations")
		respPl = m.GetPhysicalLocationNodesByFilter(&badFilter)
		if len(respPl.PhysicalLocations) != 0 {
		t.Fatalf("Failed to get expected number of physical locations")
		}
		fmt.Println("Get Processes")
		respProc = m.GetProcessNodesByFilter(&badFilter)
		if len(respProc.Processes) != 0 {
		t.Fatalf("Failed to get expected number of processes")
		}
		}

		func TestActivateDeactivate(t *testing.T) {
		fmt.Println("--- ", t.Name())
		log.MeepTextLogInit(t.Name())

go-packages/meep-model/nodeContext.go

+13 −3

Original line number	Diff line number	Diff line
		@@ -21,14 +21,17 @@ const Domain = "Domain"
		const Zone = "Zone"
		const NetLoc = "NetLoc"
		const PhyLoc = "PhyLoc"
		const Proc = "Proc"

		// NodeContext
		type NodeContext struct {
		Parents map[string]string
		Children map[string][]string
		}

		// NewNodeContext - allocate an new NodeContext
		func NewNodeContext(deployment, domain, zone, netLoc, phyLoc string) (ctx *NodeContext) {
		// NewNodeContext - allocate a new NodeContext
		//parameters are for parents and children
		func NewNodeContext(deployment, domain, zone, netLoc, phyLoc string, domains []string, zones []string, netLocs []string, phyLocs []string, procs []string) (ctx *NodeContext) {
		ctx = new(NodeContext)
		ctx.Parents = make(map[string]string)
		ctx.Parents[Deployment] = deployment
		@@ -36,5 +39,12 @@ func NewNodeContext(deployment, domain, zone, netLoc, phyLoc string) (ctx *NodeC
		ctx.Parents[Zone] = zone
		ctx.Parents[NetLoc] = netLoc
		ctx.Parents[PhyLoc] = phyLoc
		ctx.Children = make(map[string][]string)
		ctx.Children[Domain] = domains
		ctx.Children[Zone] = zones
		ctx.Children[NetLoc] = netLocs
		ctx.Children[PhyLoc] = phyLocs
		ctx.Children[Proc] = procs

		return ctx
		}