Port osbuild/images v0.33.0 with dot-notation to composer

Update the osbuild/images to the version which introduces "dot notation"
for distro release versions.

 - Replace all uses of distroregistry by distrofactory.
 - Delete local version of reporegistry and use the one from the
   osbuild/images.
 - Weldr: unify `createWeldrAPI()` and `createWeldrAPI2()` into a single
   `createTestWeldrAPI()` function`.
 - store/fixture: rework fixtures to allow overriding the host distro
   name and host architecture name. A cleanup function to restore the
   host distro and arch names is always part of the fixture struct.
 - Delete `distro_mock` package, since it is no longer used.
 - Bump the required version of osbuild to 98, because the OSCAP
   customization is using the 'compress_results' stage option, which is
   not available in older versions of osbuild.

Signed-off-by: Tomáš Hozza <thozza@redhat.com>

vendor/github.com/containers/storage/pkg/tarlog/tarlogger.go

@@ -0,0 +1,66 @@
+package tarlog
+
+import (
+	"io"
+	"sync"
+
+	"github.com/sirupsen/logrus"
+	"github.com/vbatts/tar-split/archive/tar"
+)
+
+type tarLogger struct {
+	writer     *io.PipeWriter
+	closeMutex *sync.Mutex
+	closed     bool
+}
+
+// NewLogger returns a writer that, when a tar archive is written to it, calls
+// `logger` for each file header it encounters in the archive.
+func NewLogger(logger func(*tar.Header)) (io.WriteCloser, error) {
+	reader, writer := io.Pipe()
+	t := &tarLogger{
+		writer:     writer,
+		closeMutex: new(sync.Mutex),
+		closed:     false,
+	}
+	tr := tar.NewReader(reader)
+	t.closeMutex.Lock()
+	go func() {
+		hdr, err := tr.Next()
+		for err == nil {
+			logger(hdr)
+			hdr, err = tr.Next()
+
+		}
+		// Make sure to avoid writes after the reader has been closed.
+		if err := reader.Close(); err != nil {
+			logrus.Errorf("Closing tarlogger reader: %v", err)
+		}
+		// Unblock the Close().
+		t.closeMutex.Unlock()
+	}()
+	return t, nil
+}
+
+func (t *tarLogger) Write(b []byte) (int, error) {
+	if t.closed {
+		// We cannot use os.Pipe() as this alters the tar's digest. Using
+		// io.Pipe() requires this workaround as it does not allow for writes
+		// after close.
+		return len(b), nil
+	}
+	n, err := t.writer.Write(b)
+	if err == io.ErrClosedPipe {
+		// The pipe got closed.  Track it and avoid to call Write in future.
+		t.closed = true
+		return len(b), nil
+	}
+	return n, err
+}
+
+func (t *tarLogger) Close() error {
+	err := t.writer.Close()
+	// Wait for the reader to finish.
+	t.closeMutex.Lock()
+	return err
+}