info gathering & analysis scripts

[abathur]

things to (try) gathering:

• date/time of collection (unsure, maybe the outputs should be reproducible so that it's easier to build higher-level analyses? IDK)
• OS/version details (someone else's image might differ from what's on the tin)
• shells
  • default login shell
  • those in /etc/shells
  • which shell serves as /bin/sh
  • versions (when discoverable) for any of these shells
    • maybe list of compiled features?
• shell startup/init files
  • a list and copies of what's present
  • if we can find a good way to generate it, some easy-to-read documentation of their execution order (maybe a nested list, maybe .dot graphs
    • this might need to be under different conditions (ex: login/not, interactive/not)
    • most-ideal if we could also capture whether any of these are conditional and if so what the conditions are
    • ideal if we can capture this by just tweaking the files and launching the shells under different conditions
    • not sure if all shells support set -x, but even if so this is probably not that simple unless the output format happened to be part of POSIX :)
• shell environment (likely captured after launching the shells under each condition)
  • grab the resulting envs, functions, set/shopt values, and the list of enabled/available builtins if there's any way to get it?
  • document what comes out of getconf PATH (not sure if any other getconfs are relevant?)
  • document what comes out of any other known path-generating utils such as macOS /usr/libexec/path_helper
  • for all directories present in any of these paths
    • note if it is missing
    • enumerate all of the executables and symlinks in it
      • maybe/probably/eventually capture more information about key executables (everything in POSIX? or maybe a list more tailored to "things people are likely to want to use in cross-platform scripts for bootstrapping some software")

There's probably a separate analysis phase:

• parse out which init files modify the PATH, and whether they hard-set, prepend, or append to it. This should also account for common alternate forms of accomplishing this, such as the macOS trope of eval-ing the output of path_helper.
• generate some form of diff/table/comparison of the various "stock" paths (any variants that pop up just from starting a shell + which modes they appeared in, and likewise for paths from getconf etc.
• after our last analysis, I think it would be good to have an obvious way to hook in additional phases
  • this is picking at the idea that the big rosetta stone we're building here could be an input into our efforts to write/maintain a good installer, but it could also be the foundation of our actual installer test matrix? (this could help double-dip the logic for "how do I run X on a whole bunch of different platforms" in a way that other projects may find valuable enough to help maintain)
    • do x (install nix)
    • repeat the collection+analysis
    • generate a diff/report of how doing x changed the environment
    • maybe run an extra phase of checks/assertions against the new environment? (I hesitate; it might be "better" for many of these to just be in the installer, but maybe this is a good ~playground for sharpening and understanding them first?)

[abathur]

https://blog.opstree.com/2020/02/11/shell-initialization-files/ and https://blog.flowblok.id.au/2013-02/shell-startup-scripts.html seem like good starting points for basic concepts, background on what scenarios run the shells in different mode combinations, and on how we might graph the the init process.