X-Git-Url: https://gerrit.o-ran-sc.org/r/gitweb?a=blobdiff_plain;f=pkg%2Fxapp%2Frestapi.go;h=205f5f6f8a6c50120ba29d90bdf2a5548b4f8cdb;hb=40bc000e6cafe3a7eea32e4361268574050c12c4;hp=291a874d493f15ddfbd3ce1e45344f7dd7cd98fc;hpb=6e075ceec8c477237f7d0c6d987837a8798dd4ec;p=ric-plt%2Fxapp-frame.git diff --git a/pkg/xapp/restapi.go b/pkg/xapp/restapi.go old mode 100644 new mode 100755 index 291a874..205f5f6 --- a/pkg/xapp/restapi.go +++ b/pkg/xapp/restapi.go @@ -21,13 +21,26 @@ package xapp import ( "encoding/json" - "github.com/gorilla/mux" + "fmt" + "io/ioutil" "net/http" + "os" + + "github.com/gorilla/mux" + "github.com/spf13/viper" + + "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 +59,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 +68,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 +77,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 +103,123 @@ func (r *Router) CheckStatus() (status bool) { return } +func (r *Router) GetSymptomDataParams(w http.ResponseWriter, req *http.Request) SymptomDataParams { + Logger.Info("GetSymptomDataParams ...") + + params := SymptomDataParams{} + queryParams := req.URL.Query() + + Logger.Info("GetSymptomDataParams: %+v", queryParams) + + for p := range queryParams { + if p == "timeout" { + fmt.Sscanf(p, "%d", ¶ms.Timeout) + } + if p == "fromtime" { + fmt.Sscanf(p, "%d", ¶ms.FromTime) + } + if p == "totime" { + fmt.Sscanf(p, "%d", ¶ms.ToTime) + } + } + return params +} + +func (r *Router) CollectDefaultSymptomData(fileName string, data interface{}) string { + baseDir := Config.GetString("controls.symptomdata.baseDir") + if baseDir == "" { + baseDir = "/tmp/xapp/" + } + + if err := Util.CreateDir(baseDir); err != nil { + Logger.Error("CreateDir failed: %v", err) + return "" + } + + if metrics, err := r.GetLocalMetrics(GetPortData("http").Port); err == nil { + if err := Util.WriteToFile(baseDir+"metrics.json", metrics); err != nil { + Logger.Error("writeToFile failed for metrics.json: %v", err) + } + } + + if data != nil { + if b, err := json.MarshalIndent(data, "", " "); err == nil { + Util.WriteToFile(baseDir+fileName, string(b)) + } + } + + rtPath := os.Getenv("RMR_STASH_RT") + if rtPath == "" { + return baseDir + } + + input, err := ioutil.ReadFile(rtPath) + if err != nil { + Logger.Error("ioutil.ReadFile failed: %v", err) + return baseDir + } + + Util.WriteToFile(baseDir+"rttable.txt", string(input)) + return baseDir +} + +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.MarshalIndent(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 (r *Router) GetLocalMetrics(port int) (string, error) { + resp, err := http.Get(fmt.Sprintf("http://localhost:%d/ric/v1/metrics", port)) + if err != nil { + return "", err + } + defer resp.Body.Close() + + metrics, err := ioutil.ReadAll(resp.Body) + if err != nil { + return "", err + } + + return string(metrics), nil +} + +func IsHealthProbeReady() bool { + return healthReady +} + func readyHandler(w http.ResponseWriter, r *http.Request) { + healthReady = true respondWithJSON(w, http.StatusOK, nil) } @@ -92,6 +227,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 +258,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 +}