nim reported a new issue against the project: `go-rpm-macros` that you are following:
``
The macro code needs massaging to also work on EPEL.
Most of the work is spec side since some of the macros are going to collide with the ones provided by previous iterations of Go macro packages
``
To reply, visit the link below or just reply to this email
https://pagure.io/go-rpm-macros/issue/2
nim reported a new issue against the project: `go-rpm-macros` that you are following:
``
`%goprep` should apply patches automatically, so there is no convenience gap with `%autosetup`.
This is generic work that should be done *redhat-rpm-config* side in forge macros and then reused in`%goprep`. Basically:
1. define a `patch_flags<suffix>` rpm variable holding the parameters that should be passed to `%patch<suffix>`
2. define a `default_flags<suffix>` fallback
3. define a `source_patches<suffix>` holding an ordered space separated list of patch suffixes associated with a particular forge/go source.
And then write the usual lua loops to apply it all at the right moment in the spec.
``
To reply, visit the link below or just reply to this email
https://pagure.io/go-rpm-macros/issue/3
nim reported a new issue against the project: `go-rpm-macros` that you are following:
``
This is a clone of
https://github.com/gofed/go-macros/issues/56
The problem is actually in golist, not in the macros themselves. Sticking it in the macro project for now as they need to be switched to deploy in libdir if this is not fixed
According to @jcajka this needs fixing in any case, because other build options are handled the same way by the Go compiler, so deploying only the files corresponding to a particular set of options means sources can not be used with another one later. And we have some of those in Fedora, for example, optional selinux support in some container projects.
``
To reply, visit the link below or just reply to this email
https://pagure.io/go-rpm-macros/issue/1
nim reported a new issue against the project: `golist` that you are following:
``
Right now `golist` does not permit querying the imports of a project and its tests in a single pass. You can emulate most of it with two separate commands:
```sh
golist --imported --package-path github.com/sirupsen/logrus --skip-self
golist --imported --package-path github.com/sirupsen/logrus --skip-self --tests
```
However the second line can request things the first line decided to filter out, because they are provided by the project itself. And that will probably break some builds once
https://github.com/rpm-software-management/rpm/pull/593 or
https://pagure.io/fesco/issue/2004 are done.
For dynamic BuildRequires to work reliably, we really need a single codebase+tests call (we can still use the codebase-only line when a packager disables tests in its specs).
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/3
nim reported a new issue against the project: `golist` that you are following:
``
This is the root cause behind
https://pagure.io/go-rpm-macros/issue/1
When asked to list the files to deploy, golist only answers for the current tags (arch and build options)
https://pagure.io/go-rpm-macros/blob/master/f/bin/go-rpm-integration#_386
Being arch-specific is annoying but not a blocker¹
However @jcajka thinks this will also remove installation of files not covered by current build tags. And that is a huge problem because that makes the result unusable, by any consumer, that needs a different tag combination than the one passed by the source code packager.
¹ The migration of Fedora’s go -devel packages to an arch-specific root can be kludged as evidenced by https://copr.fedorainfracloud.org/coprs/nim/go-rpm-macros/builds/ because they are only installed transiently
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/2
nim reported a new issue against the project: `golist` that you are following:
``
This is a similar issue to https://pagure.io/golist/issue/3 this time for packagers that try to package several import paths in a single spec (I’m told the practice is common RHEL-side).
For this use pattern to work reliably, you need to compute the codebase requirements in a single pass. Otherwise `golist` will forget to filter out imports of code, already available on-system under another import path. And that will break BuildRequires computation.
So we need something like
```sh
$ golist --imported --skip-self --with-tests --package-path %{goipath0} --package-path %{goipath1} --package-path %{goipath2}
```
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/4
nim reported a new issue against the project: `golist` that you are following:
``
`golist` only implements a single output format, which means this output needs to be reprocessed in shell before being fed to other software, like rpm¹.
This shell reprocessing is brittle and adds noise to Go package build logs.
Mature utilities allow specifying an output format template, which simplifies their integration with other software. This can be done:
* either by defining a custom format string using predefined variables (as [done](http://man7.org/linux/man-pages/man1/time.1.html) by the `time -f`command),
* or by specifying a specific package dep format built-in (as done by the `fcquery --format '%{=pkgkit}'` command, that allowed direct integration [within rpm](https://github.com/rpm-software-management/rpm/blob/ff4b9111aeba01dd02… in [2009](https://bugs.freedesktop.org/show_bug.cgi?id=17107))
`golist` should implement something similar.
¹ Typically to [add `golang()`](https://pagure.io/go-rpm-macros/blob/master/f/rpm/macros.d/macros.go-rpm#_228) around dependencies, would need more processing if it ever evolves to list version constrains
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/13
nim reported a new issue against the project: `golist` that you are following:
``
The last stage of rpm packaging is copying a clean final copy of all the files that will be shipped in an arborescence under a `%{buildroot}` prefix.
That is the deployment tree that is operated on to compute the actual requires and provides rpm will generate.
As a consequence of this rpm design we can not change:
* the files operated on are not in their final place but under a root prefix (`%{buildroot}/something` instead of `something`), and
* absolute symbolic links that point within the target deployment tree are left dangling (they point to `something`, when `/something` is still at `%{buildroot}/something`)
Since *golist* is used to compute provides and requires for Go sources, and those sources can include absolute symlinks, and will continue to prefer absolute symlinks over relative symlinks because relative symlinks are quite hard to get right, *golist* needs to learn to work in prefix mode, and learn to walk to `%{buildroot}/something` when encountering a `/something` symlink in the source tree.
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/12
nim reported a new issue against the project: `golist` that you are following:
``
golist relies on an obsolete release of gopkg.in/urfave/cli.v1 (1.18) and does not work with the current one (1.20)
+ go build -buildmode pie -compiler gc '-tags=rpm_crashtraceback ' -ldflags ' -X github.com/gofed/symbols-extractor/version.commit=aecba475bf76f5269c11367da… -X github.com/gofed/symbols-extractor/version=0 -B 0x53a515e8225a08687fb15659311c31138f10deef -extldflags '\''-Wl,-z,relro '\''' -a -v -x -o _bin/golist github.com/gofed/symbols-extractor/cmd/golist
…
cd /builddir/build/BUILD/symbols-extractor-aecba475bf76f5269c11367da0a190419cd9a133/_build/src/github.com/gofed/symbols-extractor/cmd/golist
/usr/lib/golang/pkg/tool/linux_amd64/compile -o $WORK/b001/_pkg_.a -trimpath $WORK/b001 -shared -p main -complete -installsuffix shared -buildid W7hFQx2bLlwdklLGWaGL/W7hFQx2bLlwdklLGWaGL -goversion go1.10 -D "" -importcfg $WORK/b001/importcfg -pack ./golist.go
# github.com/gofed/symbols-extractor/cmd/golist
cmd/golist/golist.go:25:40: cannot use nil as type string in field value
cmd/golist/golist.go:25:68: cannot use "" (type string) as type bool in field value
cmd/golist/golist.go:25:72: cannot use false (type bool) as type *cli.StringSlice in field value
cmd/golist/golist.go:26:41: cannot use nil as type string in field value
cmd/golist/golist.go:26:74: cannot use "" (type string) as type bool in field value
cmd/golist/golist.go:26:78: cannot use false (type bool) as type *cli.StringSlice in field value
cmd/golist/golist.go:27:42: cannot use nil as type string in field value
cmd/golist/golist.go:27:87: cannot use "" (type string) as type bool in field value
cmd/golist/golist.go:27:91: cannot use false (type bool) as type *cli.StringSlice in field value
cmd/golist/golist.go:28:61: cannot use "" (type string) as type bool in field value
cmd/golist/golist.go:28:61: too many errors
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/1
Hello,
I propose to skip the next meeting as I will be unavailable to chair that meeting. 26th is a public holiday in CZ and I will be 100% offline on that day.
JC
nim reported a new issue against the project: `golist` that you are following:
``
This is a continuation and modernization of https://github.com/gofed/go-macros/issues/35
When bootstrapping a set of Go projects, with circular dependencies, you need to identify quickly the parts that participate in the loop, so they can be culled in the initial bootstrap package
For example if `docker-x` depends directly or indirectly on `docker-y`, and `docker-y` imports `docker-x` in its own code (or tests), you want to identify the `docker-x` parts that use `docker-y` and remove them in `%prep`. And then, once the result is built, and permits an initial built of `docker-y`, you can use the resulting `docker-y` to build `docker-x` without removing anything
This could be done by adding a `-x` `--exclude-import-path` switch to golist.
The switch can occur several times, to specify several exclusions in one pass, as some codebases participate in several loops at once
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/11
nim reported a new issue against the project: `golist` that you are following:
``
It would be awfully nice if `golist` had a mode that outputed, for every path that can be built as a binary:
* the buildable path
* a separator that can not occur in paths
* the expected command output name (via heuristics if necessary)
The result could then be fed to `%gobuild` by [go-rpm-macros](https://pagure.io/go-rpm-macros/)
``
To reply, visit the link below or just reply to this email
https://pagure.io/golist/issue/5