示例#1
0
// saveCurrentState saves the current running turtle apps.
func saveCurrentState() error {
	// Create a new state value.
	var s state

	// Get all apps.
	curApps := apps.Apps()

	for _, app := range curApps {
		// Skip if not running.
		if !app.IsRunning() {
			continue
		}

		// Add the app name to the running apps slice.
		s.RunningApps = append(s.RunningApps, app.Name())
	}

	// Encode the state value to TOML.
	buf := new(bytes.Buffer)
	err := toml.NewEncoder(buf).Encode(&s)
	if err != nil {
		return fmt.Errorf("failed to encode turtle state value to toml: %v", err)
	}

	// Write the result to the app settings file.
	err = ioutil.WriteFile(config.Config.StateFilePath(), buf.Bytes(), 0600)
	if err != nil {
		return fmt.Errorf("failed to save turtle state value: %v", err)
	}

	return nil
}
示例#2
0
// handleList sends a list of all Apps.
func handleList(request *api.Request) (interface{}, error) {
	// Get all apps.
	curApps := apps.Apps()

	// Create the response value.
	res := api.ResponseList{
		Apps: make([]api.ResponseListApp, len(curApps)),
	}

	// Add all the apps to the response value.
	for i, app := range curApps {
		// Get the turtlefile.
		// Continue also on error.
		var turtlefileName string
		t, err := app.Turtlefile()
		if err != nil {
			turtlefileName = "ERROR In FILE"
		} else {
			turtlefileName = t.Name
		}

		res.Apps[i] = api.ResponseListApp{
			Name:       app.Name(),
			Turtlefile: turtlefileName,
			State:      app.State(),
		}
	}

	return res, nil
}
示例#3
0
func removeOldBackups() error {
	// Lock the mutex.
	removeOldBackupsMutex.Lock()
	defer removeOldBackupsMutex.Unlock()

	var allErr string

	addErr := func(err error) {
		allErr += err.Error() + "\n"
	}

	// Create the expiration unix timestamp.
	expire := time.Now().Unix() - config.Config.KeepBackupsDuration

	// Get all apps.
	curApps := apps.Apps()

	for _, app := range curApps {
		// Get all backups of the app.
		backups, err := app.Backups()
		if err != nil {
			addErr(err)
			continue
		}

		// Remove all old backups.
		for _, b := range backups {
			u, err := strconv.ParseInt(b, 10, 64)
			if err != nil {
				addErr(err)
				continue
			}

			// Skip if this is not an old backup.
			if (expire - u) <= 0 {
				continue
			}

			log.Infof("Removing old backup '%s' of app '%s'.", b, app.Name())

			// Remove the backup.
			err = app.RemoveBackup(b)
			if err != nil {
				addErr(err)
				continue
			}
		}
	}

	// Trim the all error messages string.
	allErr = strings.TrimSpace(allErr)

	// Return the error(s) if present.
	if len(allErr) > 0 {
		return fmt.Errorf(allErr)
	}

	return nil
}
示例#4
0
// restoreState loads the turtle state file if present and
// restores the previous running apps.
func restoreState() error {
	var s state

	// Set the turtle state file path.
	statePath := config.Config.StateFilePath()

	// Skip if it does not exists.
	e, err := utils.Exists(statePath)
	if err != nil {
		return err
	} else if !e {
		return nil
	}

	// Load and decode the file.
	_, err = toml.DecodeFile(statePath, &s)
	if err != nil {
		return fmt.Errorf("failed to load turtle state file '%s': %v", statePath, err)
	}

	// Get all apps.
	curApps := apps.Apps()

	// Collect all errors during startup.
	var allErr string

	// Start the apps which where running during the last turtle daemon shutdown.
	for _, rApp := range s.RunningApps {
		for _, app := range curApps {
			// Skip if this is not our searched app or if it is already running.
			if rApp != app.Name() || app.IsRunning() {
				continue
			}

			// Start the app.
			err = app.Start()
			if err != nil {
				allErr += err.Error() + "\n"
			}
		}
	}

	// Trim the new linew at the end.
	allErr = strings.TrimSpace(allErr)

	// Return the error(s) if present.
	if len(allErr) > 0 {
		return fmt.Errorf(allErr)
	}

	return nil
}