Ejemplo n.º 1
0
func apiHandler(f RouteHandler) http.HandlerFunc {
	return func(w http.ResponseWriter, r *http.Request) {
		resp, err := f(w, r)

		w.Header().Set("Cache-Control", "must-revalidate")
		w.Header().Set("Content-Type", "application/json")

		if err != nil {
			if e, ok := err.(*APIResponse); ok {
				errString, _ := json.Marshal(err)
				w.WriteHeader(e.HTTPCode)
				w.Write(errString)
			} else {
				w.WriteHeader(500)
				w.Write([]byte(`{"message": "Server Error"}`))
			}
		} else {

			if len(resp.Message) == 0 {
				resp.Message = "success"
			}

			j, err := json.Marshal(resp)
			if err != nil {
				log.Debug("apiHandler", err.Error())
				j = []byte(`{"message": "Trouble marshalling the success response"}`)
			}
			w.WriteHeader(resp.HTTPCode)
			w.Write(j)
		}
	}
}
Ejemplo n.º 2
0
func main() {

	var cPath string

	flag.StringVar(&cPath, "config", "", "Path to the config file")
	flag.Parse()

	conf, err := config.ParseConfig(cPath)
	if err != nil {
		fmt.Println("Error parsing config file:", err)
		os.Exit(1)
	}

	log.Init(conf.Log)
	log.Infof("main", "coordinator starting. Version: %s", version.Version.String())
	log.Debug("main", "config:", *conf)

	err = manager.Init(conf)
	if err != nil {
		log.Fatalf("main", "Error initializing manager: %v", err)
	}

	httpAPI := new(httpapi.Server)

	address := strings.Split(conf.Host.Address, ":")
	if len(address) != 2 {
		log.Fatalf("main", "Invalid host address. Must be in form ip:port")
	}

	httpAPI.Configure(apihandler.Routes)
	httpAPI.Start(address[0], address[1])

}
Ejemplo n.º 3
0
func agentStatus(w http.ResponseWriter, r *http.Request) (*httpapi.APIResponse, error) {
	log.Debug("apihandler", "agentStatus called")
	status := make(map[string]interface{})

	status["date"] = time.Now().String()

	status["status"] = manager.Status()

	return &httpapi.APIResponse{Data: status, HTTPCode: 200}, nil
}
Ejemplo n.º 4
0
// Builds the file list for the backup
// Listens for the cancel chanel to close to cancel walk
// Walks the file tree in JobPaths and sends any found file that isn't excluded on the return chan
// If there is an error, it sends the error on the error channel and returns
func buildBackupFileList(cancel <-chan struct{}, jobPaths []spec.BackupPath) (<-chan string, <-chan error) {

	paths := make(chan string)
	errc := make(chan error, 1)

	go func() {
		log.Debug("backupJob", "file list routine started")
		defer close(paths)

		for _, jobPath := range jobPaths {

			log.Debugf("backupJob", "Walking filepath: %v", jobPath)

			errc <- filepath.Walk(jobPath.Path, func(path string, info os.FileInfo, err error) error {

				log.Debugf("backupJob", "Walk Found: %v", path)

				if err != nil {
					return err
				}

				if !info.Mode().IsRegular() {
					return nil
				}

				if shouldExclude(path, jobPath.Excludes) {
					return nil
				}

				select {
				case paths <- path:
				case <-cancel:
					log.Info("backupJob", "Walk Canceled")
					return errors.New("Walk Canceled")
				}
				return nil
			})
		}
	}()

	return paths, errc
}