package xapp
import (
+ "bytes"
"encoding/json"
"fmt"
"io/ioutil"
"net/http"
"os"
+ "path"
+ "strings"
+ "time"
+ "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
"github.com/gorilla/mux"
+ "github.com/prometheus/client_golang/prometheus"
+ "github.com/prometheus/common/expfmt"
"github.com/spf13/viper"
-
- "gerrit.o-ran-sc.org/r/ric-plt/xapp-frame/pkg/models"
)
const (
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())
+ Logger.Debug("restapi: method=%s url=%s", req.Method, req.URL.RequestURI())
if req.URL.RequestURI() == AliveURL || r.CheckStatus() {
inner.ServeHTTP(w, req)
} else {
params := SymptomDataParams{}
queryParams := req.URL.Query()
+ Logger.Info("GetSymptomDataParams: %+v", queryParams)
+
for p := range queryParams {
if p == "timeout" {
fmt.Sscanf(p, "%d", ¶ms.Timeout)
return ""
}
- if metrics, err := r.GetLocalMetrics(GetPortData("http").Port); err == nil {
+ //
+ // Collect some general information into one file
+ //
+ var lines []string
+
+ // uptime
+ d := XappUpTime()
+ h := d / time.Hour
+ d -= h * time.Hour
+ m := d / time.Minute
+ d -= m * time.Minute
+ s := d / time.Second
+ lines = append(lines, fmt.Sprintf("uptime: %02d:%02d:%02d", h, m, s))
+
+ Util.WriteToFile(baseDir+"information.txt", strings.Join(lines, "\n"))
+
+ //
+ // Collect metrics
+ //
+ if metrics, err := r.GetLocalMetrics(); 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))
- }
+ //
+ // Collect currently used config file
+ //
+ cfile := viper.ConfigFileUsed()
+ input, err := ioutil.ReadFile(cfile)
+ if err == nil {
+ Util.WriteToFile(baseDir+path.Base(cfile), string(input))
+ } else {
+ Logger.Error("ioutil.ReadFile failed: %v", err)
}
+ //
+ // Collect environment
+ //
+ Util.WriteToFile(baseDir+"environment.txt", strings.Join(os.Environ(), "\n"))
+
+ //
+ // Collect RMR rt table
+ //
rtPath := os.Getenv("RMR_STASH_RT")
- if rtPath == "" {
- return baseDir
+ if rtPath != "" {
+ input, err = ioutil.ReadFile(rtPath)
+ if err == nil {
+ Util.WriteToFile(baseDir+"rttable.txt", string(input))
+ } else {
+ Logger.Error("ioutil.ReadFile failed: %v", err)
+ }
}
- input, err := ioutil.ReadFile(rtPath)
- if err != nil {
- Logger.Error("ioutil.ReadFile failed: %v", err)
- return baseDir
+ //
+ // Put data that was provided as argument
+ //
+ if data != nil {
+ if b, err := json.MarshalIndent(data, "", " "); err == nil {
+ Util.WriteToFile(baseDir+fileName, string(b))
+ }
}
- Util.WriteToFile(baseDir+"rttable.txt", string(input))
return baseDir
}
}
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)
+ tmpFileName, err := Util.ZipFilesToTmpFile(baseDir, "symptom", fileList)
if err != nil {
- r.SendSymptomDataError(w, req, "Failed to zip the files: "+err.Error())
+ r.SendSymptomDataError(w, req, err.Error())
return
}
+ defer os.Remove(tmpFileName)
w.Header().Set("Content-Disposition", "attachment; filename="+zipFile)
- http.ServeFile(w, req, tmpFile.Name())
+ http.ServeFile(w, req, tmpFileName)
}
func (r *Router) SendSymptomDataError(w http.ResponseWriter, req *http.Request, message string) {
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))
+func (r *Router) GetLocalMetrics() (string, error) {
+ buf := &bytes.Buffer{}
+ enc := expfmt.NewEncoder(buf, expfmt.FmtText)
+ vals, err := prometheus.DefaultGatherer.Gather()
if err != nil {
- return "", err
+ return fmt.Sprintf("#metrics get error: %s\n", err.Error()), fmt.Errorf("Could get local metrics %w", err)
}
- defer resp.Body.Close()
-
- metrics, err := ioutil.ReadAll(resp.Body)
- if err != nil {
- return "", err
+ for _, val := range vals {
+ err = enc.Encode(val)
+ if err != nil {
+ buf.WriteString(fmt.Sprintf("#metrics enc err:%s\n", err.Error()))
+ }
}
-
- return string(metrics), nil
+ return string(buf.Bytes()), nil
}
+//Resource.InjectRoute(url, metricsHandler, "GET")
+//func metricsHandler(w http.ResponseWriter, r *http.Request) {
+// w.Header().Set("Content-Type", "text/plain")
+// w.WriteHeader(http.StatusOK)
+// metrics, _ := Resource.GetLocalMetrics()
+// w.Write([]byte(metrics))
+//}
+
func IsHealthProbeReady() bool {
return healthReady
}
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)
+ // Read config-files
+ cfiles := []string{viper.ConfigFileUsed(), "/opt/ric/config/config-file.json"}
+
+ var err error
+ var configFile *os.File
+ for _, cfile := range cfiles {
+ configFile, err = os.Open(cfile)
+ if err != nil {
+ configFile = nil
+ Logger.Error("Cannot open config file: %s err: %v", cfile, err)
+ }
+ }
+ if err != nil || configFile == nil {
+ Logger.Error("Cannot open any of listed config files: %v", cfiles)
respondWithJSON(w, http.StatusInternalServerError, nil)
- // return nil,errors.New("Could Not parse the config file")
+ return
}
body, err := ioutil.ReadAll(configFile)
-
defer configFile.Close()
xappconfig.Metadata = &metadata
appconfig = append(appconfig, &xappconfig)
respondWithJSON(w, http.StatusOK, appconfig)
-
- //return appconfig,nil
}
Code Review / ric-plt / xapp-frame.git / blobdiff