Ejemplo n.º 1
0
Archivo: api.go Proyecto: ahjdzx/dis
func Start() {
	if !config.AppConfig().Http.Enabled {
		return
	}
	addr := config.AppConfig().Http.Listen
	if addr == "" {
		return
	}

	server := &http.Server{
		Addr:    addr,
		Handler: initRouter(),
	}

	log.Infoln("http listening on ", addr)
	log.Fatalln(server.ListenAndServe())
}
Ejemplo n.º 2
0
func (c *Context) Destory(rw web.ResponseWriter, req *web.Request) {
	resp := &Response{}
	defer c.WriteResponse(resp)

	body, err := ioutil.ReadAll(req.Body)
	if err != nil {
		rw.WriteHeader(http.StatusBadRequest)
		resp.Message = err.Error()
		return
	}

	sshConfig := &sshlib.SSHConfig{}
	err = json.Unmarshal(body, sshConfig)
	if err != nil {
		rw.WriteHeader(http.StatusBadRequest)
		resp.Message = err.Error()
		return
	}
	log.Info("Destory...... ", sshConfig.Address)

	client, err := sshlib.NewSSHClient(sshConfig)
	if err != nil {
		rw.WriteHeader(http.StatusBadRequest)
		resp.Message = err.Error()
		return
	}
	defer client.Close()

	for _, comp := range config.AppConfig().Components {
		comp.InitAttrs(comp.TarballDir)

		out, err := sshlib.RunCommand(client, comp.DeployFilepath+" stop")
		if err != nil {
			log.Error(err)
			resp.FailedFiles = append(resp.FailedFiles, comp.TarballFilename)
			continue
		}
		log.Info("command stop output: ", out)

		out, err = sshlib.RunCommand(client, "rm -rf "+comp.Directory)
		if err != nil {
			log.Error(err)
			resp.FailedFiles = append(resp.FailedFiles, comp.TarballFilename)
			continue
		}
		log.Info("command 'rm -rf ' output: ", out)
		resp.SucceedFiles = append(resp.SucceedFiles, comp.TarballFilename)
	}
	resp.Message = "Clean up ok."
}
Ejemplo n.º 3
0
Archivo: api.go Proyecto: ahjdzx/dis
func initRouter() *web.Router {
	router := web.New(Context{})
	router.Middleware(LogMiddleware)
	router.Middleware(web.ShowErrorsMiddleware)
	router.Middleware(web.StaticMiddleware(config.AppConfig().LocalTarballDir)) //	OR use 'router.Get("/", FileServer)'
	router.Middleware((*Context).OutputJson)

	// API
	router.Get("/v1/config/reload", (*Context).ConfigReload)
	router.Post("/v1/transfer", (*Context).Transfer)
	router.Get("/v1/status", (*Context).Status)
	router.Post("/v1/destory", (*Context).Destory)

	// Internal communicate.
	router.Post("/heartbeat", (*Context).Heartbeat)

	return router
}
Ejemplo n.º 4
0
func (c *Context) ConfigReload(rw web.ResponseWriter, req *web.Request) {
	//	if strings.HasPrefix(req.RemoteAddr, "127.0.0.1") {
	err := config.LoadConfig(config.ConfigFile)
	if err != nil {
		c.WriteResponse(map[string]string{"msg": err.Error()})
	} else {
		//	var buf bytes.Buffer
		//	en := toml.NewEncoder(&buf)
		//	err := en.Encode(config.AppConfig())
		//	if err != nil {
		//		c.WriteResponse(map[string]string{"msg": err.Error()})
		//	}
		//	fmt.Println(buf.String())
		c.WriteResponse(config.AppConfig())
	}
	//	} else {
	//		c.WriteResponse(map[string]string{"msg": "permission denied"})
	//	}
}
Ejemplo n.º 5
0
func transfer(sshConfig *sshlib.SSHConfig) (succeedFiles, failedFiles []string, err error) {
	client, err := sshlib.NewSSHClient(sshConfig)
	if err != nil {
		return
	}
	defer client.Close()

	scp := sshlib.NewScp(client)

	localTarballDir := config.AppConfig().LocalTarballDir
	for _, comp := range config.AppConfig().Components {
		comp.InitAttrs(comp.TarballDir)

		_, err := sshlib.RunCommand(client, "ls "+comp.VersionDir)
		if err != nil { // fileDir not exists.
			// Create a new directory to save tarball file.
			err = sshlib.Mkdir(client, comp.VersionDir)
			if err != nil {
				log.Errorf("Mkdir %s error: %s", comp.VersionDir, err.Error())
				failedFiles = append(failedFiles, comp.TarballFilename)
				continue
			}
		}

		localTarbalPath := path.Join(localTarballDir, comp.TarballFilename)
		remoteFilePath := comp.TarballFilepath

		_, err = sshlib.RunCommand(client, "ls "+remoteFilePath)
		if err != nil { // remoteFilePath not exists.
			err = scp.PushFile(localTarbalPath, remoteFilePath)
			if err != nil {
				log.Errorf("Push file: %s --> %s, error: %s", localTarbalPath, remoteFilePath, err.Error())
				failedFiles = append(failedFiles, comp.TarballFilename)
				continue
			}
			log.Debug("push file ", localTarbalPath, " successfully.")
			succeedFiles = append(succeedFiles, comp.TarballFilename)

			// Unpack the tarball or zip file.
			_, err = sshlib.RunCommand(client, "tar -zxf "+remoteFilePath+" -C "+comp.VersionDir)
			if err != nil {
				log.Errorf("Unpack file %s error: %s", remoteFilePath, err.Error())
				continue
			}

			// if component name is AGENT_NAME, then use ssh execute the cmd option.
			if comp.Name == model.AGENT_NAME {
				var output string
				switch comp.Cmd {
				case "start":
					startCmd := fmt.Sprintf("cd %s && ./deploy start", comp.VersionDir)
					output, err = sshlib.RunCommand(client, startCmd)
					if err != nil {
						log.Errorf("Command: %s, Error: %s", comp.Cmd, err.Error())
						continue
					}
					if output != "" {
						log.Debugf("Command: %s, Output: %s", comp.Cmd, string(output))
					}
				case "status": // TODO
					statusCmd := fmt.Sprintf("cd %s && ./deploy status", comp.VersionDir)
					output, err = sshlib.RunCommand(client, statusCmd)
					if err != nil {
						log.Errorf("Command: %s, Error: %s", comp.Cmd, err.Error())
						continue
					}
					if output != "" {
						log.Debugf("Command: %s, Output: %s", comp.Cmd, string(output))
					}
				}

			}
		}

	}

	return
}