Project: Emissary-Ingress (Orchestration & Management / API Gateway)
File: intro.md

build-aux is a collection of Makefile `.mk` snippets (and associated utilities). Each of the `.mk` snippets is written to be as independent from the others as possible, but integrate well by following common conventions. You may pick-and-choose which to include simply by writing `include build-aux/NAME.mk` in your `Makefile`. Each `.mk` snippet starts with a reference header-comment identifying: any eager-evaluated inputs (mostly variables) any lazy-evaluated inputs (mostly variables) any outputs (targets, variables) which targets from other snippets it hooks in to (mostly hooking in to `common.mk` targets) Eager inputs need to be defined before loading the snippet; lazy inputs can be defined later. See for more information on the reference header-comment. For the most part, you don't need to worry about dependencies between `.mk` files; each file will automatically `include` the others it depends on. However, if you would like to use an output from one snippet as an eager input to another, then you do need to worry about include order; if you would like to use `kubernaut-ui.mk` to set `KUBECONFIG` for `teleproxy.mk`, then you will need to make sure you include `kubernaut-ui.mk` before you include `teleproxy.mk`. You don't need to worry about including a file twice; this is safe, as they all have C-header-style include guards. Most (but not all) of the snippets include `common.mk`, which Configures Make to use sane settings (since the default settings are set for historical compatibility, not the "right thing"). Defines several `$(call )`-able helper functions, like `joinlist`, `path.trimprefix`, or `quote.shell`. See itself for the full list, and documentation on how to use them. Declares several utility variables: `GOOS`, `GOARCH`: Operating system name, and CPU architecture. `GO` is included in the variable names to indicate that they use the same names as `go env` (as opposed to using `uname -s`/`uname -m` names, or something

`NL`: a single newline character, since that's hard to type in Make `SPACE`: a single space character, since that's hard to type in Make Declares several high-level common targets, like `make build`, `make clean`, or `make check`. See itself for the full list. By defining a list of common user-facing targets, the rest of the snippets can hook in to that and provide a uniform interface. With the exception of `make check` (which is special, see below), your `Makefile` can extend any of these by adding dependencies to the target name. For example, to have `make build` build the `foo` file, you could write: build: foo or to have `make lint` run the `flake8` Python linter, you could write lint: flake8 flake8: flake8 mypackage/ .PHONY: flake8 or lint: flake8 mypackage/ The former has the advantage that it allows you to add multiple hooks on to `lint` (so it's the only method that build-aux snippets use), and also allows flake8 to run in parallel with other linters set up by build-aux snippets. `make check` is special in how it works. Instead of writing check: my-test # WRONG you write test-suite.tap: my-test.tap # CORRECT See for information about writing the recipe for `my-test.tap`. Because of `make check`'s use of `test-suite.tap`, `common.mk` also goes ahead and has `make clean` run `rm -f test-suite.tap`. With the exceptions of `make check` and `make clean`, `common.mk` only provides empty definitions; it is up to your `Makefile`, or other `.mk` snippets to make these rules actually do something. The snippet `help.mk` adds a `make help` target, that display information about your project (customizable by setting the `help.body` variable from your `Makefile`), and a table of all of the `make FOO` targets that Make knows about. Any targets you write in your `Makefile` that you think should be visible can be added to this listing by writing a magic comment: frob: ## Frobnicate the splorks See itself for full documentation.