Exemple #1
0
func rewriteConfigForLogstashForwarder(comp *model.Component, containers []*Container) error {
	log.Infoln("rewrite configuration file ", comp.Name)
	// 1. Load configuration file.
	c := &Config{}
	err := LoadConfig(comp.ConfigFilepath, c)
	if err != nil {
		return err
	}

	newFiles := make([]FileConfig, 0, 10)

	// 2. Change the configuration content.
	for _, fileCfg := range c.Files {
		var pathsContainsUPM_DATA bool = false
		for _, fp := range fileCfg.Paths {
			if strings.Contains(fp, "upm-data") {
				pathsContainsUPM_DATA = true
				break
			}
		}
		if !pathsContainsUPM_DATA {
			newFiles = append(newFiles, fileCfg)
		}
	}

	for _, ctn := range containers {
		fileCfg := FileConfig{
			Fields: make(map[string]string, 5),
		}
		if len(ctn.Names) > 0 {
			_path := fmt.Sprintf("/upm-data/%s/logs/*log*", path.Base(ctn.Names[0]))
			fileCfg.Paths = append(fileCfg.Paths, _path)

			fileCfg.Fields["type"] = strings.Split(path.Base(ctn.Image), ":")[0]
			fileCfg.Fields["image"] = ctn.Image
			fileCfg.Fields["cid"] = ctn.ID
			fileCfg.Fields["created"] = strconv.FormatInt(ctn.Created, 10)
			fileCfg.Fields["name"] = path.Base(ctn.Names[0])
		}
		newFiles = append(newFiles, fileCfg)
	}

	c.Files = newFiles

	// 3. Rewrite the configuration file.
	ret, err := json.MarshalIndent(c, "", "    ")
	if err != nil {
		return err
	}
	log.Debugln("configuration file path is ", comp.ConfigFilepath)
	err = utils.WriteFile(comp.ConfigFilepath, ret, 0644)
	return err
}
Exemple #2
0
func rewriteConfigForCollectd(comp *model.Component, containers []*Container) error {
	log.Infoln("rewrite configuration file ", comp.Name)
	// 1. Load configuration file.
	c := &cfg_collected.Config{}
	_, err := toml.DecodeFile(comp.ConfigFilepath, c)
	if err != nil {
		return err
	}

	// 2. Change the configuration content.
	inputConfig := &cfg_collected.InputConfig{
		Enabled:  true,
		Interval: DefaultInterval,
		SubInput: make([]*cfg_collected.InputConfig, len(containers)),
	}
	for i, ctn := range containers {
		serviceType := strings.Split(path.Base(ctn.Image), ":")[0]
		var interval int
		itv, ok := config.AppConfig().Intervals[serviceType]
		if !ok {

			log.Warnf("service %s hasn't config interval, using default %d", serviceType, DefaultInterval)
			interval = DefaultInterval
		} else {
			interval = itv.Value
		}
		subConfig := &cfg_collected.InputConfig{
			Enabled:  true,
			Interval: interval,
			Tags:     fmt.Sprintf("cid:%s", ctn.ID),
		}
		inputConfig.SubInput[i] = subConfig
	}
	c.Input["container"] = inputConfig

	// 3. Rewrite the configuration file.
	buf := bytes.NewBuffer(nil)
	encoder := toml.NewEncoder(buf)
	err = encoder.Encode(c)
	if err != nil {
		return err
	}
	encoder.Indent = "  "
	log.Debugln("configuration file path is ", comp.ConfigFilepath)
	err = utils.WriteFile(comp.ConfigFilepath, buf.Bytes(), 0644)
	return err
}
Exemple #3
0
func main() {
	flag.Parse()

	if *versionFlag {
		fmt.Println(VERSION)
		os.Exit(0)
	}

	if *logstashFlag {
		log.ChangeToLogstashFormater(APP_NAME)
	}

	log.SetLogFile(LOG_FILE)

	err := config.LoadConfig(*cfgFileFlag)
	if err != nil {
		log.Fatalln(err)
	}

	pid := os.Getpid()
	// Save the pid into the pid file.
	err = utils.WriteFile(PID_FILE, []byte(strconv.Itoa(pid)), 0644)
	if err != nil {
		log.Fatalln(err)
	}
	defer os.Remove(PID_FILE)

	go api.Start()

	// catch some signal
	sigCh := make(chan os.Signal)
	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM, os.Kill)
	// Block until a signal is received.
	s := <-sigCh

	log.Debugf("Caught Signal: %s, shutting down...", s)
}
Exemple #4
0
func main() {
	flag.Parse()

	if *versionFlag {
		fmt.Println(VERSION)
		os.Exit(0)
	}

	if *logstashFlag {
		log.ChangeToLogstashFormater(APP_NAME)
	}

	log.SetLogFile(LOG_FILE)

	err := config.LoadConfig(*cfgFileFlag)
	if err != nil {
		log.Fatalln(err)
	}

	pid := os.Getpid() // This process's pid.
	// Save the pid into the pid file.
	err = utils.WriteFile(PID_FILE, []byte(strconv.Itoa(pid)), 0666)
	if err != nil {
		log.Fatalln(err)
	}
	defer os.Remove(PID_FILE)

	clientSet, err := initClientSet()
	if err != nil {
		log.Fatalln(err)
	}

	go engine.Boot()

	engine.Watcher, err = engine.NewWatch(clientSet)
	if err != nil {
		log.Fatalln(err)
	}
	go engine.Run()

	if engine.CurrentDir == "" {
		log.Fatalln("current directory is blank.")
	}

	err = utils.WriteFile(path.Join(path.Dir(engine.CurrentDir), ".version"), []byte(VERSION), 0644)
	if err != nil {
		log.Fatalln(err)
	}

	err = common.ConsulRegister(APP_NAME, path.Join(engine.CurrentDir, "deploy"))
	if err != nil {
		log.Fatalln(err)
	}

	// go api.Start()

	// catch some signal
	sigCh := make(chan os.Signal)
	signal.Notify(sigCh, syscall.SIGINT, syscall.SIGTERM, os.Kill)
	// Block until a signal is received.
	s := <-sigCh
	log.Infof("Caught Signal: %s, shutting down...", s)
}
Exemple #5
0
// Update or create
func heartbeat() {
	log.Debugln("heartbeat......")
	log.Debugln("stackDir is ", stackDir)

	localComps := LocalComponents()

	hbtRequest, err := buildHeartbeatRequest()
	if err != nil {
		log.Errorln(err)
		return
	}
	hbtRequest.RemoteComponents = localComps

	log.Infoln("request: ", hbtRequest)
	// http request to server heartbeat url.
	if config.AppConfig().Server == "" {
		log.Errorln("configuration server is blank.")
		return
	}
	heartbeatURL := fmt.Sprintf("http://%s/heartbeat", config.AppConfig().Server)
	hbtResponse, err := requestHeartbeat(heartbeatURL, hbtRequest)
	if err != nil {
		log.Errorln(err)
		return
	}
	log.Infoln("response: ", hbtResponse)

	if hbtResponse != nil && hbtResponse.Components != nil {
		log.Infoln("response comps : ", hbtResponse.Components)
		for _, newComp := range hbtResponse.Components {
			newComp.InitAttrs(stackDir)
			log.Debugf("newComp: %s", newComp)

			// 1. Create version directory.   stack_dir/comp_name/version_number/
			if utils.IsExist(newComp.VersionDir) {
				_, err := utils.ExecCommand(false, "mkdir", "-p", newComp.VersionDir)
				if err != nil {
					log.Errorln(err)
					continue
				}
			}

			// 2. Download new version component.
			downURL := fmt.Sprintf("http://%s/%s", config.AppConfig().Server, newComp.TarballFilename)
			err = downloadFromURL(newComp.TarballFilepath, downURL)
			if err != nil {
				log.Errorln(err)
				continue
			}
			// 3. Uncompress the new component file.
			output, err := utils.ExecCommand(false, "tar", "-zxf", newComp.TarballFilepath, "-C", newComp.VersionDir)
			if err != nil {
				log.Errorln(err)
				continue
			}
			log.Debugf("Untar file: %s , output: %s", newComp.TarballFilepath, output)

			if newComp.Cmd == "start" {
				if view != nil {
					containers := view.Data.([]*Container)
					switch newComp.Name {
					case "dis-collectd":
						{
							err := rewriteConfigForCollectd(newComp, containers)
							if err != nil {
								log.Errorln("rewriteConfigForCollectd error: ", err)
								continue
							}
						}
					case "logstash-forwarder":
						{
							err := rewriteConfigForLogstashForwarder(newComp, containers)
							if err != nil {
								log.Errorln("rewriteConfigForLogstashForwarder error: ", err)
								continue
							}
						}
					}
				}

				log.Debugln("new component DeployFilepath = ", newComp.DeployFilepath)
				output, err = utils.ExecCommand(false, newComp.DeployFilepath, "start")
				if err != nil {
					log.Errorln(err)
					continue
				}
				log.Debugf("Execute command: %s %s, output: %s\n", newComp.DeployFilepath, newComp.Cmd, output)

				// Componet directory was existed, then shutdown old verison component.
				if utils.IsExist(path.Join(newComp.Directory, ".version")) {
					oldVersion_b, err := utils.ReadFile(path.Join(newComp.Directory, ".version"))
					if err != nil {
						log.Errorln(err)
						continue
					}
					oldDeployFilePath := path.Join(newComp.Directory, strings.TrimSpace(string(oldVersion_b)), "deploy")
					_, err = utils.ExecCommand(false, oldDeployFilePath, "stop")
					if err != nil {
						log.Errorln(err)
						continue
					}
				}

				// Write the verion number to .version in the parent directory.
				log.Debugln("write version number file,  ", newComp.Directory)
				err = utils.WriteFile(path.Join(newComp.Directory, ".version"), []byte(newComp.Version), 0644)
				if err != nil {
					log.Errorln(err)
					continue
				}

				// Register this component to consul.
				err = common.ConsulRegister(newComp.Name, newComp.DeployFilepath)
				if err != nil {
					log.Errorln(err)
					continue
				}
			} else {
				log.Debugln("new component DeployFilepath = ", newComp.DeployFilepath)
				output, err = utils.ExecCommand(false, newComp.DeployFilepath, newComp.Cmd)
				if err != nil {
					log.Errorln(err)
					continue
				}
				log.Debugln("Execute command: %s %s, output: %s\n", newComp.DeployFilepath, newComp.Cmd, output)
			}
		}
	}
}