func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("use -c to specify configuration file")
}
if !file.IsExist(cfg) {
log.Fatalln("config file:", cfg, "is not existent")
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file:", cfg, "fail:", err)
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file:", cfg, "fail:", err)
}
if !file.IsExist(c.ExternalNodes) {
log.Printf("WARN: the external_nodes file [%s] is not exist!", c.ExternalNodes)
c.ExternalNodes = ""
}
configLock.Lock()
defer configLock.Unlock()
config = &c
log.Println("read config file:", cfg, "successfully")
}
func StopAgentOf(agentName, newVersion string) error {
agentDir := path.Join(g.SelfDir, agentName)
versionFile := path.Join(agentDir, ".version")
if !file.IsExist(versionFile) {
log.Printf("WARN: %s is nonexistent", versionFile)
return nil
}
version, err := file.ToTrimString(versionFile)
if err != nil {
log.Printf("WARN: read %s fail %s", version, err)
return nil
}
if version == newVersion {
// do nothing
return nil
}
versionDir := path.Join(agentDir, version)
if !file.IsExist(versionDir) {
log.Printf("WARN: %s nonexistent", versionDir)
return nil
}
return ControlStopIn(versionDir)
}
func configPluginRoutes() {
http.HandleFunc("/plugin/update", func(w http.ResponseWriter, r *http.Request) {
if !g.Config().Plugin.Enabled {
w.Write([]byte("plugin not enabled"))
return
}
dir := g.Config().Plugin.Dir
parentDir := file.Dir(dir)
file.InsureDir(parentDir)
if file.IsExist(dir) {
// git pull
cmd := exec.Command("git", "pull")
cmd.Dir = dir
err := cmd.Run()
if err != nil {
w.Write([]byte(fmt.Sprintf("git pull in dir:%s fail. error: %s", dir, err)))
return
}
} else {
// git clone
cmd := exec.Command("git", "clone", g.Config().Plugin.Git, file.Basename(dir))
cmd.Dir = parentDir
err := cmd.Run()
if err != nil {
w.Write([]byte(fmt.Sprintf("git clone in dir:%s fail. error: %s", parentDir, err)))
return
}
}
w.Write([]byte("success"))
})
http.HandleFunc("/plugin/reset", func(w http.ResponseWriter, r *http.Request) {
if !g.Config().Plugin.Enabled {
w.Write([]byte("plugin not enabled"))
return
}
dir := g.Config().Plugin.Dir
if file.IsExist(dir) {
cmd := exec.Command("git", "reset", "--hard")
cmd.Dir = dir
err := cmd.Run()
if err != nil {
w.Write([]byte(fmt.Sprintf("git reset --hard in dir:%s fail. error: %s", dir, err)))
return
}
}
w.Write([]byte("success"))
})
http.HandleFunc("/plugins", func(w http.ResponseWriter, r *http.Request) {
//TODO: not thread safe
RenderDataJson(w, plugins.Plugins)
})
}
func AllProcs() (ps []*Proc, err error) {
var dirs []string
dirs, err = file.DirsUnder("/proc")
if err != nil {
return
}
size := len(dirs)
if size == 0 {
return
}
for i := 0; i < size; i++ {
pid, e := strconv.Atoi(dirs[i])
if e != nil {
continue
}
statusFile := fmt.Sprintf("/proc/%d/status", pid)
cmdlineFile := fmt.Sprintf("/proc/%d/cmdline", pid)
if !file.IsExist(statusFile) || !file.IsExist(cmdlineFile) {
continue
}
name, e := ReadName(statusFile)
if e != nil {
continue
}
cmdlineBytes, e := file.ToBytes(cmdlineFile)
if e != nil {
continue
}
cmdlineBytesLen := len(cmdlineBytes)
if cmdlineBytesLen == 0 {
continue
}
noNut := make([]byte, 0, cmdlineBytesLen)
for j := 0; j < cmdlineBytesLen; j++ {
if cmdlineBytes[j] != 0 {
noNut = append(noNut, cmdlineBytes[j])
}
}
p := Proc{Pid: pid, Name: name, Cmdline: string(noNut)}
ps = append(ps, &p)
}
return
}
func BuildHeartbeatRequest(hostname string, agentDirs []string) model.HeartbeatRequest {
req := model.HeartbeatRequest{Hostname: hostname}
realAgents := []*model.RealAgent{}
now := time.Now().Unix()
for _, agentDir := range agentDirs {
// 如果目录下没有.version，我们认为这根本不是一个agent
versionFile := path.Join(g.SelfDir, agentDir, ".version")
if !f.IsExist(versionFile) {
continue
}
version, err := f.ToTrimString(versionFile)
if err != nil {
log.Printf("read %s/.version fail: %v", agentDir, err)
continue
}
controlFile := path.Join(g.SelfDir, agentDir, version, "control")
if !f.IsExist(controlFile) {
log.Printf("%s is nonexistent", controlFile)
continue
}
cmd := exec.Command("./control", "status")
cmd.Dir = path.Join(g.SelfDir, agentDir, version)
bs, err := cmd.CombinedOutput()
status := ""
if err != nil {
status = fmt.Sprintf("exec `./control status` fail: %s", err)
} else {
status = strings.TrimSpace(string(bs))
}
realAgent := &model.RealAgent{
Name: agentDir,
Version: version,
Status: status,
Timestamp: now,
}
realAgents = append(realAgents, realAgent)
}
req.RealAgents = realAgents
return req
}
func FilesReady(da *model.DesiredAgent) bool {
if !file.IsExist(da.Md5Filepath) {
return false
}
if !file.IsExist(da.TarballFilepath) {
return false
}
if !file.IsExist(da.ControlFilepath) {
return false
}
return utils.Md5sumCheck(da.AgentVersionDir, da.Md5Filename)
}
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("use -c to specify one config file")
}
if !file.IsExist(cfg) {
log.Fatalln("config file:", cfg, "not exist")
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file:", cfg, "failed:", err)
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file:", cfg, "failed:", err)
}
// check
if !checkConfig(c) {
log.Fatalln("check config file:", cfg, "failed")
}
configLock.Lock()
defer configLock.Unlock()
config = &c
log.Println("g.ParseConfig ok, file ", cfg)
}
func StopDesiredAgent(da *model.DesiredAgent) {
if !file.IsExist(da.ControlFilepath) {
return
}
ControlStopIn(da.AgentVersionDir)
}
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("use -c to specify configuration file")
}
if !file.IsExist(cfg) {
log.Fatalln("config file:", cfg, "is not existent. maybe you need `mv cfg.example.json cfg.json`")
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file:", cfg, "fail:", err)
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file:", cfg, "fail:", err)
}
// split cluster config
c.Judge.Cluster2 = formatClusterItems(c.Judge.Cluster)
c.Graph.Cluster2 = formatClusterItems(c.Graph.Cluster)
c.Graph.ClusterMigrating2 = formatClusterItems(c.Graph.ClusterMigrating)
configLock.Lock()
defer configLock.Unlock()
config = &c
log.Println("g.ParseConfig ok, file ", cfg)
}
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("config file not specified: use -c $filename")
}
if !file.IsExist(cfg) {
log.Fatalln("config file specified not found:", cfg)
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file", cfg, "error:", err.Error())
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file", cfg, "error:", err.Error())
}
if c.Migrate.Enabled && len(c.Migrate.Cluster) == 0 {
c.Migrate.Enabled = false
}
// set config
atomic.StorePointer(&ptr, unsafe.Pointer(&c))
log.Println("g.ParseConfig ok, file", cfg)
}
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("use -c to specify configuration file")
}
if !file.IsExist(cfg) {
log.Fatalln("config file:", cfg, "is not existent. maybe you need `mv cfg.example.json cfg.json`")
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file:", cfg, "fail:", err)
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file:", cfg, "fail:", err)
}
lock.Lock()
defer lock.Unlock()
config = &c
log.Println("read config file:", cfg, "successfully")
}
// Reference to Open-Falcon's ParseConfig()
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("Config file not specified: use -c $filename")
}
if !file.IsExist(cfg) {
log.Fatalln("Config file specified not found:", cfg)
}
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("Read config file", cfg, "error:", err.Error())
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("Parse config file", cfg, "error:", err.Error())
}
// set config
configLock.Lock()
defer configLock.Unlock()
Config = &c
printDebug(2, "ParseConfig:", cfg, "[DONE.]")
}
func (t *RingBackend) LoadAddrs(f string) error {
if !file.IsExist(f) {
return errors.New("backends file is not exist")
}
file_content, err := file.ToString(f)
if err != nil {
return err
}
file_content = strings.Trim(file_content, " \n\t")
lines := strings.Split(file_content, "\n")
if len(lines) == 0 {
return errors.New("empty backends")
}
tmp_addrs := make(map[string][]string)
for _, line := range lines {
fields := strings.Fields(line)
size := len(fields)
if size < 2 {
logger.Warn("invalid backend %s", line)
continue
}
name := fields[0]
addr := fields[1:size]
tmp_addrs[name] = addr
}
t.Lock()
defer t.Unlock()
t.Addrs = tmp_addrs
return nil
}
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("use -c to specify configuration file")
}
if !file.IsExist(cfg) {
log.Fatalln("config file:", cfg, "is not existent")
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file:", cfg, "fail:", err)
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file:", cfg, "fail:", err)
}
configLock.Lock()
defer configLock.Unlock()
config = &c
logger.SetLevel(config.LogLevel)
log.Println("read config file:", cfg, "successfully")
}
func ParseConfig(cfg string) error {
if cfg == "" {
return fmt.Errorf("use -c to specify configuration file")
}
if !file.IsExist(cfg) {
return fmt.Errorf("config file %s is nonexistent", cfg)
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
return fmt.Errorf("read config file %s fail %s", cfg, err)
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
return fmt.Errorf("parse config file %s fail %s", cfg, err)
}
configLock.Lock()
defer configLock.Unlock()
config = &c
log.Println("read config file:", cfg, "successfully")
return nil
}
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("config file not specified: use -c $filename")
}
if !file.IsExist(cfg) {
log.Fatalln("config file specified not found:", cfg)
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file", cfg, "error:", err.Error())
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file", cfg, "error:", err.Error())
}
SetConfig(&c)
logger.InitLogger(c.Debug)
log.Println("g.ParseConfig ok, file", cfg)
}
func ParseConfig(cfg string) {
if cfg == "" {
log.Fatalln("config file not specified: use -c $filename")
}
if !file.IsExist(cfg) {
log.Fatalln("config file specified not found:", cfg)
}
ConfigFile = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatalln("read config file", cfg, "error:", err.Error())
}
var c GlobalConfig
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("parse config file", cfg, "error:", err.Error())
}
// set config
configLock.Lock()
defer configLock.Unlock()
config = &c
log.Println("g.ParseConfig ok, file", cfg)
}
func loadJSONConfig(cfgFile string) {
cfgFile = filepath.Clean(cfgFile)
cfgPath := getCfgAbsPath(cfgFile)
if !file.IsExist(cfgPath) {
log.Fatalln("Configuration file [", cfgFile, "] doesn't exist")
}
configContent, err := file.ToTrimString(cfgPath)
if err != nil {
log.Fatalln("Reading configuration file [", cfgFile, "] failed:", err)
}
var c JSONConfigFile
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Fatalln("Parsing configuration file [", cfgFile, "] failed:", err)
}
jsonCfgLock.Lock()
defer jsonCfgLock.Unlock()
jsonConfig = &c
log.Println("Reading configuration file [", cfgFile, "] succeeded")
}
func configPageRoutes() {
http.HandleFunc("/", func(w http.ResponseWriter, r *http.Request) {
if strings.HasSuffix(r.URL.Path, "/") {
if !file.IsExist(filepath.Join(g.Root, "/public", r.URL.Path, "index.html")) {
http.NotFound(w, r)
return
}
}
http.FileServer(http.Dir(filepath.Join(g.Root, "/public"))).ServeHTTP(w, r)
})
}
func CheckFileOrDirExists(username, fp, fileType string) bool {
if CurrentUser == username {
return file.IsExist(fp)
} else {
cmd := BuildCommand(username, "sh", "check_file.sh", fileType, fp)
cmd.Dir = file.SelfDir()
strOut, err := ExecuteCommandWithOutput(cmd)
if nil != err {
logger.Errorln("check dir exists", strOut, err)
return false
}
result, _ := strconv.ParseBool(strings.Replace(strOut, "\n", "", -1))
return result
}
return false
}
func ParseNodeConfig(cfg string) {
if cfg == "" {
log.Println("请配置nodepath")
cfg = "node.file"
}
if !file.IsExist(cfg) {
log.Println("node file:", cfg, "is not existent.`")
return
}
NodeFilePath = cfg
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Println("read node file:", cfg, "fail:", err)
return
}
c := Nodefile{}
err = json.Unmarshal([]byte(configContent), &c)
if err != nil {
log.Println("parse node file:", cfg, "fail:", err)
return
}
nm := make(map[string]string)
for _, node := range c.Data {
if len(node.Nodeout_ports) == 0 {
continue
}
//fmt.Printf("%v\n", node)
//fmt.Printf("%#v\n", len(node.Nodeout_ports))
for _, port := range node.Nodeout_ports {
nm[node.Manage_ip+port.Name] = node.Node.ID
//fmt.Printf("%s%s:%s\n", node.Manage_ip, port.Name, node.Node.ID)
}
}
lock.Lock()
defer lock.Unlock()
nodemap = &nm
log.Println("read node file:", cfg, "successfully")
}
// key: sys/ntp/60_ntp.py
func ListPlugins(relativePath string) map[string]*Plugin {
ret := make(map[string]*Plugin)
if relativePath == "" {
return ret
}
dir := filepath.Join(g.Config().Plugin.Dir, relativePath)
if !file.IsExist(dir) || file.IsFile(dir) {
return ret
}
fs, err := ioutil.ReadDir(dir)
if err != nil {
log.Println("can not list files under", dir)
return ret
}
for _, f := range fs {
if f.IsDir() {
continue
}
filename := f.Name()
arr := strings.Split(filename, "_")
if len(arr) < 2 {
continue
}
// filename should be: $cycle_$xx
var cycle int
cycle, err = strconv.Atoi(arr[0])
if err != nil {
continue
}
fpath := filepath.Join(relativePath, filename)
plugin := &Plugin{FilePath: fpath, MTime: f.ModTime().Unix(), Cycle: cycle}
ret[fpath] = plugin
}
return ret
}
func InitFlows() {
cfg := revel.BasePath + "/conf/flow.json"
if !file.IsExist(cfg) {
file, _ := os.Getwd()
revel.ERROR.Fatalln("config file:", cfg, "is not existent. getcwd", file)
}
configContent, err := file.ToTrimString(cfg)
if err != nil {
revel.ERROR.Fatalln("read config file:", cfg, "fail:", err)
}
err = json.Unmarshal([]byte(configContent), &Flows)
if err != nil {
revel.ERROR.Fatalln("parse config file:", cfg, "fail:", err)
} else {
revel.INFO.Println("InitFlows ok")
}
}
/**
* @function name: func parseConfig()
* @description: This function parses config file cfg.json.
* @related issues: OWL-201, OWL-115, OWL-085
* @param: void
* @return: void
* @author: Don Hsieh
* @since: 09/14/2015
* @last modified: 12/10/2015
* @called by: func Register(r *macaron.Macaron)
*/
func parseConfig() {
cfg := "cfg.json"
if !file.IsExist(cfg) {
log.Fatal(4, "config file:", cfg, "is not existent. maybe you need `mv cfg.example.json cfg.json`")
}
configContent, err := file.ToTrimString(cfg)
if err != nil {
log.Fatal(4, "read config file:", cfg, "fail:", err)
}
var configGlobal GlobalConfig
err = json.Unmarshal([]byte(configContent), &configGlobal)
if err != nil {
log.Fatal(4, "parse config file:", cfg, "fail:", err)
return
}
lock.Lock()
defer lock.Unlock()
ConfigOpenFalcon = &configGlobal
}
func GetCurrPluginVersion() string {
if !Config().Plugin.Enabled {
return "plugin not enabled"
}
pluginDir := Config().Plugin.Dir
if !file.IsExist(pluginDir) {
return "plugin dir not existent"
}
cmd := exec.Command("git", "rev-parse", "HEAD")
cmd.Dir = pluginDir
var out bytes.Buffer
cmd.Stdout = &out
err := cmd.Run()
if err != nil {
return fmt.Sprintf("Error:%s", err.Error())
}
return strings.TrimSpace(out.String())
}
// 初始化配置文件
func Parse(path string) {
if !file.IsExist(path) {
panic("Parse - parse file not exists")
}
buf, err := ioutil.ReadFile(path)
if err != nil {
log.Fatalln("Parse - read file error ", err.Error())
}
ConfigFile = path
var c GlobalConfig
err = json.Unmarshal(buf, &c)
if err != nil {
log.Fatalln("Parse - Unmarshal ", ConfigFile, " failed, error :", err)
}
configLock.Lock()
defer configLock.Unlock()
config = &c
log.Println("Parse - parse config file success - ", ConfigFile)
}
func ControlStopIn(workdir string) error {
if !file.IsExist(workdir) {
return nil
}
out, err := ControlStatus(workdir)
if err == nil && strings.Contains(out, "stoped") {
return nil
}
_, err = ControlStop(workdir)
if err != nil {
return err
}
time.Sleep(time.Second * 3)
out, err = ControlStatus(workdir)
if err == nil && strings.Contains(out, "stoped") {
return nil
}
return err
}
func ListDiskStats() ([]*DiskStats, error) {
proc_diskstats := "/proc/diskstats"
if !file.IsExist(proc_diskstats) {
return nil, fmt.Errorf("%s not exists", proc_diskstats)
}
contents, err := ioutil.ReadFile(proc_diskstats)
if err != nil {
return nil, err
}
ret := make([]*DiskStats, 0)
reader := bufio.NewReader(bytes.NewBuffer(contents))
for {
line, err := file.ReadLine(reader)
if err == io.EOF {
err = nil
break
} else if err != nil {
return nil, err
}
fields := strings.Fields(string(line))
// shortcut the deduper and just skip disks that
// haven't done a single read. This elimiates a bunch
// of loopback, ramdisk, and cdrom devices but still
// lets us report on the rare case that we actually use
// a ramdisk.
if fields[3] == "0" {
continue
}
size := len(fields)
// kernel version too low
if size != 14 {
continue
}
item := &DiskStats{}
if item.Major, err = strconv.Atoi(fields[0]); err != nil {
return nil, err
}
if item.Minor, err = strconv.Atoi(fields[1]); err != nil {
return nil, err
}
item.Device = fields[2]
if item.ReadRequests, err = strconv.ParseUint(fields[3], 10, 64); err != nil {
return nil, err
}
if item.ReadMerged, err = strconv.ParseUint(fields[4], 10, 64); err != nil {
return nil, err
}
if item.ReadSectors, err = strconv.ParseUint(fields[5], 10, 64); err != nil {
return nil, err
}
if item.MsecRead, err = strconv.ParseUint(fields[6], 10, 64); err != nil {
return nil, err
}
if item.WriteRequests, err = strconv.ParseUint(fields[7], 10, 64); err != nil {
return nil, err
}
if item.WriteMerged, err = strconv.ParseUint(fields[8], 10, 64); err != nil {
return nil, err
}
if item.WriteSectors, err = strconv.ParseUint(fields[9], 10, 64); err != nil {
return nil, err
}
if item.MsecWrite, err = strconv.ParseUint(fields[10], 10, 64); err != nil {
return nil, err
}
if item.IosInProgress, err = strconv.ParseUint(fields[11], 10, 64); err != nil {
return nil, err
}
if item.MsecTotal, err = strconv.ParseUint(fields[12], 10, 64); err != nil {
return nil, err
}
if item.MsecWeightedTotal, err = strconv.ParseUint(fields[13], 10, 64); err != nil {
return nil, err
}
item.TS = time.Now()
ret = append(ret, item)
}
return ret, nil
}
// rrd文件是否存在
func IsRrdFileExist(filename string) bool {
return file.IsExist(filename)
}
func PluginRun(plugin *Plugin) {
timeout := plugin.Cycle*1000 - 500
fpath := filepath.Join(g.Config().Plugin.Dir, plugin.FilePath)
if !file.IsExist(fpath) {
log.Println("no such plugin:", fpath)
return
}
debug := g.Config().Debug
if debug {
log.Println(fpath, "running...")
}
cmd := exec.Command(fpath)
var stdout bytes.Buffer
cmd.Stdout = &stdout
var stderr bytes.Buffer
cmd.Stderr = &stderr
cmd.Start()
err, isTimeout := sys.CmdRunWithTimeout(cmd, time.Duration(timeout)*time.Millisecond)
errStr := stderr.String()
if errStr != "" {
logFile := filepath.Join(g.Config().Plugin.LogDir, plugin.FilePath+".stderr.log")
if _, err = file.WriteString(logFile, errStr); err != nil {
log.Printf("[ERROR] write log to %s fail, error: %s\n", logFile, err)
}
}
if isTimeout {
// has be killed
if err == nil && debug {
log.Println("[INFO] timeout and kill process", fpath, "successfully")
}
if err != nil {
log.Println("[ERROR] kill process", fpath, "occur error:", err)
}
return
}
if err != nil {
log.Println("[ERROR] exec plugin", fpath, "fail. error:", err)
return
}
// exec successfully
data := stdout.Bytes()
if len(data) == 0 {
if debug {
log.Println("[DEBUG] stdout of", fpath, "is blank")
}
return
}
var metrics []*model.MetricValue
err = json.Unmarshal(data, &metrics)
if err != nil {
log.Printf("[ERROR] json.Unmarshal stdout of %s fail. error:%s stdout: \n%s\n", fpath, err, stdout.String())
return
}
g.SendToTransfer(metrics)
}