GitLab

This writes the library files to the go cache so that it is preserved as
long as the cache is preserved.

A separate build pipeline that uses this pkg-config sometimes sets GO (a
la Make's CC and LD variables). In that case pkg-config attempts to
execute a "go" that does not exist. Instead, use the value of the
environment variable GO, if it is set to a non-empty string.

fix: expand relative module paths

When a module path references, for instance, `../flux`, that path is
relative to the `go.mod` file that the reference is in. This patch
expands that path to be absolute before it is operated on, so that the
resulting operations don't break when run from other directories.

This changes `pkg-config` to produce a unique hashed linked output and
configures it to output a link command that includes that hash. This is
done because Go will hash the output of `pkg-config` and it will hash
multiple builds.

For example, it is possible to use `pkg-config` on one build and get a
valid output. Then you make a modification and use it again and get
another valid output. If you revert back to the first build input,
go will believe the library has already been built and won't run
`pkg-config` again. It will link against the output from the second
build.

This is because go's invocation of `pkg-config` always assumes that
nothing changes. By adding these hashes, go will use the first
`pkg-config` invocation's output and link against the correct library.

This mostly affects local builds because local builds are the only
circumstance where `pkg-config` will overwrite the old file. Module and
vendor builds aren't affected because they produce a unique directory
output.

fix: set CC when building for macOS

Currently, the pkg-config unsets the `CC` environment variable when
cross-compiling. This causes problems when darwin then tries to use the
default compiler, `gcc`, where the final linking would use `clang` and thus be incompatible.

This branch is for linking against the refactor/one-public-create branch in
flux, which exposes only a single create to Rust and C.

When we print the environment when overwriting the environment, we risk
printing any sensitive information that was held inside of environment
variables. Now that we have determined that this code works, the log
message should be removed to avoid leaking credentials.

This patch fixes a copy-n-paste issue that slipped through pairing and
code review.
Co-authored-by: Paul Hummer <phummer@influxdata.com>

This will add a `v6` or `v7` to the end of the arm architecture if the
architecture is `arm`.

feat: add all supported targets to cargo call

This patch adds support for all the flux supported targets.

fix: remove compiler environment variable when cross compiling

The CC environment variable, along with potentially `AR` and `CXX`,
seems to interfere with the musl compilation toolchain when cross
compiling. Because of this, we remove these environment variables when
running cargo.

feat: add support for static builds

This patch adds support for static builds using the musl library.

If the application was specified with `pkg-config`, it would still look
on the path for itself and would remove the real `pkg-config`. This
fixes it so it recognizes that `PKG_CONFIG` was set and will unset that
environment variable instead of modifying the path. If it was wrong and
`PKG_CONFIG` was not used to invoke it, this just causes it to call
itself once rather than infinitely.

This also modifies `pkg-config` to use the `CARGO` environment variable
to find `cargo` for the flux build. This makes it easier to configure
for an IDE that doesn't have cargo on the normal path.

The `pkg-config` executable made the erroneous assumption it would be
called within the directory of the project that was invoking it rather
than inside of the package that was using it.

The `pkg-config` executable can now recognize when it is called from
within the module cache and it can find the version by using the
directory filepath instead of relying on git for those situations.

It also is now able to recognize when it is within a vendor directory.
After it finds the module root, it looks to see if there is another
module root in the path with a vendor directory. If there is, it will
use the original project instead of the vendored directory and it will
proceed with the `go mod download` workflow.

This extends the existing log mechanism to print the output when a
failure occurs.

This will compute the arg0 path by looking at the first entry in the
path where the executable can be found. This is the proper way to find
the real path of the executable.

Downloading the flux module should always reference the
`github.com/influxdata/flux` module even when a replace says to put it
somewhere else. `go mod download` will follow the replace so doing that
ourselves results in an error when a module is in another repository
when using replace.

If `pkg-config` was installed in multiple places on the path, it would
be possible for one of those `pkg-config` executables to invoke the
other, then for that one to invoke the original, in an infinite loop.

So the path resolution has now been modified to find the current
executable on the path and, if present, it will remove all entries
before it. This way, it avoids triggering an infinite loop.

This implements finding the flux module when it is not the main module.
When a replace is used with a file path, `pkg-config` will compile it
the same as if it were the main module.

This also implements downloading the module to the module cache to
perform the build there. This build will fail though because the
directory is read only.