simapp.go

// SPDX-FileCopyrightText: 2021 Open Networking Foundation <info@opennetworking.org>
//
// SPDX-License-Identifier: Apache-2.0
//

package main

import (
	"bytes"
	"context"
	"crypto/sha1"
	"encoding/hex"
	"encoding/json"
	"errors"
	"fmt"
	"io"
	"net/http"
	"os"
	"os/signal"
	"path/filepath"
	"reflect"
	"slices"
	"strconv"
	"strings"
	"sync"
	"syscall"
	"time"

	"github.com/fsnotify/fsnotify"
	"github.com/omec-project/simapp/logger"
	"github.com/spf13/viper"
	"github.com/urfave/cli/v3"
	"go.uber.org/zap"
	"go.uber.org/zap/zapcore"
	"go.yaml.in/yaml/v4"
)

type Config struct {
	Info          *Info          `yaml:"info"`
	Configuration *Configuration `yaml:"configuration"`
	Logger        *Logger        `yaml:"logger"`
}

type Logger struct {
	APP *LogSetting `yaml:"APP" valid:"optional"`
}

type LogSetting struct {
	DebugLevel string `yaml:"debugLevel" valid:"debugLevel"`
}

type Info struct {
	Version     string `yaml:"version,omitempty"`
	Description string `yaml:"description,omitempty"`
	HttpVersion int    `yaml:"http-version,omitempty"`
}

type Configuration struct {
	SubProvisionEndpt *SubProvisionEndpt `yaml:"sub-provision-endpt,omitempty"`
	DevGroup          []*DevGroup        `yaml:"device-groups,omitempty"`
	NetworkSlice      []*NetworkSlice    `yaml:"network-slices,omitempty"`
	Subscriber        []*Subscriber      `yaml:"subscribers,omitempty"`
	MaxWorkers        int                `yaml:"max-workers,omitempty"`
}

type DevGroup struct {
	Name         string     `yaml:"name,omitempty"`
	SiteInfo     string     `yaml:"site-info,omitempty" json:"site-info,omitempty"`
	Imsis        []string   `yaml:"imsis,omitempty" json:"imsis,omitempty"`
	ImsiStart    string     `yaml:"imsi-start,omitempty" json:"imsi-start,omitempty"`
	ImsiEnd      string     `yaml:"imsi-end,omitempty" json:"imsi-end,omitempty"`
	Msisdns      []string   `yaml:"msisdns,omitempty" json:"msisdns,omitempty"`
	MsisdnStart  string     `yaml:"msisdn-start,omitempty" json:"msisdn-start,omitempty"`
	MsisdnEnd    string     `yaml:"msisdn-end,omitempty" json:"msisdn-end,omitempty"`
	IpDomainName string     `yaml:"ip-domain-name,omitempty" json:"ip-domain-name,omitempty"`
	IpDomains    []IpDomain `yaml:"ip-domains,omitempty" json:"ip-domains,omitempty"`
	visited      bool
}

type IpDomain struct {
	UeDnnQos     *UeDnnQosInfo `yaml:"ue-dnn-qos,omitempty" json:"ue-dnn-qos,omitempty"`
	Dnn          string        `yaml:"dnn,omitempty" json:"dnn,omitempty"`
	DnsPrimary   string        `yaml:"dns-primary,omitempty" json:"dns-primary,omitempty"`
	PcscfPrimary string        `yaml:"pcscf-primary,omitempty" json:"pcscf-primary,omitempty"`
	DnsSecondary string        `yaml:"dns-secondary,omitempty" json:"dns-secondary,omitempty"`
	UePool       string        `yaml:"ue-ip-pool,omitempty" json:"ue-ip-pool,omitempty"`
	Mtu          int           `yaml:"mtu,omitempty" json:"mtu,omitempty"`
}

type Subscriber struct {
	UeId           string
	UeIdStart      string `yaml:"ueId-start,omitempty" json:"-"`
	UeIdEnd        string `yaml:"ueId-end,omitempty" json:"-"`
	PlmnId         string `yaml:"plmnId,omitempty" json:"plmnId,omitempty"`
	OPc            string `yaml:"opc,omitempty" json:"opc,omitempty"`
	OP             string `yaml:"op,omitempty" json:"op,omitempty"`
	Key            string `yaml:"key,omitempty" json:"key,omitempty"`
	SequenceNumber string `yaml:"sequenceNumber,omitempty" json:"sequenceNumber,omitempty"`
}

type SubProvisionEndpt struct {
	Addr string `yaml:"addr,omitempty" json:"addr,omitempty"`
	Port string `yaml:"port,omitempty" json:"port,omitempty"`
}

type NetworkSlice struct {
	Name                      string                       `yaml:"name,omitempty" json:"name,omitempty"`
	SliceId                   *SliceId                     `yaml:"slice-id,omitempty" json:"slice-id,omitempty"`
	DevGroups                 []string                     `yaml:"site-device-group,omitempty" json:"site-device-group,omitempty"`
	SiteInfo                  *SiteInfo                    `yaml:"site-info,omitempty" json:"site-info,omitempty"`
	ApplicationFilteringRules []*ApplicationFilteringRules `yaml:"application-filtering-rules,omitempty" json:"application-filtering-rules,omitempty"`
	visited                   bool
	modified                  bool
}

type SliceId struct {
	Sst string `yaml:"sst,omitempty" json:"sst,omitempty"`
	Sd  string `yaml:"sd,omitempty" json:"sd,omitempty"`
}

type UeDnnQosInfo struct {
	TrafficClass *TrafficClassInfo `yaml:"traffic-class,omitempty" json:"traffic-class,omitempty"`
	BitRateUnit  string            `yaml:"bitrate-unit,omitempty" json:"bitrate-unit,omitempty"`
	Uplink       int               `yaml:"dnn-mbr-uplink,omitempty" json:"dnn-mbr-uplink,omitempty"`
	Downlink     int               `yaml:"dnn-mbr-downlink,omitempty" json:"dnn-mbr-downlink,omitempty"`
}

type TrafficClassInfo struct {
	Name string `yaml:"name,omitempty" json:"name,omitempty"`
	Qci  int    `yaml:"qci,omitempty" json:"qci,omitempty"`
	Arp  int    `yaml:"arp,omitempty" json:"arp,omitempty"`
	Pdb  int    `yaml:"pdb,omitempty" json:"pdb,omitempty"`
	Pelr int    `yaml:"pelr,omitempty" json:"pelr,omitempty"`
}

type SiteInfo struct {
	Plmn     *Plmn  `yaml:"plmn,omitempty"   json:"plmn,omitempty"`
	Upf      *Upf   `yaml:"upf,omitempty" json:"upf,omitempty"`
	SiteName string `yaml:"site-name,omitempty" json:"site-name,omitempty"`
	Gnb      []*Gnb `yaml:"gNodeBs,omitempty" json:"gNodeBs,omitempty"`
}

type Gnb struct {
	Name string `yaml:"name,omitempty" json:"name,omitempty"`
	Tac  int    `yaml:"tac,omitempty" json:"tac,omitempty"`
}

type Plmn struct {
	Mcc string `yaml:"mcc,omitempty" json:"mcc,omitempty"`
	Mnc string `yaml:"mnc,omitempty" json:"mnc,omitempty"`
}

type Upf struct {
	UpfName string `yaml:"upf-name,omitempty" json:"upf-name,omitempty"`
	UpfPort int    `yaml:"upf-port,omitempty" json:"upf-port,omitempty"`
}

type ApplicationFilteringRules struct {
	TrafficClass   *TrafficClassInfo `yaml:"traffic-class,omitempty" json:"traffic-class,omitempty"`
	RuleName       string            `yaml:"rule-name,omitempty" json:"rule-name,omitempty"`
	Action         string            `yaml:"action,omitempty" json:"action,omitempty"`
	Endpoint       string            `yaml:"endpoint,omitempty" json:"endpoint,omitempty"`
	BitRateUnit    string            `yaml:"bitrate-unit,omitempty" json:"bitrate-unit,omitempty"`
	RuleTrigger    string            `yaml:"rule-trigger,omitempty" json:"rule-trigger,omitempty"`
	Priority       int32             `yaml:"priority,omitempty" json:"priority,omitempty"`
	Protocol       int32             `yaml:"protocol,omitempty" json:"protocol,omitempty"`
	StartPort      int32             `yaml:"dest-port-start,omitempty" json:"dest-port-start,omitempty"`
	EndPort        int32             `yaml:"dest-port-end,omitempty" json:"dest-port-end,omitempty"`
	AppMbrUplink   int32             `yaml:"app-mbr-uplink,omitempty" json:"app-mbr-uplink,omitempty"`
	AppMbrDownlink int32             `yaml:"app-mbr-downlink,omitempty" json:"app-mbr-downlink,omitempty"`
}

const (
	add_op = iota
	modify_op
	delete_op
)

const (
	device_group = iota
	network_slice
	subscriber
)

const httpProtocol = "http://"

type configMessage struct {
	msgPtr  *bytes.Buffer
	wg      *sync.WaitGroup
	name    string
	msgType int
	msgOp   int
}

func (msg configMessage) String() string {
	var msgType, msgOp string
	switch msg.msgOp {
	case add_op:
		msgOp = "add_op"
	case modify_op:
		msgOp = "modify_op"
	case delete_op:
		msgOp = "delete_op"
	}

	switch msg.msgType {
	case device_group:
		msgType = "device-group"
	case network_slice:
		msgType = "network-slice"
	case subscriber:
		msgType = "subscriber"
	}
	return fmt.Sprintf("config msg name [%v], type [%v], op [%v]", msg.name, msgType, msgOp)
}

var (
	SimappConfig  Config
	configMsgChan chan configMessage
	client        *http.Client
)

func InitConfigFactory(f string, subProvisionEndpt *SubProvisionEndpt) error {
	logger.SimappLog.Infoln("function called", f)
	if content, err := os.ReadFile(f); err != nil {
		logger.SimappLog.Infoln("readfile failed called", err)
		return err
	} else {
		SimappConfig = Config{}

		if yamlErr := yaml.Unmarshal(content, &SimappConfig); yamlErr != nil {
			logger.SimappLog.Errorln("yaml parsing failed", yamlErr)
			return yamlErr
		}
	}

	if SimappConfig.Logger.APP != nil {
		if SimappConfig.Logger.APP.DebugLevel != "" {
			if level, err := zapcore.ParseLevel(SimappConfig.Logger.APP.DebugLevel); err != nil {
				logger.SimappLog.Warnf("Simapp log level [%s] is invalid, set to [info] level",
					SimappConfig.Logger.APP.DebugLevel)
				logger.SetLogLevel(zap.InfoLevel)
			} else {
				logger.SetLogLevel(level)
			}
		} else {
			logger.SimappLog.Warnln("Simapp log level not set. Default set to [info] level")
			logger.SetLogLevel(zap.InfoLevel)
		}
	}

	if SimappConfig.Configuration == nil {
		logger.SimappLog.Infoln("configuration parsing failed", SimappConfig.Configuration)
		return nil
	}

	// set http client
	httpVersion := 1
	if SimappConfig.Info != nil {
		httpVersion = SimappConfig.Info.HttpVersion
	}
	if httpVersion == 2 {
		transport := &http.Transport{
			MaxIdleConns:        100,
			MaxIdleConnsPerHost: 100,
			MaxConnsPerHost:     0,
			IdleConnTimeout:     90 * time.Second,
			DisableKeepAlives:   false,
		}
		// h2c requires HTTP1 to stay unset; setting it would make the transport fall back to HTTP/1.1
		transport.Protocols = new(http.Protocols)
		transport.Protocols.SetUnencryptedHTTP2(true)
		client = &http.Client{
			Transport: transport,
			Timeout:   30 * time.Second,
		}
	} else {
		transport := &http.Transport{
			MaxIdleConns:        100,
			MaxIdleConnsPerHost: 100,
			MaxConnsPerHost:     0,
			IdleConnTimeout:     90 * time.Second,
			DisableKeepAlives:   false,
		}
		client = &http.Client{
			Transport: transport,
			Timeout:   30 * time.Second,
		}
	}

	logger.SimappLog.Infof("subscriber provision endpoint: %s:%s", SimappConfig.Configuration.SubProvisionEndpt.Addr, SimappConfig.Configuration.SubProvisionEndpt.Port)
	subProvisionEndpt.Addr = SimappConfig.Configuration.SubProvisionEndpt.Addr
	subProvisionEndpt.Port = SimappConfig.Configuration.SubProvisionEndpt.Port

	viper.SetConfigFile(f)
	viper.SetConfigType("yaml")
	err := viper.ReadInConfig() // Find and read the config file
	if err != nil {             // Handle errors reading the config file
		return err
	}
	return nil
}

func syncConfig(w http.ResponseWriter, req *http.Request) {
	_, err := fmt.Fprintf(w, "OK\n")
	if err != nil {
		logger.SimappLog.Errorln(err)
	}
	dispatchAllGroups(configMsgChan, nil)
	dispatchAllNetworkSlices(configMsgChan, nil)
}

func main() {
	app := &cli.Command{}
	app.Name = "simapp"
	logger.SimappLog.Infoln(app.Name)
	app.Usage = "SIMApp"
	app.UsageText = "simapp -cfg <simapp_config_file.yaml>"
	app.Flags = []cli.Flag{
		&cli.StringFlag{
			Name:     "cfg",
			Usage:    "simapp config file",
			Required: true,
		},
	}
	app.Action = action
	if err := app.Run(context.Background(), os.Args); err != nil {
		logger.SimappLog.Fatalf("SIMApp run error: %v", err)
	}
}

func action(ctx context.Context, c *cli.Command) error {
	logger.SimappLog.Infoln("SIMApp started")
	configMsgChan = make(chan configMessage, 100)
	var subProvisionEndpt SubProvisionEndpt

	cfg := c.String("cfg")
	absPath, err := filepath.Abs(cfg)
	if err != nil {
		logger.SimappLog.Errorln(err)
		return err
	}

	err = InitConfigFactory(absPath, &subProvisionEndpt)
	if err != nil {
		logger.SimappLog.Errorln(err)
	}

	// The /synchronize server, created up front so that a SIGTERM in any phase
	// can shut it down.
	syncServer := &http.Server{Addr: ":8080", ReadHeaderTimeout: 10 * time.Second}
	handleTermination(syncServer)

	go sendMessage(configMsgChan, subProvisionEndpt)
	go WatchConfig()

	// Wait for webui to be ready before dispatching any messages.
	waitForWebui(subProvisionEndpt)

	// Provisioning must follow a strict order because the webconsole's sync logic
	// (triggered on device-group/network-slice creation) checks whether subscriber
	// auth data already exists in the DB. If subscribers aren't committed yet,
	// policy data is never written and UEs get REGISTRATION-REJECT.
	//
	// Phase 1: Subscribers (auth data must exist first)
	// Phase 2: Device groups (reference subscriber IMSIs)
	// Phase 3: Network slices (reference device groups; creation triggers final sync)

	// Phase 1: Subscribers
	var subscriberWg sync.WaitGroup
	dispatchAllSubscribers(configMsgChan, &subscriberWg)
	subscriberWg.Wait()
	logger.SimappLog.Infoln("phase 1 complete: subscribers provisioned")

	// Phase 2: Device groups
	var groupWg sync.WaitGroup
	dispatchAllGroups(configMsgChan, &groupWg)
	groupWg.Wait()
	logger.SimappLog.Infoln("phase 2 complete: device groups provisioned")

	// Phase 3: Network slices
	var sliceWg sync.WaitGroup
	dispatchAllNetworkSlices(configMsgChan, &sliceWg)
	sliceWg.Wait()
	logger.SimappLog.Infoln("phase 3 complete: network slices provisioned")

	http.HandleFunc("/synchronize", syncConfig)
	err = syncServer.ListenAndServe()
	if err != nil && !errors.Is(err, http.ErrServerClosed) {
		// Note: as per the `ListenAndServe` documentation: "ListenAndServe always returns a non-nil error."
		logger.SimappLog.Errorln(err)
	}
	for {
		time.Sleep(100 * time.Second)
	}
}

// handleTermination stops simapp on SIGTERM (a pod delete or a rollout) or
// Ctrl-C, in whatever phase it is: it shuts the /synchronize server down and
// exits 0.
func handleTermination(server *http.Server) {
	signals := make(chan os.Signal, 1)
	signal.Notify(signals, os.Interrupt, syscall.SIGTERM)
	go func() {
		sig := <-signals
		logger.SimappLog.Infof("received %v, terminating SIMApp", sig)
		stopServer(server, 5*time.Second)
		logger.SimappLog.Infoln("SIMApp terminated")
		os.Exit(0)
	}()
}

// stopServer shuts the server down, waiting at most timeout for requests in
// flight. A server that was never started returns at once.
func stopServer(server *http.Server, timeout time.Duration) {
	shutdownCtx, cancel := context.WithTimeout(context.Background(), timeout)
	defer cancel()
	if err := server.Shutdown(shutdownCtx); err != nil {
		logger.SimappLog.Warnf("/synchronize server shutdown: %v", err)
	}
}

func getNextBackoffInterval(retry, interval uint) uint {
	mFactor := 1.5
	nextInterval := float64(retry*interval) * mFactor

	if nextInterval > 10 {
		return 10
	}

	return uint(nextInterval)
}

func sendHttpReqMsg(req *http.Request) (*http.Response, error) {
	// Keep sending request to Http server until response is success
	var retries uint = 0
	body, err := io.ReadAll(req.Body)
	if err != nil {
		logger.SimappLog.Errorln(err)
	}
	for {
		cloneReq := req.Clone(context.Background())
		req.Body = io.NopCloser(bytes.NewReader(body))
		cloneReq.Body = io.NopCloser(bytes.NewReader(body))
		rsp, err := client.Do(cloneReq)
		retries += 1
		if err != nil {
			if rsp != nil {
				if rsp.StatusCode == http.StatusConflict {
					logger.SimappLog.Infof("http response StatusConflict, skipping retry")
					err = req.Body.Close()
					if err != nil {
						logger.SimappLog.Errorln(err)
					}
					return rsp, nil
				}
			}
			nextInterval := getNextBackoffInterval(retries, 2)
			logger.SimappLog.Errorf("http req send error [%v], retrying after %d sec", err, nextInterval)
			time.Sleep(time.Second * time.Duration(nextInterval))
			continue
		}

		if rsp.StatusCode == http.StatusAccepted ||
			rsp.StatusCode == http.StatusOK || rsp.StatusCode == http.StatusNoContent ||
			rsp.StatusCode == http.StatusCreated {
			logger.SimappLog.Debugln("config push success")
			err = req.Body.Close()
			if err != nil {
				logger.SimappLog.Errorln(err)
			}
			return rsp, nil
		} else {
			if rsp.StatusCode == http.StatusConflict {
				logger.SimappLog.Infof("http response StatusConflict, skipping retry")
				err = req.Body.Close()
				if err != nil {
					logger.SimappLog.Errorln(err)
				}
				return rsp, nil
			}
			// 4xx client errors indicate a bad request that retrying won't fix
			if rsp.StatusCode >= 400 && rsp.StatusCode < 500 {
				logger.SimappLog.Errorf("http rsp client error [%s], not retrying", http.StatusText(rsp.StatusCode))
				err = req.Body.Close()
				if err != nil {
					logger.SimappLog.Errorln(err)
				}
				return rsp, fmt.Errorf("client error %d: %s", rsp.StatusCode, http.StatusText(rsp.StatusCode))
			}
			nextInterval := getNextBackoffInterval(retries, 2)
			logger.SimappLog.Infof("http rsp error [%s], retrying after %d sec", http.StatusText(rsp.StatusCode), nextInterval)
			err = rsp.Body.Close()
			if err != nil {
				logger.SimappLog.Infoln(err)
			}
			time.Sleep(time.Second * time.Duration(nextInterval))
		}
	}
}

func waitForWebui(subProvisionEndpt SubProvisionEndpt) {
	ip := strings.TrimSpace(subProvisionEndpt.Addr)
	readinessURL := httpProtocol + ip + ":" + subProvisionEndpt.Port + "/config/v1/device-group/"

	logger.SimappLog.Infoln("waiting for webui to be ready at", readinessURL)
	for {
		req, err := http.NewRequestWithContext(context.Background(), http.MethodGet, readinessURL, nil)
		if err != nil {
			logger.SimappLog.Errorf("failed to create readiness request: %v", err)
			time.Sleep(2 * time.Second)
			continue
		}
		rsp, err := client.Do(req)
		if err != nil {
			logger.SimappLog.Infof("webui not ready: %v, retrying in 2 seconds...", err)
			time.Sleep(2 * time.Second)
			continue
		}
		if err := rsp.Body.Close(); err != nil {
			logger.SimappLog.Errorf("failed to close readiness response body: %v", err)
		}
		if rsp.StatusCode >= 200 && rsp.StatusCode < 300 {
			logger.SimappLog.Infoln("webui is ready, starting message processing")
			return
		}
		logger.SimappLog.Infof("webui returned status %d, retrying in 2 seconds...", rsp.StatusCode)
		time.Sleep(2 * time.Second)
	}
}

func sendMessage(msgChan chan configMessage, subProvisionEndpt SubProvisionEndpt) {
	var devGroupHttpend string
	var networkSliceHttpend string
	var subscriberHttpend string

	logger.SimappLog.Infof("subscriber provision endpoint in sendMessage: %s:%s", subProvisionEndpt.Addr, subProvisionEndpt.Port)

	ip := strings.TrimSpace(subProvisionEndpt.Addr)

	logger.SimappLog.Infoln("webui running at", ip)
	devGroupHttpend = httpProtocol + ip + ":" + subProvisionEndpt.Port + "/config/v1/device-group/"
	logger.SimappLog.Infoln("device trigger http endpoint", devGroupHttpend)
	networkSliceHttpend = httpProtocol + ip + ":" + subProvisionEndpt.Port + "/config/v1/network-slice/"
	logger.SimappLog.Infoln("network slice http endpoint", networkSliceHttpend)
	subscriberHttpend = httpProtocol + ip + ":" + subProvisionEndpt.Port + "/api/subscriber/imsi-"
	logger.SimappLog.Infoln("subscriber http endpoint", subscriberHttpend)

	// Create a worker pool with configurable max concurrent requests
	maxWorkers := SimappConfig.Configuration.MaxWorkers
	if maxWorkers <= 0 {
		maxWorkers = 50
	}
	var wg sync.WaitGroup
	semaphore := make(chan struct{}, maxWorkers)

	logger.SimappLog.Infof("starting message processor with %d parallel workers", maxWorkers)

	for msg := range msgChan {
		wg.Add(1)
		semaphore <- struct{}{} // Acquire semaphore

		go func(msg configMessage) {
			defer wg.Done()
			defer func() { <-semaphore }() // Release semaphore

			var httpend string
			logger.SimappLog.Debugln("received message from channel", msg)
			switch msg.msgType {
			case device_group:
				httpend = devGroupHttpend + msg.name
			case network_slice:
				httpend = networkSliceHttpend + msg.name
			case subscriber:
				httpend = subscriberHttpend + msg.name
			}
			var rsp *http.Response
			var httpErr error
			for {
				if msg.msgOp == add_op {
					logger.SimappLog.Infof("post message [%v] to %v", msg.String(), httpend)
					req, err := http.NewRequestWithContext(context.Background(), http.MethodPost, httpend, msg.msgPtr)
					if err != nil {
						logger.SimappLog.Errorf("an error occurred %v", err)
						time.Sleep(1 * time.Second)
						continue
					}

					req.Header.Set("Content-Type", "application/json; charset=utf-8")
					rsp, httpErr = sendHttpReqMsg(req)
					if httpErr != nil {
						logger.SimappLog.Errorf("post message [%v] returned error [%v]", httpend, httpErr.Error())
					}

					logger.SimappLog.Infof("message POST %v success", rsp.StatusCode)
				} else if msg.msgOp == modify_op {
					logger.SimappLog.Infof("put message [%v] to %v", msg.String(), httpend)

					req, err := http.NewRequestWithContext(context.Background(), http.MethodPut, httpend, msg.msgPtr)
					// Handle Error
					if err != nil {
						logger.SimappLog.Errorf("an error occurred %v", err)
						time.Sleep(1 * time.Second)
						continue
					}
					// set the request header Content-Type for json
					req.Header.Set("Content-Type", "application/json; charset=utf-8")
					rsp, httpErr = sendHttpReqMsg(req)
					if httpErr != nil {
						logger.SimappLog.Errorf("put message [%v] returned error [%v]", httpend, httpErr.Error())
					}

					logger.SimappLog.Infof("message PUT %v success", rsp.StatusCode)
				} else if msg.msgOp == delete_op {
					logger.SimappLog.Infof("delete message [%v] to %v", msg.String(), httpend)

					req, err := http.NewRequestWithContext(context.Background(), http.MethodDelete, httpend, msg.msgPtr)
					// Handle Error
					if err != nil {
						logger.SimappLog.Errorf("an error occurred %v", err)
						time.Sleep(1 * time.Second)
						continue
					}
					// set the request header Content-Type for json
					req.Header.Set("Content-Type", "application/json; charset=utf-8")
					rsp, httpErr = sendHttpReqMsg(req)
					if httpErr != nil {
						logger.SimappLog.Errorf("delete message [%v] returned error [%v]", httpend, httpErr.Error())
					}
					logger.SimappLog.Infof("message DEL %v success", rsp.StatusCode)
				}
				err := rsp.Body.Close()
				if err != nil {
					logger.SimappLog.Errorln(err)
				}
				if msg.wg != nil {
					msg.wg.Done()
				}
				break
			}
		}(msg)
	}

	// Wait for all goroutines to complete before exiting
	wg.Wait()
	logger.SimappLog.Infoln("all messages processed, message sender shutting down")
}

func compareSubscriber(subscriberNew *Subscriber, subscriberOld *Subscriber) bool {
	if subscriberNew.PlmnId != subscriberOld.PlmnId {
		logger.SimappLog.Infoln("plmn ID changed")
		return true
	}
	if subscriberNew.OPc != subscriberOld.OPc {
		logger.SimappLog.Infoln("OPc changed")
		return true
	}
	if subscriberNew.OP != subscriberOld.OP {
		logger.SimappLog.Infoln("OP changed")
		return true
	}
	if subscriberNew.Key != subscriberOld.Key {
		logger.SimappLog.Infoln("Key changed")
		return true
	}
	if subscriberNew.SequenceNumber != subscriberOld.SequenceNumber {
		logger.SimappLog.Infoln("SequenceNumber changed")
		return true
	}
	return false
}

func compareGroup(groupNew *DevGroup, groupOld *DevGroup) bool {
	if groupNew.IpDomainName != groupOld.IpDomainName {
		logger.SimappLog.Infoln("ip domain name changed")
		return true
	}

	if groupNew.SiteInfo != groupOld.SiteInfo {
		logger.SimappLog.Infoln("siteInfo name changed")
		return true
	}

	if groupNew.ImsiStart != groupOld.ImsiStart || groupNew.ImsiEnd != groupOld.ImsiEnd {
		logger.SimappLog.Infoln("imsi range changed")
		return true
	}

	if len(groupNew.Imsis) != len(groupOld.Imsis) {
		logger.SimappLog.Infoln("number of Imsis changed")
		return true
	}

	if groupNew.MsisdnStart != groupOld.MsisdnStart || groupNew.MsisdnEnd != groupOld.MsisdnEnd {
		logger.SimappLog.Infoln("msisdn range changed")
		return true
	}

	// Compare MSISDN lists
	if !reflect.DeepEqual(groupNew.Msisdns, groupOld.Msisdns) {
		logger.SimappLog.Infoln("msisdns list has changed")
		return true
	}

	var allimsiNew string
	for _, imsi := range groupNew.Imsis {
		allimsiNew = allimsiNew + imsi
	}
	h1 := sha1.New()
	h1.Write([]byte(allimsiNew))
	bs1 := h1.Sum(nil)
	strcode1 := hex.EncodeToString(bs1[:])

	var allimsiOld string
	for _, imsi := range groupOld.Imsis {
		allimsiOld = allimsiOld + imsi
	}
	h2 := sha1.New()
	h2.Write([]byte(allimsiOld))
	bs2 := h2.Sum(nil)
	strcode2 := hex.EncodeToString(bs2[:])

	logger.SimappLog.Infof("CODE1: %s and CODE2: %s", strcode1, strcode2)
	if strcode2 != strcode1 {
		return true
	}

	if len(groupNew.IpDomains) != len(groupOld.IpDomains) {
		logger.SimappLog.Infoln("Number of IpDomains changed")
		return true
	}

	for i := range groupNew.IpDomains {
		if i >= len(groupOld.IpDomains) {
			// If groupOld doesn't have enough IpDomains
			return true
		}

		oldIpDomain := groupOld.IpDomains[i]
		newIpDomain := groupNew.IpDomains[i]

		if oldIpDomain.Dnn != newIpDomain.Dnn {
			logger.SimappLog.Infoln("DNN changed")
			return true
		}

		if oldIpDomain.Mtu != newIpDomain.Mtu {
			logger.SimappLog.Infoln("MTU changed")
			return true
		}

		if oldIpDomain.PcscfPrimary != newIpDomain.PcscfPrimary {
			logger.SimappLog.Infoln("PcscfPrimary changed")
			return true
		}

		if oldIpDomain.UePool != newIpDomain.UePool {
			logger.SimappLog.Infoln("UePool changed")
			return true
		}

		// Detect addition or removal of UeDnnQos
		if (oldIpDomain.UeDnnQos == nil) != (newIpDomain.UeDnnQos == nil) {
			logger.SimappLog.Infoln("UeDnnQos presence changed")
			return true
		}

		if oldIpDomain.UeDnnQos != nil && newIpDomain.UeDnnQos != nil {
			// Detect addition or removal of TrafficClass
			if (oldIpDomain.UeDnnQos.TrafficClass == nil) !=
				(newIpDomain.UeDnnQos.TrafficClass == nil) {
				logger.SimappLog.Infoln("TrafficClass presence changed")
				return true
			}

			// Compare UeDnnQos bitrate fields
			if oldIpDomain.UeDnnQos.Uplink != newIpDomain.UeDnnQos.Uplink ||
				oldIpDomain.UeDnnQos.Downlink != newIpDomain.UeDnnQos.Downlink ||
				oldIpDomain.UeDnnQos.BitRateUnit != newIpDomain.UeDnnQos.BitRateUnit {
				logger.SimappLog.Infoln("UeDnnQos bitrate parameters changed")
				return true
			}

			// Compare TrafficClass fields when both exist
			if oldIpDomain.UeDnnQos.TrafficClass != nil &&
				newIpDomain.UeDnnQos.TrafficClass != nil {
				if oldIpDomain.UeDnnQos.TrafficClass.Name != newIpDomain.UeDnnQos.TrafficClass.Name ||
					oldIpDomain.UeDnnQos.TrafficClass.Qci != newIpDomain.UeDnnQos.TrafficClass.Qci ||
					oldIpDomain.UeDnnQos.TrafficClass.Arp != newIpDomain.UeDnnQos.TrafficClass.Arp ||
					oldIpDomain.UeDnnQos.TrafficClass.Pdb != newIpDomain.UeDnnQos.TrafficClass.Pdb ||
					oldIpDomain.UeDnnQos.TrafficClass.Pelr != newIpDomain.UeDnnQos.TrafficClass.Pelr {
					logger.SimappLog.Infoln("TrafficClass properties changed")
					return true
				}
			}
		}
	}
	return false
}

func compareNetworkSlice(sliceNew *NetworkSlice, sliceOld *NetworkSlice) bool {
	// slice Id should not change
	appFilteringRulesNew := sliceNew.ApplicationFilteringRules
	appFilteringRulesOld := sliceOld.ApplicationFilteringRules
	if !reflect.DeepEqual(appFilteringRulesNew, appFilteringRulesOld) {
		return true
	}
	for _, ng := range sliceNew.DevGroups {
		if !slices.Contains(sliceOld.DevGroups, ng) {
			logger.SimappLog.Infoln("new dev group added in slice")
			return true // 2 network slices have some difference
		}
	}
	for _, ng := range sliceOld.DevGroups {
		if !slices.Contains(sliceNew.DevGroups, ng) {
			logger.SimappLog.Infoln("dev group deleted in slice")
			return true // 2 network slices have some difference
		}
	}
	oldSite := sliceOld.SiteInfo
	newSite := sliceNew.SiteInfo
	if oldSite.SiteName != newSite.SiteName {
		logger.SimappLog.Infoln("site name changed")
		return true
	}
	oldUpf := oldSite.Upf
	newUpf := newSite.Upf
	if (oldUpf.UpfName != newUpf.UpfName) && (oldUpf.UpfPort != newUpf.UpfPort) {
		logger.SimappLog.Infoln("upf details changed")
		return true
	}

	for _, newgnb := range newSite.Gnb {
		if !slices.ContainsFunc(oldSite.Gnb, func(oldgnb *Gnb) bool {
			return newgnb.Name == oldgnb.Name && newgnb.Tac == oldgnb.Tac
		}) {
			logger.SimappLog.Infoln("gnb changed in slice")
			return true // change in slice details
		}
	}

	logger.SimappLog.Warnln("no change in slices")
	return false
}

func isImsiInSubscribers(imsi int, subscribers []*Subscriber) (bool, *Subscriber) {
	for _, subscriber := range subscribers {
		start, err := strconv.Atoi(subscriber.UeIdStart)
		if err != nil {
			logger.SimappLog.Errorln("error in Atoi with UeIdStart", err)
			continue
		}
		end, err := strconv.Atoi(subscriber.UeIdEnd)
		if err != nil {
			logger.SimappLog.Errorln("error in Atoi with UeIdEnd", err)
			continue
		}
		if imsi >= start && imsi <= end {
			return true, subscriber
		}
	}
	return false, nil
}

func UpdateConfig(f string) error {
	if content, err := os.ReadFile(f); err != nil {
		return err
	} else {
		NewSimappConfig := Config{}

		if yamlErr := yaml.Unmarshal(content, &NewSimappConfig); yamlErr != nil {
			return yamlErr
		}
		if NewSimappConfig.Configuration == nil {
			logger.SimappLog.Infoln("configuration parsing failed", NewSimappConfig.Configuration)
			return nil
		}

		logger.SimappLog.Infoln("number of subscriber ranges in updated config", len(SimappConfig.Configuration.Subscriber))
		var newImsiList []uint64
		for _, newSubscribers := range NewSimappConfig.Configuration.Subscriber {
			logger.SimappLog.Infoln("Subscribers:")
			logger.SimappLog.Infoln("UeIdStart", newSubscribers.UeIdStart)
			logger.SimappLog.Infoln("UeIdEnd", newSubscribers.UeIdEnd)
			logger.SimappLog.Infoln("PlmnId", newSubscribers.PlmnId)
			logger.SimappLog.Infoln("OPc", newSubscribers.OPc)
			logger.SimappLog.Infoln("OP", newSubscribers.OP)
			logger.SimappLog.Infoln("Key", newSubscribers.Key)
			logger.SimappLog.Infoln("SequenceNumber", newSubscribers.SequenceNumber)

			newStart, err := strconv.Atoi(newSubscribers.UeIdStart)
			if err != nil {
				logger.SimappLog.Errorln("error in Atoi with UeIdStart", err)
				continue
			}
			newEnd, err := strconv.Atoi(newSubscribers.UeIdEnd)
			if err != nil {
				logger.SimappLog.Errorln("error in Atoi with UeIdEnd", err)
				continue
			}
			for i := newStart; i <= newEnd; i++ {
				newImsiList = append(newImsiList, uint64(i))

				found, existingSubscriber := isImsiInSubscribers(i, SimappConfig.Configuration.Subscriber)
				if found {
					if compareSubscriber(newSubscribers, existingSubscriber) {
						logger.SimappLog.Warnln("subscriber provision not support modify yet")
					}
					continue
				}
				// add subscriber to chan
				newSubscribers.UeId = fmt.Sprintf("%015d", i)

				b, err := json.Marshal(newSubscribers)
				if err != nil {
					logger.SimappLog.Errorln("error in marshal with newSubscriber", err)
					continue
				}
				reqMsgBody := bytes.NewBuffer(b)
				var msg configMessage
				msg.msgPtr = reqMsgBody
				msg.msgType = subscriber
				msg.name = newSubscribers.UeId
				msg.msgOp = add_op
				configMsgChan <- msg
			}
		}
		// delete all the existing subscribers not show up in new config.
		for _, subscribers := range SimappConfig.Configuration.Subscriber {
			start, err := strconv.Atoi(subscribers.UeIdStart)
			if err != nil {
				logger.SimappLog.Errorln("error in Atoi with UeIdStart", err)
				continue
			}
			end, err := strconv.Atoi(subscribers.UeIdEnd)
			if err != nil {
				logger.SimappLog.Errorln("error in Atoi with UeIdEnd", err)
				continue
			}
			for k := start; k <= end; k++ {
				if !slices.Contains(newImsiList, uint64(k)) {
					logger.SimappLog.Infoln("going to delete subscriber:", k)
					b, err := json.Marshal("")
					if err != nil {
						logger.SimappLog.Infoln("error in marshal with subscriber", err)
						continue
					}
					reqMsgBody := bytes.NewBuffer(b)
					var msg configMessage
					msg.msgPtr = reqMsgBody
					msg.msgType = subscriber
					msg.name = fmt.Sprintf("%015d", k)
					msg.msgOp = delete_op
					configMsgChan <- msg
				}
			}
		}
		SimappConfig.Configuration.Subscriber = NewSimappConfig.Configuration.Subscriber
		// end process subscriber update

		for _, group := range SimappConfig.Configuration.DevGroup {
			group.visited = false
		}
		for _, groupNew := range NewSimappConfig.Configuration.DevGroup {
			found := false
			for _, groupOld := range SimappConfig.Configuration.DevGroup {
				if groupNew.Name == groupOld.Name {
					configChange := compareGroup(groupNew, groupOld)
					if configChange {
						// send Group Put
						logger.SimappLog.Infoln("updated group config", groupNew.Name)
						dispatchGroup(configMsgChan, groupNew, modify_op, nil)
						// find all slices which are using this device group and mark them modified
						for _, slice := range SimappConfig.Configuration.NetworkSlice {
							if slices.Contains(slice.DevGroups, groupOld.Name) {
								slice.modified = true
							}
						}
					} else {
						logger.SimappLog.Infoln("config not updated for group", groupNew.Name)
					}
					found = true
					groupOld.visited = true
					break
				}
			}
			if !found {
				// new Group - Send Post
				logger.SimappLog.Infoln("new group config", groupNew.Name)
				dispatchGroup(configMsgChan, groupNew, add_op, nil)
			}
		}
		// visit all groups see if slice is deleted...if found = false
		for _, group := range SimappConfig.Configuration.DevGroup {
			if !group.visited {
				logger.SimappLog.Infoln("group deleted", group.Name)
				dispatchGroup(configMsgChan, group, delete_op, nil)
				// find all slices which are using this device group and mark them modified
				for _, slice := range SimappConfig.Configuration.NetworkSlice {
					if slices.Contains(slice.DevGroups, group.Name) {
						slice.modified = true
					}
				}
			}
		}

		SimappConfig.Configuration.DevGroup = NewSimappConfig.Configuration.DevGroup

		// visit all sliceOld see if slice is deleted...if found = false
		for _, slice := range SimappConfig.Configuration.NetworkSlice {
			slice.visited = false
		}

		for _, sliceNew := range NewSimappConfig.Configuration.NetworkSlice {
			found := false
			for _, sliceOld := range SimappConfig.Configuration.NetworkSlice {
				if sliceNew.Name == sliceOld.Name {
					configChange := compareNetworkSlice(sliceNew, sliceOld)
					if sliceOld.modified {
						logger.SimappLog.Infoln("updated slice config", sliceNew.Name)
						sliceOld.modified = false
						dispatchNetworkSlice(configMsgChan, sliceNew, modify_op, nil)
					} else if configChange {
						// send Slice Put
						logger.SimappLog.Infoln("updated slice config", sliceNew.Name)
						dispatchNetworkSlice(configMsgChan, sliceNew, modify_op, nil)
					} else {
						logger.SimappLog.Infoln("config not updated for slice", sliceNew.Name)
					}
					found = true
					sliceOld.visited = true
					break
				}
			}
			if !found {
				// new Slice - Send Post
				logger.SimappLog.Infoln("new slice config", sliceNew.Name)
				dispatchNetworkSlice(configMsgChan, sliceNew, add_op, nil)
			}
		}
		// visit all sliceOld see if slice is deleted...if found = false
		for _, slice := range SimappConfig.Configuration.NetworkSlice {
			if !slice.visited {
				logger.SimappLog.Infoln("slice deleted", slice.Name)
				dispatchNetworkSlice(configMsgChan, slice, delete_op, nil)
			}
		}
		SimappConfig.Configuration.NetworkSlice = NewSimappConfig.Configuration.NetworkSlice
	}
	return nil
}

func WatchConfig() {
	viper.WatchConfig()
	viper.OnConfigChange(func(e fsnotify.Event) {
		logger.SimappLog.Infoln("config file changed:", e.Name)
		if err := UpdateConfig("config/simapp.yaml"); err != nil {
			logger.SimappLog.Errorln("error in loading updated configuration", err)
		} else {
			logger.SimappLog.Infoln("successfully updated configuration")
		}
	})
	logger.SimappLog.Infoln("watchConfig done")
}

func dispatchAllSubscribers(configMsgChan chan configMessage, wg *sync.WaitGroup) {
	logger.SimappLog.Infoln("number of subscriber ranges", len(SimappConfig.Configuration.Subscriber))
	for _, subscribers := range SimappConfig.Configuration.Subscriber {
		logger.SimappLog.Infof("subscribers: UeIdStart: %s, UeIdEnd: %s, PlmnId: %s, OPc: %s, OP: %s, Key: %s, SequenceNumber: %s",
			subscribers.UeIdStart, subscribers.UeIdEnd, subscribers.PlmnId, subscribers.OPc,
			subscribers.OP, subscribers.Key, subscribers.SequenceNumber)
		start, err := strconv.Atoi(subscribers.UeIdStart)
		if err != nil {
			logger.SimappLog.Errorln("error in Atoi with UeIdStart", err)
			continue
		}
		end, err := strconv.Atoi(subscribers.UeIdEnd)
		if err != nil {
			logger.SimappLog.Errorln("error in Atoi with UeIdEnd", err)
			continue
		}
		for i := start; i <= end; i++ {
			subscribers.UeId = fmt.Sprintf("%015d", i)
			logger.SimappLog.Debugln("ueId", subscribers.UeId)
			b, err := json.Marshal(subscribers)
			if err != nil {
				logger.SimappLog.Errorln("error in marshal with subscribers", err)
				continue
			}
			reqMsgBody := bytes.NewBuffer(b)
			var msg configMessage
			msg.msgPtr = reqMsgBody
			msg.msgType = subscriber
			msg.name = subscribers.UeId
			msg.msgOp = add_op
			if wg != nil {
				wg.Add(1)
				msg.wg = wg
			}
			configMsgChan <- msg
		}
	}
}

func splitNumericSuffix(value string) (string, uint64, int, error) {
	index := len(value)
	for index > 0 && value[index-1] >= '0' && value[index-1] <= '9' {
		index--
	}
	if index == len(value) {
		return "", 0, 0, fmt.Errorf("missing numeric suffix")
	}

	number, err := strconv.ParseUint(value[index:], 10, 64)
	if err != nil {
		return "", 0, 0, err
	}
	return value[:index], number, len(value) - index, nil
}

func dispatchGroup(configMsgChan chan configMessage, group *DevGroup, msgOp int, wg *sync.WaitGroup) {
	groupCopy := *group
	group = &groupCopy
	if msgOp != delete_op && (group.ImsiStart != "" || group.ImsiEnd != "") {
		if group.ImsiStart == "" || group.ImsiEnd == "" {
			logger.SimappLog.Errorf("incomplete IMSI range %q-%q for group %s (both imsi-start and imsi-end are required)", group.ImsiStart, group.ImsiEnd, group.Name)
			return
		}
		start, startErr := strconv.ParseUint(group.ImsiStart, 10, 64)
		end, endErr := strconv.ParseUint(group.ImsiEnd, 10, 64)
		if startErr != nil || endErr != nil || start > end {
			logger.SimappLog.Errorf("invalid IMSI range %q-%q for group %s", group.ImsiStart, group.ImsiEnd, group.Name)
			return
		}
		diff := end - start
		if diff == ^uint64(0) {
			logger.SimappLog.Errorf("IMSI range too large %q-%q for group %s", group.ImsiStart, group.ImsiEnd, group.Name)
			return
		}
		count := diff + 1
		if count > uint64(^uint(0)>>1) {
			logger.SimappLog.Errorf("IMSI range too large %q-%q for group %s", group.ImsiStart, group.ImsiEnd, group.Name)
			return
		}
		group.Imsis = make([]string, 0, int(count))
		for imsi := start; ; imsi++ {
			group.Imsis = append(group.Imsis, fmt.Sprintf("%015d", imsi))
			if imsi == end {
				break
			}
		}
	}
	if msgOp != delete_op && (group.MsisdnStart != "" || group.MsisdnEnd != "") {
		if group.MsisdnStart == "" || group.MsisdnEnd == "" {
			logger.SimappLog.Errorf("incomplete MSISDN range %q-%q for group %s (both msisdn-start and msisdn-end are required)", group.MsisdnStart, group.MsisdnEnd, group.Name)
			return
		}
		prefix, start, width, startErr := splitNumericSuffix(group.MsisdnStart)
		endPrefix, end, endWidth, endErr := splitNumericSuffix(group.MsisdnEnd)
		if startErr != nil || endErr != nil || prefix != endPrefix || width != endWidth || start > end {
			logger.SimappLog.Errorf("invalid MSISDN range %q-%q for group %s", group.MsisdnStart, group.MsisdnEnd, group.Name)
			return
		}
		diff := end - start
		if diff == ^uint64(0) {
			logger.SimappLog.Errorf("MSISDN range too large %q-%q for group %s", group.MsisdnStart, group.MsisdnEnd, group.Name)
			return
		}
		count := diff + 1
		if count > uint64(^uint(0)>>1) {
			logger.SimappLog.Errorf("MSISDN range too large %q-%q for group %s", group.MsisdnStart, group.MsisdnEnd, group.Name)
			return
		}

		group.Msisdns = make([]string, 0, int(count))
		for msisdn := start; ; msisdn++ {
			group.Msisdns = append(group.Msisdns, fmt.Sprintf("%s%0*d", prefix, width, msisdn))
			if msisdn == end {
				break
			}
		}
	}
	logger.SimappLog.Infoln("group name", group.Name)
	logger.SimappLog.Infoln("site name", group.SiteInfo)
	logger.SimappLog.Infoln("imsis", group.Imsis)
	for _, imsi := range group.Imsis {
		logger.SimappLog.Debugln("imsi", imsi)
	}
	logger.SimappLog.Infoln("IpDomainName", group.IpDomainName)
	// Check if IpDomains is nil or not
	if group.IpDomains != nil {
		for _, ipDomain := range group.IpDomains {
			logger.SimappLog.Infoln("  IpDomain Dnn:", ipDomain.Dnn)
			logger.SimappLog.Infoln("  IpDomain Dns Primary:", ipDomain.DnsPrimary)
			logger.SimappLog.Infoln("  IpDomain Pcscf Primary:", ipDomain.PcscfPrimary)
			logger.SimappLog.Infoln("  IpDomain Mtu:", ipDomain.Mtu)
			logger.SimappLog.Infoln("  IpDomain UePool:", ipDomain.UePool)

			// Check if UeDnnQos field is populated
			if ipDomain.UeDnnQos != nil {
				logger.SimappLog.Infoln("  UeDnnQos:", ipDomain.UeDnnQos)
			} else {
				logger.SimappLog.Warnln("  UeDnnQos is nil")
			}
		}
	} else {
		logger.SimappLog.Warnln("  IpDomains is nil")
	}
	b, err := json.Marshal(group)
	if err != nil {
		logger.SimappLog.Errorln("error in marshal", err)
		return
	}
	reqMsgBody := bytes.NewBuffer(b)
	var msg configMessage
	msg.msgPtr = reqMsgBody
	msg.msgType = device_group
	msg.name = group.Name
	msg.msgOp = msgOp
	if wg != nil {
		wg.Add(1)
		msg.wg = wg
	}
	configMsgChan <- msg
}

func dispatchAllGroups(configMsgChan chan configMessage, wg *sync.WaitGroup) {
	logger.SimappLog.Infoln("number of device groups", len(SimappConfig.Configuration.DevGroup))
	for _, group := range SimappConfig.Configuration.DevGroup {
		dispatchGroup(configMsgChan, group, add_op, wg)
	}
}

func dispatchNetworkSlice(configMsgChan chan configMessage, slice *NetworkSlice, msgOp int, wg *sync.WaitGroup) {
	logger.SimappLog.Infoln("slice name:", slice.Name)
	logger.SimappLog.Infof("slice sst %v, sd %v", slice.SliceId.Sst, slice.SliceId.Sd)
	logger.SimappLog.Infof("slice site info: %+v", slice.SiteInfo)
	site := slice.SiteInfo
	logger.SimappLog.Infoln("slice site name", site.SiteName)
	logger.SimappLog.Infoln("slice gNB", len(site.Gnb))
	for i, gnb := range site.Gnb {
		logger.SimappLog.Infof("slice gNB[%v] = %s, tac: %d", i, gnb.Name, gnb.Tac)
	}
	logger.SimappLog.Infof("slice Plmn %+v", site.Plmn)
	logger.SimappLog.Infof("slice Upf %+v", site.Upf)

	logger.SimappLog.Infoln("slice device groups", slice.DevGroups)
	for _, devGroup := range slice.DevGroups {
		logger.SimappLog.Infoln("attached device group", devGroup)
	}

	b, err := json.Marshal(slice)
	if err != nil {
		logger.SimappLog.Errorln("error in marshal", err)
		return
	}
	reqMsgBody := bytes.NewBuffer(b)

	var msg configMessage
	msg.msgPtr = reqMsgBody
	msg.msgType = network_slice
	msg.name = slice.Name
	msg.msgOp = msgOp
	if wg != nil {
		wg.Add(1)
		msg.wg = wg
	}
	configMsgChan <- msg
}

func dispatchAllNetworkSlices(configMsgChan chan configMessage, wg *sync.WaitGroup) {
	logger.SimappLog.Infoln("number of network slices", len(SimappConfig.Configuration.NetworkSlice))
	for _, slice := range SimappConfig.Configuration.NetworkSlice {
		dispatchNetworkSlice(configMsgChan, slice, add_op, wg)
	}
}