Add utility module

[ric-plt/xapp-frame.git] / pkg / xapp / restapi.go

diff --git a/pkg/xapp/restapi.go b/pkg/xapp/restapi.go
index 291a874..40ad8d2 100755 (executable)
--- a/pkg/xapp/restapi.go
+++ b/pkg/xapp/restapi.go
@@ -21,13 +21,25 @@ package xapp
 
 import (
        "encoding/json"
+       "fmt"
        "github.com/gorilla/mux"
+       "github.com/spf13/viper"
+       "io/ioutil"
        "net/http"
+       "os"
+
+       "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
 )
 
 const (
-       ReadyURL = "/ric/v1/health/ready"
-       AliveURL = "/ric/v1/health/alive"
+       ReadyURL     = "/ric/v1/health/ready"
+       AliveURL     = "/ric/v1/health/alive"
+       ConfigURL    = "/ric/v1/cm/{name}"
+       AppConfigURL = "/ric/v1/config"
+)
+
+var (
+       healthReady bool
 )
 
 type StatusCb func() bool
@@ -46,6 +58,8 @@ func NewRouter() *Router {
        // Inject default routes for health probes
        r.InjectRoute(ReadyURL, readyHandler, "GET")
        r.InjectRoute(AliveURL, aliveHandler, "GET")
+       r.InjectRoute(ConfigURL, configHandler, "POST")
+       r.InjectRoute(AppConfigURL, appconfigHandler, "GET")
 
        return r
 }
@@ -53,7 +67,7 @@ func NewRouter() *Router {
 func (r *Router) serviceChecker(inner http.HandlerFunc) http.HandlerFunc {
        return http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
                Logger.Info("restapi: method=%s url=%s", req.Method, req.URL.RequestURI())
-               if req.URL.RequestURI() == AliveURL || (Rmr.IsReady() && r.CheckStatus()) {
+               if req.URL.RequestURI() == AliveURL || r.CheckStatus() {
                        inner.ServeHTTP(w, req)
                } else {
                        respondWithJSON(w, http.StatusServiceUnavailable, nil)
@@ -62,11 +76,15 @@ func (r *Router) serviceChecker(inner http.HandlerFunc) http.HandlerFunc {
 }
 
 func (r *Router) InjectRoute(url string, handler http.HandlerFunc, method string) *mux.Route {
-       return r.router.HandleFunc(url, r.serviceChecker(handler)).Methods(method)
+       return r.router.Path(url).HandlerFunc(r.serviceChecker(handler)).Methods(method)
 }
 
 func (r *Router) InjectQueryRoute(url string, h http.HandlerFunc, m string, q ...string) *mux.Route {
-       return r.router.HandleFunc(url, r.serviceChecker(h)).Methods(m).Queries(q...)
+       return r.router.Path(url).HandlerFunc(r.serviceChecker(h)).Methods(m).Queries(q...)
+}
+
+func (r *Router) InjectRoutePrefix(prefix string, handler http.HandlerFunc) *mux.Route {
+       return r.router.PathPrefix(prefix).HandlerFunc(r.serviceChecker(handler))
 }
 
 func (r *Router) InjectStatusCb(f StatusCb) {
@@ -84,7 +102,66 @@ func (r *Router) CheckStatus() (status bool) {
        return
 }
 
+func (r *Router) GetSymptomDataParams(w http.ResponseWriter, req *http.Request) SymptomDataParams {
+       params := SymptomDataParams{}
+       queryParams := req.URL.Query()
+
+       for p := range queryParams {
+               if p == "timeout" {
+                       fmt.Sscanf(p, "%d", &params.Timeout)
+               }
+               if p == "fromtime" {
+                       fmt.Sscanf(p, "%d", &params.FromTime)
+               }
+               if p == "totime" {
+                       fmt.Sscanf(p, "%d", &params.ToTime)
+               }
+       }
+       return params
+}
+
+func (r *Router) SendSymptomDataJson(w http.ResponseWriter, req *http.Request, data interface{}, n string) {
+       w.Header().Set("Content-Type", "application/json")
+       w.Header().Set("Content-Disposition", "attachment; filename="+n)
+       w.WriteHeader(http.StatusOK)
+       if data != nil {
+               response, _ := json.Marshal(data)
+               w.Write(response)
+       }
+}
+
+func (r *Router) SendSymptomDataFile(w http.ResponseWriter, req *http.Request, baseDir, zipFile string) {
+       // Compress and reply with attachment
+       tmpFile, err := ioutil.TempFile("", "symptom")
+       if err != nil {
+               r.SendSymptomDataError(w, req, "Failed to create a tmp file: "+err.Error())
+               return
+       }
+       defer os.Remove(tmpFile.Name())
+
+       var fileList []string
+       fileList = Util.FetchFiles(baseDir, fileList)
+       err = Util.ZipFiles(tmpFile, baseDir, fileList)
+       if err != nil {
+               r.SendSymptomDataError(w, req, "Failed to zip the files: "+err.Error())
+               return
+       }
+
+       w.Header().Set("Content-Disposition", "attachment; filename="+zipFile)
+       http.ServeFile(w, req, tmpFile.Name())
+}
+
+func (r *Router) SendSymptomDataError(w http.ResponseWriter, req *http.Request, message string) {
+       w.Header().Set("Content-Disposition", "attachment; filename=error_status.txt")
+       http.Error(w, message, http.StatusInternalServerError)
+}
+
+func IsHealthProbeReady() bool {
+       return healthReady
+}
+
 func readyHandler(w http.ResponseWriter, r *http.Request) {
+       healthReady = true
        respondWithJSON(w, http.StatusOK, nil)
 }
 
@@ -92,6 +169,29 @@ func aliveHandler(w http.ResponseWriter, r *http.Request) {
        respondWithJSON(w, http.StatusOK, nil)
 }
 
+func configHandler(w http.ResponseWriter, r *http.Request) {
+       xappName := mux.Vars(r)["name"]
+       if xappName == "" || r.Body == nil {
+               respondWithJSON(w, http.StatusBadRequest, nil)
+               return
+       }
+       defer r.Body.Close()
+
+       body, err := ioutil.ReadAll(r.Body)
+       if err != nil {
+               Logger.Error("ioutil.ReadAll failed: %v", err)
+               respondWithJSON(w, http.StatusInternalServerError, nil)
+               return
+       }
+
+       if err := PublishConfigChange(xappName, string(body)); err != nil {
+               respondWithJSON(w, http.StatusInternalServerError, nil)
+               return
+       }
+
+       respondWithJSON(w, http.StatusOK, nil)
+}
+
 func respondWithJSON(w http.ResponseWriter, code int, payload interface{}) {
        w.Header().Set("Content-Type", "application/json")
        w.WriteHeader(code)
@@ -100,3 +200,36 @@ func respondWithJSON(w http.ResponseWriter, code int, payload interface{}) {
                w.Write(response)
        }
 }
+
+func appconfigHandler(w http.ResponseWriter, r *http.Request) {
+
+       Logger.Info("Inside appconfigHandler")
+
+       var appconfig models.XappConfigList
+       var metadata models.ConfigMetadata
+       var xappconfig models.XAppConfig
+       name := viper.GetString("name")
+       configtype := "json"
+       metadata.XappName = &name
+       metadata.ConfigType = &configtype
+
+       configFile, err := os.Open("/opt/ric/config/config-file.json")
+       if err != nil {
+               Logger.Error("Cannot open config file: %v", err)
+               respondWithJSON(w, http.StatusInternalServerError, nil)
+               // return nil,errors.New("Could Not parse the config file")
+       }
+
+       body, err := ioutil.ReadAll(configFile)
+
+       defer configFile.Close()
+
+       xappconfig.Metadata = &metadata
+       xappconfig.Config = string(body)
+
+       appconfig = append(appconfig, &xappconfig)
+
+       respondWithJSON(w, http.StatusOK, appconfig)
+
+       //return appconfig,nil
+}