based on top of mec011 phase1 (423bebfb) · Commits · MEC - Multi-access Edge Computing / ETSI MEC Sandbox

go-apps/meep-app-enablement/server/app-support/api_app_subscriptions.go

+4 −8

Original line number	Diff line number	Diff line
		@@ -28,21 +28,17 @@ import (
		)

		func ApplicationsSubscriptionDELETE(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		w.WriteHeader(http.StatusOK)
		applicationsSubscriptionDELETE(w, r)
		}

		func ApplicationsSubscriptionGET(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		w.WriteHeader(http.StatusOK)
		applicationsSubscriptionGET(w, r)
		}

		func ApplicationsSubscriptionsGET(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		w.WriteHeader(http.StatusOK)
		applicationsSubscriptionsGET(w, r)
		}

		func ApplicationsSubscriptionsPOST(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		w.WriteHeader(http.StatusOK)
		applicationsSubscriptionsPOST(w, r)
		}

go-apps/meep-app-enablement/server/app-support/app-support.go

+256 −1

Original line number	Diff line number	Diff line
		@@ -21,9 +21,11 @@ import (

		"encoding/json"
		"errors"
		"fmt"
		"net/http"
		"net/url"
		"os"
		"strconv"
		"strings"
		"sync"

		@@ -40,6 +42,7 @@ const mappsupportKey = "mec-app-support"
		const appEnablementKey = "app-enablement"
		const ACTIVE = "ACTIVE"
		const INACTIVE = "INACTIVE"
		const APP_TERMINATION_NOTIFICATION_SUBSCRIPTION_TYPE = "AppTerminationNotificationSubscription"

		var mutex *sync.Mutex

		@@ -62,6 +65,7 @@ var appEnablementBaseKey string

		//var expiryTicker *time.Ticker

		var appTerminationNotificationSubscriptionMap = map[int]*AppTerminationNotificationSubscription{}
		var nextSubscriptionIdAvailable int

		/func notImplemented(w http.ResponseWriter, r http.Request) {
		@@ -69,8 +73,10 @@ var nextSubscriptionIdAvailable int
		w.WriteHeader(http.StatusNotImplemented)
		}
		*/

		func Init(globalMutex *sync.Mutex) (err error) {
		mutex = globalMutex

		// Retrieve Sandbox name from environment variable
		sandboxNameEnv := strings.TrimSpace(os.Getenv("MEEP_SANDBOX_NAME"))
		if sandboxNameEnv != "" {
		@@ -129,6 +135,7 @@ func Init(globalMutex *sync.Mutex) (err error) {
		log.Info("Connected to Redis DB")

		reInit()

		/*
		expiryTicker = time.NewTicker(time.Second)
		go func() {
		@@ -144,6 +151,9 @@ func Init(globalMutex *sync.Mutex) (err error) {
		func reInit() {
		//next available subsId will be overrriden if subscriptions already existed
		nextSubscriptionIdAvailable = 1
		keyName := baseKey + ":subscriptions:" + "*"
		_ = rc.ForEachJSONEntry(keyName, repopulateAppTerminationNotificationSubscriptionMap, nil)

		}

		// Run - Start APP support
		@@ -156,6 +166,33 @@ func Stop() (err error) {
		return nil
		}

		func repopulateAppTerminationNotificationSubscriptionMap(key string, jsonInfo string, userData interface{}) error {

		var subscription AppTerminationNotificationSubscription

		// Format response
		err := json.Unmarshal([]byte(jsonInfo), &subscription)
		if err != nil {
		return err
		}

		selfUrl := strings.Split(subscription.Links.Self.Href, "/")
		subsIdStr := selfUrl[len(selfUrl)-1]
		subsId, _ := strconv.Atoi(subsIdStr)

		mutex.Lock()
		defer mutex.Unlock()

		appTerminationNotificationSubscriptionMap[subsId] = &subscription

		//reinitialisation of next available Id for future subscription request
		if subsId >= nextSubscriptionIdAvailable {
		nextSubscriptionIdAvailable = subsId + 1
		}

		return nil
		}

		func applicationsConfirmReadyPOST(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		log.Info("applicationsConfirmReadyPOST")
		@@ -231,6 +268,22 @@ func applicationsConfirmTerminationPOST(w http.ResponseWriter, r *http.Request)
		return
		}

		//look if subscription exist to process the Termination POST
		found := false
		//loop through appTerm map
		for _, appTermSubscription := range appTerminationNotificationSubscriptionMap {
		if appTermSubscription != nil && appTermSubscription.AppInstanceId == appInstanceId {
		found = true
		break
		}
		}

		if !found {
		log.Error("AppInstanceId not subscribed for graceful termination")
		http.Error(w, "AppInstanceId not subscribed for graceful termination", http.StatusBadRequest)
		return
		}

		var confirmation AppTerminationConfirmation
		decoder := json.NewDecoder(r.Body)
		err = decoder.Decode(&confirmation)
		@@ -281,8 +334,10 @@ func updateAllServices(appInstanceId string, state msmgmt.ServiceState) error {
		var sInfoList msmgmt.ServiceInfoList

		keyName := appEnablementBaseKey + ":apps:" + appInstanceId + ":svcs:*"

		mutex.Lock()
		defer mutex.Unlock()

		err := rc.ForEachJSONEntry(keyName, populateServiceInfoList, &sInfoList)
		if err != nil {
		return err
		@@ -294,7 +349,6 @@ func updateAllServices(appInstanceId string, state msmgmt.ServiceState) error {
		if err != nil {
		return err
		}

		}
		return nil
		}
		@@ -316,3 +370,204 @@ func populateServiceInfoList(key string, jsonInfo string, sInfoList interface{})
		data.ServiceInfos = append(data.ServiceInfos, sInfo)
		return nil
		}

		func applicationsSubscriptionsPOST(w http.ResponseWriter, r *http.Request) {

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

		vars := mux.Vars(r)
		appInstanceId := vars["appInstanceId"]

		//check if entry exist for the application in the DB
		key := appEnablementBaseKey + ":apps:" + appInstanceId
		fields, err := rc.GetEntry(key)
		if err != nil \|\| len(fields) == 0 {
		log.Error("AppInstanceId does not exist, app is not running")
		http.Error(w, "AppInstanceId does not exist, app is not running", http.StatusBadRequest)
		return
		}

		var subscription AppTerminationNotificationSubscription
		decoder := json.NewDecoder(r.Body)
		err = decoder.Decode(&subscription)
		if err != nil {
		log.Error(err.Error())
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
		}

		//checking for mandatory properties
		if subscription.CallbackReference == "" {
		log.Error("Mandatory CallbackReference parameter not present")
		http.Error(w, "Mandatory CallbackReference parameter not present", http.StatusBadRequest)
		return
		}

		if subscription.SubscriptionType != APP_TERMINATION_NOTIFICATION_SUBSCRIPTION_TYPE {
		log.Error("SubscriptionType shall be AppTerminationNotificationSubscription")
		http.Error(w, "SubscriptionType shall be AppTerminationNotificationSubscription", http.StatusBadRequest)
		return
		}

		if subscription.AppInstanceId == "" {
		log.Error("Mandatory AppInstanceId parameter not present")
		http.Error(w, "Mandatory AppInstanceId parameter not present", http.StatusBadRequest)
		return
		}

		if subscription.AppInstanceId != appInstanceId {
		log.Error("AppInstanceId in endpoint and in body not matching")
		http.Error(w, "AppInstanceId in endpoint and in body not matching", http.StatusBadRequest)
		return
		}

		newSubsId := nextSubscriptionIdAvailable
		nextSubscriptionIdAvailable++
		subsIdStr := strconv.Itoa(newSubsId)

		link := new(Self)
		self := new(LinkType)
		self.Href = hostUrl.String() + basePath + "applications/" + appInstanceId + "/subscriptions/" + subsIdStr
		link.Self = self
		subscription.Links = link

		//registration
		registerAppTerm(&subscription, newSubsId)
		_ = rc.JSONSetEntry(baseKey+":subscriptions:"+subsIdStr, ".", convertAppTerminationNotificationSubscriptionToJson(&subscription))

		jsonResponse, err := json.Marshal(subscription)

		//processing the error of the jsonResponse
		if err != nil {
		log.Error(err.Error())
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
		}
		w.WriteHeader(http.StatusCreated)
		fmt.Fprintf(w, string(jsonResponse))
		}

		func registerAppTerm(subscription *AppTerminationNotificationSubscription, subsId int) {
		mutex.Lock()
		defer mutex.Unlock()

		appTerminationNotificationSubscriptionMap[subsId] = subscription
		log.Info("New registration: ", subsId, " type: ", APP_TERMINATION_NOTIFICATION_SUBSCRIPTION_TYPE)
		}

		func deregisterAppTermination(subsIdStr string, mutexTaken bool) {
		subsId, _ := strconv.Atoi(subsIdStr)
		if !mutexTaken {
		mutex.Lock()
		defer mutex.Unlock()
		}

		appTerminationNotificationSubscriptionMap[subsId] = nil
		log.Info("Deregistration: ", subsId, " type: ", APP_TERMINATION_NOTIFICATION_SUBSCRIPTION_TYPE)
		}

		func applicationsSubscriptionGET(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		vars := mux.Vars(r)
		subIdParamStr := vars["subscriptionId"]
		appInstanceId := vars["appInstanceId"]

		//check if entry exist for the application in the DB
		key := appEnablementBaseKey + ":apps:" + appInstanceId
		fields, err := rc.GetEntry(key)
		if err != nil \|\| len(fields) == 0 {
		log.Error("AppInstanceId does not exist, app is not running")
		http.Error(w, "AppInstanceId does not exist, app is not running", http.StatusBadRequest)
		return
		}

		jsonResponse, _ := rc.JSONGetEntry(baseKey+":subscriptions:"+subIdParamStr, ".")
		if jsonResponse == "" {
		w.WriteHeader(http.StatusNotFound)
		return
		}

		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, string(jsonResponse))
		}

		func applicationsSubscriptionDELETE(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")
		vars := mux.Vars(r)
		subIdParamStr := vars["subscriptionId"]
		appInstanceId := vars["appInstanceId"]

		//check if entry exist for the application in the DB
		key := appEnablementBaseKey + ":apps:" + appInstanceId
		fields, err := rc.GetEntry(key)
		if err != nil \|\| len(fields) == 0 {
		log.Error("AppInstanceId does not exist, app is not running")
		http.Error(w, "AppInstanceId does not exist, app is not running", http.StatusBadRequest)
		return
		}

		jsonResponse, _ := rc.JSONGetEntry(baseKey+":subscriptions:"+subIdParamStr, ".")
		if jsonResponse == "" {
		w.WriteHeader(http.StatusNotFound)
		return
		}

		err = rc.JSONDelEntry(baseKey+":subscriptions"+":"+subIdParamStr, ".")
		deregisterAppTermination(subIdParamStr, false)
		if err != nil {
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
		}

		w.WriteHeader(http.StatusNoContent)
		}

		func applicationsSubscriptionsGET(w http.ResponseWriter, r *http.Request) {
		w.Header().Set("Content-Type", "application/json; charset=UTF-8")

		vars := mux.Vars(r)
		appInstanceId := vars["appInstanceId"]

		//check if entry exist for the application in the DB
		key := appEnablementBaseKey + ":apps:" + appInstanceId
		fields, err := rc.GetEntry(key)
		if err != nil \|\| len(fields) == 0 {
		log.Error("AppInstanceId does not exist, app is not running")
		http.Error(w, "AppInstanceId does not exist, app is not running", http.StatusBadRequest)
		return
		}

		subscriptionLinkList := new(MecAppSuptApiSubscriptionLinkList)

		link := new(MecAppSuptApiSubscriptionLinkListLinks)
		self := new(LinkType)
		self.Href = hostUrl.String() + basePath + "applications/" + appInstanceId + "/subscriptions"

		link.Self = self
		subscriptionLinkList.Links = link

		//loop through all different types of subscription

		mutex.Lock()
		defer mutex.Unlock()

		//loop through appTerm map
		for _, appTermSubscription := range appTerminationNotificationSubscriptionMap {
		if appTermSubscription != nil {
		var subscription MecAppSuptApiSubscriptionLinkListSubscription
		subscription.Href = appTermSubscription.Links.Self.Href
		//in v2.1.1 it should be SubscriptionType, but spec is expecting "rel" as per v1.1.1
		subscription.Rel = APP_TERMINATION_NOTIFICATION_SUBSCRIPTION_TYPE
		subscriptionLinkList.Links.Subscriptions = append(subscriptionLinkList.Links.Subscriptions, subscription)
		}
		}

		jsonResponse, err := json.Marshal(subscriptionLinkList)
		if err != nil {
		log.Error(err.Error())
		http.Error(w, err.Error(), http.StatusInternalServerError)
		return
		}
		w.WriteHeader(http.StatusOK)
		fmt.Fprintf(w, string(jsonResponse))
		}

go-apps/meep-app-enablement/server/app-support/convert.go

0 → 100644

+34 −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 server

		import (
		"encoding/json"

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

		func convertAppTerminationNotificationSubscriptionToJson(appTerm *AppTerminationNotificationSubscription) string {

		jsonInfo, err := json.Marshal(*appTerm)
		if err != nil {
		log.Error(err.Error())
		return ""
		}

		return string(jsonInfo)
		}