Commit 59d4dc10 authored by Michel Roy's avatar Michel Roy Committed by Kevin Di Lallo
Browse files

meep-model package

parent 2d3afd0c

go-packages/meep-model/go.mod

0 → 100644
+20 −0
Original line number Diff line number Diff line 
module github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-model



go 1.12



require (

	github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-ctrl-engine-model v0.0.0

	github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-logger v0.0.0

	github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-redis v0.0.0

	github.com/flimzy/kivik v1.8.1

	github.com/go-kivik/couchdb v1.8.1

	github.com/gorilla/mux v1.7.3 // indirect

	github.com/imdario/mergo v0.3.7 // indirect

	github.com/pkg/errors v0.8.1 // indirect

)



replace github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-logger => ../../go-packages/meep-logger



replace github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-redis => ../../go-packages/meep-redis



replace github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-ctrl-engine-model => ../../go-packages/meep-ctrl-engine-model

go-packages/meep-model/go.sum

0 → 100644
+55 −0
Original line number Diff line number Diff line 
github.com/KromDaniel/jonson v0.0.0-20180630143114-d2f9c3c389db h1:Zkf5kwhxdW0xV7WM/crqIcOP5LCFGnAmumWSFAewJ74=

github.com/KromDaniel/jonson v0.0.0-20180630143114-d2f9c3c389db/go.mod h1:RU+6d0CNIRSp6yo1mXLIIrnFa/3LHhvcDVLVJyovptM=

github.com/KromDaniel/rejonson v0.0.0-20180822072824-00b5bcf2b351 h1:1u1XrfCBnY+GijnyU6O1k4odp5TnqZQTsp5v7+n/E4Y=

github.com/KromDaniel/rejonson v0.0.0-20180822072824-00b5bcf2b351/go.mod h1:HxwfbuElTuGf+/uKZfjJrCnv0BmmpkPJDI7gBwj1KkM=

github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=

github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=

github.com/flimzy/kivik v1.8.1 h1:URl7e0OnfSvAu3ZHQ5BkvzRZlCmyYuDyWUCcPWIHlU0=

github.com/flimzy/kivik v1.8.1/go.mod h1:S2aPycbG0eDFll4wgXt9uacSNkXISPufutnc9sv+mdA=

github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=

github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=

github.com/go-kivik/couchdb v1.8.1 h1:2yjmysS48JYpyWTkx2E3c7ASZP8Kh0eABWnkKlV8bbw=

github.com/go-kivik/couchdb v1.8.1/go.mod h1:5XJRkAMpBlEVA4q0ktIZjUPYBjoBmRoiWvwUBzP3BOQ=

github.com/go-redis/redis v6.15.2+incompatible h1:9SpNVG76gr6InJGxoZ6IuuxaCOQwDAhzyXg+Bs+0Sb4=

github.com/go-redis/redis v6.15.2+incompatible/go.mod h1:NAIEuMOZ/fxfXJIrKDQDz8wamY7mA7PouImQ2Jvg6kA=

github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=

github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=

github.com/gorilla/mux v1.7.3 h1:gnP5JzjVOuiZD07fKKToCAOjS0yOpj/qPETTXCCS6hw=

github.com/gorilla/mux v1.7.3/go.mod h1:1lud6UwP+6orDFRuTfBEV8e9/aOM/c4fVVCaMa2zaAs=

github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=

github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=

github.com/imdario/mergo v0.3.7 h1:Y+UAYTZ7gDEuOfhxKWy+dvb5dRQ6rJjFSdX2HZY1/gI=

github.com/imdario/mergo v0.3.7/go.mod h1:2EnlNZ0deacrJVfApfmtdGgDfMuh/nq6Ok1EcJh5FfA=

github.com/konsorten/go-windows-terminal-sequences v1.0.1 h1:mweAR1A6xJ3oS2pRaGiHgQ4OO8tzTaLawm8vnODuwDk=

github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=

github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=

github.com/onsi/ginkgo v1.10.1 h1:q/mM8GF/n0shIN8SaAZ0V+jnLPzen6WIVZdiwrRlMlo=

github.com/onsi/ginkgo v1.10.1/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=

github.com/onsi/gomega v1.7.0 h1:XPnZz8VVBHjVsy1vzJmRwIcSwiUO+JFfrv/xGiigmME=

github.com/onsi/gomega v1.7.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=

github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=

github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=

github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=

github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=

github.com/sirupsen/logrus v1.4.1 h1:GL2rEmy6nsikmW0r8opw9JIRScdMF5hA8cOYLH7In1k=

github.com/sirupsen/logrus v1.4.1/go.mod h1:ni0Sbl8bgC9z8RoU9G6nDWqqs/fq4eDPysMBDgk/93Q=

github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=

github.com/stretchr/testify v1.2.2 h1:bSDNvY7ZPG5RlJ8otE/7V6gMiyenm9RtJ7IUVIAoJ1w=

github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=

golang.org/x/net v0.0.0-20180906233101-161cd47e91fd h1:nTDtHvHSdCn1m6ITfMRqtOd/9+7a3s8RBNOZ3eYZzJA=

golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=

golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=

golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=

golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e h1:o3PsSEY8E4eXWkXrIP9YJALUkVZqzHJT5DOasTyn8Vs=

golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=

golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=

golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=

gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=

gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=

gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=

gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=

gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=

gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=

gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=

gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=

go-packages/meep-model/model.go

0 → 100644
+459 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2019  InterDigital Communications, Inc

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package model



import (

	"encoding/json"

	"errors"

	"strings"



	ceModel "github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-ctrl-engine-model"

	log "github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-logger"

	redis "github.com/InterDigitalInc/AdvantEDGE/go-packages/meep-redis"

)



const activeName = "active"



// Model - Implements a Meep Model

type Model struct {

	name          string

	module        string

	active        bool

	activeChannel string

	rc            *redis.Connector

	scenario      *ceModel.Scenario

	svcMap        []ceModel.NodeServiceMaps

	nodeMap       *NodeMap

}



// NewModel - Create a model object

func NewModel(dbAddr string, module string, name string) (m *Model, err error) {

	if name == "" {

		err = errors.New("Missing name")

		log.Error(err)

		return nil, err

	}

	if module == "" {

		err = errors.New("Missing module")

		log.Error(err)

		return nil, err

	}



	m = new(Model)

	m.name = name

	m.module = module

	m.active = false

	m.activeChannel = m.module + "-" + activeName

	m.scenario = new(ceModel.Scenario)

	m.nodeMap = NewNodeMap()

	m.parseNodes()

	m.updateSvcMap()



	// Connect to Redis DB

	m.rc, err = redis.NewConnector(dbAddr, 0)

	if err != nil {

		log.Error("Model ", m.name, " failed connection to Redis:")

		log.Error(err)

		return nil, err

	}

	log.Debug("Model created ", m.name)

	return m, nil

}



// SetModel - Initialize model from JSON string

func (m *Model) SetModel(j []byte) (err error) {

	err = json.Unmarshal(j, m.scenario)

	if err != nil {

		log.Error(err.Error())

		return err

	}

	m.parseNodes()

	m.updateSvcMap()

	return nil

}



// GetModel - Get model pointer

func (m *Model) GetModel() *ceModel.Scenario {

	return m.scenario

}



func (m *Model) parseNodes() (err error) {

	if m.scenario.Deployment != nil {

		if m.scenario.Deployment != nil {

			// Parse through scenario and fill external node service mappings

			for iDomain := range m.scenario.Deployment.Domains {

				domain := &m.scenario.Deployment.Domains[iDomain]

				m.nodeMap.AddNode(NewNode(domain.Name, domain.Type_, domain, &domain.Zones, m.scenario.Deployment))

				for iZone := range domain.Zones {

					zone := &domain.Zones[iZone]

					m.nodeMap.AddNode(NewNode(zone.Name, zone.Type_, zone, &zone.NetworkLocations, domain))

					for iNL := range zone.NetworkLocations {

						nl := &zone.NetworkLocations[iNL]

						m.nodeMap.AddNode(NewNode(nl.Name, nl.Type_, nl, &nl.PhysicalLocations, zone))

						for iPL := range nl.PhysicalLocations {

							pl := &nl.PhysicalLocations[iPL]

							m.nodeMap.AddNode(NewNode(pl.Name, pl.Type_, pl, &pl.Processes, nl))

							for iProc := range pl.Processes {

								proc := &pl.Processes[iProc]

								m.nodeMap.AddNode(NewNode(proc.Name, proc.Type_, proc, nil, pl))

							}

						}

					}

				}

			}

		}

	}

	return nil

}



func (m *Model) updateSvcMap() (err error) {

	if m.scenario.Deployment == nil {

		m.svcMap = nil

	} else {

		// Parse through scenario and fill external node service mappings

		for _, domain := range m.scenario.Deployment.Domains {

			for _, zone := range domain.Zones {

				for _, nl := range zone.NetworkLocations {

					for _, pl := range nl.PhysicalLocations {

						for _, proc := range pl.Processes {

							if proc.IsExternal {

								// Create new node service map

								var nodeServiceMaps ceModel.NodeServiceMaps

								nodeServiceMaps.Node = proc.Name

								nodeServiceMaps.IngressServiceMap = append(nodeServiceMaps.IngressServiceMap,

									proc.ExternalConfig.IngressServiceMap...)

								nodeServiceMaps.EgressServiceMap = append(nodeServiceMaps.EgressServiceMap,

									proc.ExternalConfig.EgressServiceMap...)



								// Add new map to list

								m.svcMap = append(m.svcMap, nodeServiceMaps)

							}

						}

					}

				}

			}

		}

	}

	return nil

}



// GetServiceMaps - Extracts the model service maps

func (m *Model) GetServiceMaps() []ceModel.NodeServiceMaps {

	return m.svcMap

}



// Activate - Make scenario the active scenario

func (m *Model) Activate() (err error) {

	jsonScenario, err := json.Marshal(m.scenario)

	if err != nil {

		log.Error(err.Error())

		return err

	}

	err = m.rc.JSONSetEntry(m.module+":"+m.name, ".", string(jsonScenario))

	if err != nil {

		log.Error(err.Error())

		return err

	}

	err = m.rc.Publish(m.activeChannel, "")

	if err != nil {

		log.Error(err.Error())

		return err

	}

	m.active = true

	return nil

}



// Deactivate - Remove the active scenario

func (m *Model) Deactivate() (err error) {

	if m.active == true {

		err = m.rc.JSONDelEntry(m.module+":"+m.name, ".")

		if err != nil {

			log.Error(err.Error())

			return err

		}

		err = m.rc.Publish(m.activeChannel, "")

		if err != nil {

			log.Error(err.Error())

			return err

		}

	}

	m.active = false

	return nil

}



// Update - Update existing model with the new version

func (m *Model) Update(j []byte) (err error) {

	err = m.SetModel(j)

	if err != nil {

		log.Error(err.Error())

		return err

	}

	err = m.refresh()

	if err != nil {

		return err

	}

	return nil

}



func (m *Model) refresh() (err error) {

	if m.active == true {

		err = m.rc.JSONDelEntry(m.module+":"+m.name, ".")

		if err != nil {

			log.Error(err.Error())

			return err

		}

	}

	jsonScenario, err := json.Marshal(m.scenario)

	if err != nil {

		log.Error(err.Error())

		return err

	}

	err = m.rc.JSONSetEntry(m.module+":"+m.name, ".", string(jsonScenario))

	if err != nil {

		log.Error(err.Error())

		return err

	}

	err = m.rc.Publish(m.activeChannel, "")

	if err != nil {

		log.Error(err.Error())

		return err

	}

	return nil

}



func (m *Model) movePL(node *Node, destName string) (oldLocName string, newLocName string, err error) {

	var pl *ceModel.PhysicalLocation

	var oldNL *ceModel.NetworkLocation

	var newNL *ceModel.NetworkLocation



	// Node is a UE

	pl = node.object.(*ceModel.PhysicalLocation)

	// fmt.Printf("+++ pl: %+v\n", pl)



	oldNL = node.parent.(*ceModel.NetworkLocation)

	// fmt.Printf("+++ oldNL: %+v\n", oldNL)

	if oldNL == nil {

		return "", "", errors.New("MoveNode: " + node.name + " old location not found)")

	}



	newNLNode := m.nodeMap.FindByName(destName)

	// fmt.Printf("+++ newNLNode: %+v\n", newNLNode)

	if newNLNode == nil {

		return "", "", errors.New("MoveNode: " + destName + " not found")

	}

	newNL = newNLNode.object.(*ceModel.NetworkLocation)

	// fmt.Printf("+++ newNL: %+v\n", newNL)



	// Update location if necessary

	if pl != nil && oldNL != nil && newNL != nil && oldNL != newNL {

		log.Debug("Found PL & destination. Updating PL location.")



		// Add PL to new location

		newNL.PhysicalLocations = append(newNL.PhysicalLocations, *pl)

		node.parent = newNL



		var idx int

		for i, x := range oldNL.PhysicalLocations {

			if x.Type_ == "UE" && x.Name == node.name {

				idx = i

				break

			}

		}

		// Remove UE from old location

		//overwrite

		oldNL.PhysicalLocations[idx] = oldNL.PhysicalLocations[len(oldNL.PhysicalLocations)-1]

		//truncate

		oldNL.PhysicalLocations = oldNL.PhysicalLocations[:len(oldNL.PhysicalLocations)-1]

	}



	return oldNL.Name, newNL.Name, nil

}



func (m *Model) moveProc(node *Node, destName string) (oldLocName string, newLocName string, err error) {

	var proc *ceModel.Process

	var oldPL *ceModel.PhysicalLocation

	var newPL *ceModel.PhysicalLocation



	// Node is a process

	proc = node.object.(*ceModel.Process)

	// fmt.Printf("+++ process: %+v\n", proc)

	//process part of a mobility group can't be moved

	if proc.ServiceConfig != nil {

		if proc.ServiceConfig.MeSvcName != "" {

			return "", "", errors.New("Process part of a mobility group cannot be moved ")

		}

	}



	oldPL = node.parent.(*ceModel.PhysicalLocation)

	// fmt.Printf("+++ oldPL: %+v\n", oldPL)

	if oldPL == nil {

		return "", "", errors.New("MoveNode: " + node.name + " old location not found)")

	}



	newPLNode := m.nodeMap.FindByName(destName)

	// fmt.Printf("+++ newPLNode: %+v\n", newPLNode)

	if newPLNode == nil {

		return "", "", errors.New("MoveNode: " + destName + " not found")

	}

	newPL = newPLNode.object.(*ceModel.PhysicalLocation)

	// fmt.Printf("+++ newNL: %+v\n", newNL)



	// Update location if necessary

	if proc != nil && oldPL != nil && newPL != nil && oldPL != newPL {

		log.Debug("Found Process & destination. Updating PL location.")



		// Add PL to new location

		newPL.Processes = append(newPL.Processes, *proc)

		node.parent = newPL



		var idx int

		for i, x := range oldPL.Processes {

			if x.Name == node.name {

				idx = i

				break

			}

		}

		// Remove UE from old location

		//overwrite

		oldPL.Processes[idx] = oldPL.Processes[len(oldPL.Processes)-1]

		//truncate

		oldPL.Processes = oldPL.Processes[:len(oldPL.Processes)-1]

	}



	return oldPL.Name, newPL.Name, nil

}



// MoveNode - Move a specific UE in the scenario

func (m *Model) MoveNode(nodeName string, destName string) (oldLocName string, newLocName string, err error) {

	moveNode := m.nodeMap.FindByName(nodeName)

	// fmt.Printf("+++ ueNode: %+v\n", ueNode)

	if moveNode == nil {

		return "", "", errors.New("Mobility: " + nodeName + " not found")

	}



	if moveNode.nodeType == "EDGE-APP" {

		oldLocName, newLocName, err = m.moveProc(moveNode, destName)

		if err != nil {

			return "", "", err

		}

	} else {

		oldLocName, newLocName, err = m.movePL(moveNode, destName)

		if err != nil {

			return "", "", err

		}

	}



	err = m.refresh()

	if err != nil {

		return "", "", err

	}

	return oldLocName, newLocName, nil

}



//FindUE - return a UE

func (m *Model) FindUE(name string) (ue *ceModel.PhysicalLocation, err error) {

	ueNode := m.nodeMap.FindByName(name)

	// fmt.Printf("+++ ueNode: %+v\n", ueNode)

	if ueNode == nil {

		return nil, errors.New("Did not find ue " + name + " in scenario " + m.name)

	}

	ue = ueNode.object.(*ceModel.PhysicalLocation)

	return ue, nil



}



//UpdateNetChar - Update network characteristics for a node

func (m *Model) UpdateNetChar(nc *ceModel.EventNetworkCharacteristicsUpdate) (err error) {

	updated := false



	ncName := nc.ElementName

	ncType := strings.ToUpper(nc.ElementType)



	// Find the element

	if ncType == "SCENARIO" {

		m.scenario.Deployment.InterDomainLatency = nc.Latency

		m.scenario.Deployment.InterDomainLatencyVariation = nc.LatencyVariation

		m.scenario.Deployment.InterDomainThroughput = nc.Throughput

		m.scenario.Deployment.InterDomainPacketLoss = nc.PacketLoss

		updated = true

	} else {

		n := m.nodeMap.FindByName(ncName)

		// fmt.Printf("+++ node: %+v\n", n)

		if n == nil {

			return errors.New("Did not find " + ncName + " in scenario " + m.name)

		}

		if ncType == "OPERATOR" {

			domain := n.object.(*ceModel.Domain)

			domain.InterZoneLatency = nc.Latency

			domain.InterZoneLatencyVariation = nc.LatencyVariation

			domain.InterZoneThroughput = nc.Throughput

			domain.InterZonePacketLoss = nc.PacketLoss

			updated = true

		} else if ncType == "ZONE-INTER-EDGE" {

			zone := n.object.(*ceModel.Zone)

			zone.InterEdgeLatency = nc.Latency

			zone.InterEdgeLatencyVariation = nc.LatencyVariation

			zone.InterEdgeThroughput = nc.Throughput

			zone.InterEdgePacketLoss = nc.PacketLoss

			updated = true

		} else if ncType == "ZONE-INTER-FOG" {

			zone := n.object.(*ceModel.Zone)

			zone.InterFogLatency = nc.Latency

			zone.InterFogLatencyVariation = nc.LatencyVariation

			zone.InterFogThroughput = nc.Throughput

			zone.InterFogPacketLoss = nc.PacketLoss

			updated = true

		} else if ncType == "ZONE-EDGE-FOG" {

			zone := n.object.(*ceModel.Zone)

			zone.EdgeFogLatency = nc.Latency

			zone.EdgeFogLatencyVariation = nc.LatencyVariation

			zone.EdgeFogThroughput = nc.Throughput

			zone.EdgeFogPacketLoss = nc.PacketLoss

			updated = true

		} else if ncType == "POA" {

			nl := n.object.(*ceModel.NetworkLocation)

			nl.TerminalLinkLatency = nc.Latency

			nl.TerminalLinkLatencyVariation = nc.LatencyVariation

			nl.TerminalLinkThroughput = nc.Throughput

			nl.TerminalLinkPacketLoss = nc.PacketLoss

			updated = true

		} else if ncType == "DISTANT CLOUD" || ncType == "EDGE" || ncType == "FOG" || ncType == "UE" {

			pl := n.object.(*ceModel.PhysicalLocation)

			pl.LinkLatency = nc.Latency

			pl.LinkLatencyVariation = nc.LatencyVariation

			pl.LinkThroughput = nc.Throughput

			pl.LinkPacketLoss = nc.PacketLoss

			updated = true

		} else if ncType == "CLOUD APPLICATION" || ncType == "EDGE APPLICATION" || ncType == "UE APPLICATION" {

			proc := n.object.(*ceModel.Process)

			proc.AppLatency = nc.Latency

			proc.AppLatencyVariation = nc.LatencyVariation

			proc.AppThroughput = nc.Throughput

			proc.AppPacketLoss = nc.PacketLoss

			updated = true

		}



	}

	if updated {

		err = m.refresh()

		if err != nil {

			return err

		}

	}

	return nil



}

go-packages/meep-model/model_test.go

0 → 100644
+614 −0

File added.

Preview size limit exceeded, changes collapsed.

go-packages/meep-model/nodeMap.go

0 → 100644
+70 −0
Original line number Diff line number Diff line 
/*

 * Copyright (c) 2019  InterDigital Communications, Inc

 *

 * Licensed under the Apache License, Version 2.0 (the "License");

 * you may not use this file except in compliance with the License.

 * You may obtain a copy of the License at

 *

 *     http://www.apache.org/licenses/LICENSE-2.0

 *

 * Unless required by applicable law or agreed to in writing, software

 * distributed under the License is distributed on an "AS IS" BASIS,

 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.

 * See the License for the specific language governing permissions and

 * limitations under the License.

 */



package model



// Node - model node

type Node struct {

	name     string

	nodeType string

	object   interface{}

	child    interface{}

	parent   interface{}

}



// NodeMap - Model node map

type NodeMap struct {

	nameMap map[string]*Node

	typeMap map[string]map[string]*Node

}



// NewNodeMap - allocate a blank NodeMap

func NewNodeMap() (nm *NodeMap) {

	nm = new(NodeMap)

	nm.nameMap = make(map[string]*Node)

	nm.typeMap = make(map[string]map[string]*Node)

	return nm

}



// NewNode - allocate a Node

func NewNode(name string, nodeType string, object interface{}, child interface{}, parent interface{}) (n *Node) {

	n = new(Node)

	n.name = name

	n.nodeType = nodeType

	n.object = object

	n.child = child

	n.parent = parent

	return n

}



// AddNode - Add a node to the NodeMap

func (nm *NodeMap) AddNode(n *Node) {

	nm.nameMap[n.name] = n

	if nm.typeMap[n.nodeType] == nil {

		nm.typeMap[n.nodeType] = make(map[string]*Node)

	}

	nm.typeMap[n.nodeType][n.name] = n

}



// FindByName - find a node using its name

func (nm *NodeMap) FindByName(name string) (n *Node) {

	return nm.nameMap[name]

}



// FindByType - find a node using its type - NOT SURE WE NEED THIS

func (nm *NodeMap) FindByType(name string, nodeType string) (n *Node) {

	return nm.typeMap[nodeType][name]

}