go_sysutils/auger/funcs_aug.go

package auger

import (
	`bufio`
	`errors`
	`fmt`
	`io`
	`os`
	`path/filepath`
	`strings`

	`github.com/davecgh/go-spew/spew`
	`github.com/google/shlex`
	`honnef.co/go/augeas`
	`r00t2.io/goutils/bitmask`
	`r00t2.io/sysutils/paths`
)

// Close cleanly closes the underlying Augeas connection.
func (a *Aug) Close() {

	a.aug.Close()

}

// Interact provides an interactive shell-like interface for debugging purposes to explore the loaded Augeas tree.
func (a *Aug) Interact() (err error) {

	var input string
	var lexed []string
	var cmd string
	var arg string
	var val string
	var augVal string
	var augVals []string
	var buf *bufio.Reader = bufio.NewReader(os.Stdin)

	fmt.Fprint(os.Stderr, "INTERACTIVE MODE\nCmds: get, getall, match, set, quit\n")
breakCmd:
	for {
		cmd, arg, val = "", "", ""

		fmt.Fprint(os.Stderr, "> ")
		if input, err = buf.ReadString('\n'); err != nil {
			if errors.Is(err, io.EOF) {
				err = nil
				break breakCmd
			}
			return
		}
		if strings.TrimSpace(input) == "" {
			continue
		}
		if lexed, err = shlex.Split(input); err != nil {
			return
		}
		if lexed == nil || len(lexed) == 0 || len(lexed) > 3 {
			fmt.Fprintf(os.Stderr, "Bad command: %#v\n", lexed)
			continue
		}
		cmd = lexed[0]
		switch len(lexed) {
		case 2:
			arg = lexed[1]
		case 3:
			arg = lexed[1]
			val = lexed[2]
		}
		switch cmd {
		case "get":
			if strings.TrimSpace(arg) == "" {
				fmt.Fprintln(os.Stderr, "Missing argument")
				continue
			}
			if augVal, err = a.aug.Get(arg); err != nil {
				fmt.Fprintf(os.Stderr, "!! ERROR !!\n%v\n", spew.Sdump(err))
				err = nil
				continue
			}
			fmt.Fprintln(os.Stderr, augVal)
		case "getall":
			if strings.TrimSpace(arg) == "" {
				fmt.Fprintln(os.Stderr, "Missing argument")
				continue
			}
			if augVals, err = a.aug.GetAll(arg); err != nil {
				fmt.Fprintf(os.Stderr, "!! ERROR !!\n%v\n", spew.Sdump(err))
				err = nil
				continue
			}
			fmt.Fprintln(os.Stderr, strings.Join(augVals, "\n"))
		case "match":
			if strings.TrimSpace(arg) == "" {
				fmt.Fprintln(os.Stderr, "Missing argument")
				continue
			}
			if augVals, err = a.aug.Match(arg); err != nil {
				fmt.Fprintf(os.Stderr, "!! ERROR !!\n%v\n", spew.Sdump(err))
				err = nil
				continue
			}
			fmt.Fprintln(os.Stderr, strings.Join(augVals, "\n"))
		case "set":
			if strings.TrimSpace(arg) == "" {
				fmt.Fprintln(os.Stderr, "Missing argument")
				continue
			}
			if strings.TrimSpace(val) == "" {
				fmt.Fprintln(os.Stderr, "Missing value")
				continue
			}
			if err = a.aug.Set(arg, val); err != nil {
				fmt.Fprintf(os.Stderr, "!! ERROR !!\n%v\n", spew.Sdump(err))
				err = nil
				continue
			}
			fmt.Fprintln(os.Stderr, "Success!")
		case "quit":
			break breakCmd
		default:
			fmt.Fprintf(os.Stderr, "Unknown command: %v\n", cmd)
			continue
		}
	}

	return
}

/*
	RecursiveInclude parses the configuration files belonging to Augeas lens name augLens,
	searching for all occurrences of includeDirective, loading those files (if they exist),
	and continuing so forth recursively, loading them into the Augeas file tree.

	If any relative paths are found, they will be assumed to be relative to fsRoot ("/" if empty).
	For e.g. Nginx, you almost absolutely want to set this to "/etc/nginx", but you really should
	use absolute paths for every include in your configs if supported by the application; it will
	lead to much less guesswork and much more accurate recursing/walking.

	Some lens recursively load depending on their respective include directive(s) automatically;
	some (such as the Nginx lens) do not.

	For example for Nginx, augLens should be "Nginx". RecursiveInclude will then iterate over
	/augeas/load/Nginx/incl (/augeas/load/<augLens>/incl), parsing each file for includeDirective
	(the "include" keyword, in Nginx's case), check if it is already loaded in /augeas/load/<augLens>/incl,
	adding it and reloading if not, and then scanning *that* file for includeDirective, etc.

	An error will be returned if augLens is a nonexistent or not-loaded Augeas lens module.

	Depending on how many files there are and whether globs vs. explicit filepaths are included, this may take a while.

	optFlags may be nil, multiple includeOpt (see the IncludeOpt* constants) as variadic parameters/expanded slice,
	bitwise-OR'd together, or multiple non-OR'd and OR'd together (all will be combined to a single value).
*/
func (a *Aug) RecursiveInclude(augLens, includeDirective, fsRoot string, optFlags ...includeOpt) (err error) {

	var flags *bitmask.MaskBit = bitmask.NewMaskBit()

	if optFlags != nil && len(optFlags) > 0 {
		for _, f := range optFlags {
			flags.AddFlag(f.toMb())
		}
	}

	if err = a.addIncl(includeDirective, augLens, fsRoot, nil, flags); err != nil {
		return
	}

	return
}

/*
	addIncl is used by RecursiveInclude.

	includeDirective, augLens, and fsRoot have the same meaning as in RecursiveInclude.

	newInclPaths are new filesystem paths/Augeas-compatible glob patterns to load into the filetree and recurse into.
	They may be nil, especially if the first run.
*/
func (a *Aug) addIncl(includeDirective, augLens string, fsRoot string, newInclPaths []string, inclFlags *bitmask.MaskBit) (err error) {

	var matches []string                                   // Passed around set of Augeas matches.
	var exists bool                                        // Used to indicate if the include path exists.
	var includes []string                                  // Filepath(s)/glob(s) from fetching includeDirective in lensInclPath. These are internal to the application but are recursed.
	var lensInclPath string                                // The path of the included paths in the tree. These are internal to Augeas, not the application.
	var appendPath string                                  // The path for new Augeas includes.
	var match []string                                     // A placeholder for iterating when populating includes.
	var fpath string                                       // A placeholder for finding the path of a conf file that contains an includeDirective.
	var normalizedIncludes []string                        // A temporary slice to hold normalization operations and other dynamic building.
	var lensPath string = fmt.Sprintf(augLensTpl, augLens) // The path of the lens (augLens) itself.
	var augErr *augeas.Error = new(augeas.Error)           // We use this to skip "nonexistent" lens.

	if fsRoot == "" {
		fsRoot = "/"
	}
	if err = paths.RealPath(&fsRoot); err != nil {
		return
	}

	for strings.HasSuffix(lensPath, "/") {
		lensPath = lensPath[:len(lensPath)-1]
	}
	if !strings.HasSuffix(lensPath, "/"+augInclTfm) {
		lensPath = strings.TrimSuffix(lensPath, "/"+augInclTfm)
	}
	lensInclPath = fmt.Sprintf("%v/%v", lensPath, augInclTfm)
	appendPath = fmt.Sprintf("%v/%v", lensInclPath, augAppendSuffix)

	// First canonize paths.
	if newInclPaths != nil && len(newInclPaths) > 0 {
		// Existing includes. We don't return on an empty lensInclPath.
		if matches, err = a.aug.Match(lensInclPath); err != nil {
			if errors.As(err, augErr) && augErr.Code == augeas.NoMatch {
				err = nil
			} else {
				return
			}
		} else {
			for idx, m := range matches {
				if matches[idx], err = a.aug.Get(m); err != nil {
					return
				}
			}
		}

		// Normalize new include(s).
		for idx, i := range newInclPaths {
			if !filepath.IsAbs(i) {
				newInclPaths[idx] = filepath.Join(fsRoot, i)
			}
			if err = paths.RealPath(&newInclPaths[idx]); err != nil {
				return
			}
		}

		// We don't want to bother adding multiple incl's for the same path(s); it can negatively affect Augeas loads.
		newInclPaths = dedupePaths(newInclPaths, matches)

		// And then apply things like recursion, globbing, etc.
		normalizedIncludes = make([]string, 0, len(newInclPaths))
		if inclFlags.HasFlag(IncludeOptGlobbing.toMb()) {
			// TODO
			/*
				if strings.Contains(newInclPaths[idx], "*") {

				}
			*/
		}

		// Add the new path(s) as Augeas include entries.
		if newInclPaths != nil {
			for _, fsPath := range newInclPaths {
				if err = a.aug.Set(appendPath, fsPath); err != nil {
					return
				}
			}
			/*
				And then load the new files into the tree.
				This is done at the end as it takes WAYYY less time to just reload the tree
				as a whole once you have more than, say, 30 files added at a time.
			*/
			if err = a.aug.Load(); err != nil {
				return
			}
		}
	}

	// We now fetch all values (filepath/globs) that match the includeDirective and recurse with those as new include files.
	matches = nil
	if includes, err = a.aug.GetAll(lensInclPath); err != nil {
		return
	}
	for _, fsPath := range includes {
		// This gets the Augeas filetree path, NOT the FS path...
		if match, err = a.aug.Match(fmt.Sprintf(augFsTpl, fsPath, includeDirective)); err != nil {
			return
		}
		if match == nil || len(match) == 0 {
			continue
		}
		/*
			For each directive match, we need to:

				1.) normalize to an FS *file* path (strip augFsTree from the beginning
				2.) walk backwards (via AugpathToFspath) until we find an actual file
				3.) get the *dirname* of that file
				4.) join the value (included file) to #3
			IF
				fsRoot == "/"

			This very obviously breaks for applications with arbitrary roots (like Nginx including relative to /etc/nginx).
			That's why we warn about it in Aug.RecursiveInclude. Caveat emptor.
		*/
		for idx, ftreePath := range match {
			if fpath, err = a.aug.Get(ftreePath); err != nil {
				return
			}
			if fsRoot == "/" {
				if ftreePath, err = AugpathToFspath(
					strings.TrimSuffix(ftreePath, augFsTree),
				); err != nil {
					return
				}
				if ftreePath != "" {
					fpath = filepath.Join(filepath.Dir(ftreePath), fpath)
				}
			}
			match[idx] = fpath
		}
		matches = append(matches, match...)
	}

	if matches != nil && len(matches) != 0 {
		if err = a.addIncl(includeDirective, augLens, fsRoot, matches, inclFlags); err != nil {
			return
		}
	}

	// TODO
	_, _ = exists, normalizedIncludes

	return
}