feat: support SOURCE_DATE_EPOCH (#26)

I have found out something horrifying about how tools deal with time:
some tools will interpret a zero time value as "has no time". This is
horrifying. As such, I have implemented support for SOURCE_DATE_EPOCH,
which will be auto-populated by the commit date in the current working
directory, or be overrided with the environment variable value.

This means that yeet package contents won't be "50 years old", which can
cause some issues for downstream consumers.

https://reproducible-builds.org/docs/source-date-epoch/

Signed-off-by: Xe Iaso <[e-mail]>

internal/git.go

···
 import (
 	"context"
 	"flag"
+	"log/slog"
 	"os"
+	"os/exec"
 	"path/filepath"
+	"strconv"
+	"strings"
+	"time"
 
 	"github.com/Songmu/gitconfig"
 	"github.com/TecharoHQ/yeet/internal/yeet"
 )
 
 var (
-	GPGKeyFile     = flag.String("gpg-key-file", gpgKeyFileLocation(), "GPG key file to sign the package")
-	GPGKeyID       = flag.String("gpg-key-id", "", "GPG key ID to sign the package")
-	GPGKeyPassword = flag.String("gpg-key-password", "", "GPG key password to sign the package")
-	UserName       = flag.String("git-user-name", GitUserName(), "user name in Git")
-	UserEmail      = flag.String("git-user-email", GitUserEmail(), "user email in Git")
+	GPGKeyFile      = flag.String("gpg-key-file", gpgKeyFileLocation(), "GPG key file to sign the package")
+	GPGKeyID        = flag.String("gpg-key-id", "", "GPG key ID to sign the package")
+	GPGKeyPassword  = flag.String("gpg-key-password", "", "GPG key password to sign the package")
+	UserName        = flag.String("git-user-name", GitUserName(), "user name in Git")
+	UserEmail       = flag.String("git-user-email", GitUserEmail(), "user email in Git")
+	SourceDateEpoch = flag.Int64("source-date-epoch", GetSourceDateEpoch(), "Timestamp to use for all files in packages")
 )
 
 const (
···
 
 	return vers
 }
+
+func GetSourceDateEpoch() int64 {
+	// fallback needs to be 1 because some software thinks unix time 0 means "no time"
+	const fallback = 1
+
+	gitPath, err := exec.LookPath("git")
+	if err != nil {
+		slog.Warn("git not found in $PATH", "err", err)
+		return fallback
+	}
+
+	epochFromGitStr, err := yeet.Output(context.Background(), gitPath, "log", "-1", "--format=%ct")
+	if err == nil {
+		num, _ := strconv.ParseInt(strings.TrimSpace(epochFromGitStr), 10, 64)
+		if num != 0 {
+			return num
+		}
+	}
+
+	return fallback
+}
+
+func SourceEpoch() time.Time {
+	return time.Unix(*SourceDateEpoch, 0)
+}

internal/mkdeb/mkdeb.go

···
 	"os"
 	"path/filepath"
 	"runtime"
-	"time"
 
 	"github.com/Masterminds/semver/v3"
 	"github.com/TecharoHQ/yeet/internal"
···
 			Type:        files.TypeDir,
 			Destination: d,
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 				Mode:  os.FileMode(0600),
 			},
 		})
···
 			Destination: osPath,
 			FileInfo: &files.ContentFileInfo{
 				Mode:  os.FileMode(0600),
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 	}
···
 			Source:      repoPath,
 			Destination: filepath.Join("/usr/share/doc", p.Name, rpmPath),
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 	}
···
 			Source:      repoPath,
 			Destination: rpmPath,
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 	}
···
 			Source:      path,
 			Destination: path[len(dir)+1:],
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 
···
 		return "", fmt.Errorf("mkdeb: can't walk output directory: %w", err)
 	}
 
-	contents, err = files.PrepareForPackager(contents, 0o002, "deb", true, time.Unix(0, 0))
+	contents, err = files.PrepareForPackager(contents, 0o002, "deb", true, internal.SourceEpoch())
 	if err != nil {
 		return "", fmt.Errorf("mkdeb: can't prepare for packager: %w", err)
 	}
 
 	for _, content := range contents {
-		content.FileInfo.MTime = time.Unix(0, 0)
+		content.FileInfo.MTime = internal.SourceEpoch()
 	}
 
 	info := nfpm.WithDefaults(&nfpm.Info{
···
 		Maintainer:  fmt.Sprintf("%s <%s>", *internal.UserName, *internal.UserEmail),
 		Homepage:    p.Homepage,
 		License:     p.License,
-		MTime:       time.Unix(0, 0),
+		MTime:       internal.SourceEpoch(),
 		Overridables: nfpm.Overridables{
 			Contents:   contents,
 			Depends:    p.Depends,

internal/mkrpm/mkrpm.go

···
 			Type:        files.TypeDir,
 			Destination: d,
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 	}
···
 			Destination: rpmPath,
 			FileInfo: &files.ContentFileInfo{
 				Mode:  os.FileMode(0600),
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 	}
···
 			Source:      repoPath,
 			Destination: filepath.Join("/usr/share/doc", p.Name, rpmPath),
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 	}
···
 			Source:      repoPath,
 			Destination: rpmPath,
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 	}
···
 			Source:      path,
 			Destination: path[len(dir)+1:],
 			FileInfo: &files.ContentFileInfo{
-				MTime: time.Date(1970, time.January, 1, 0, 0, 0, 0, time.UTC),
+				MTime: internal.SourceEpoch(),
 			},
 		})
 
···
 	}
 
 	for _, content := range contents {
-		content.FileInfo.MTime = time.Unix(0, 0)
+		content.FileInfo.MTime = internal.SourceEpoch()
 	}
 
 	info := nfpm.WithDefaults(&nfpm.Info{
···
 		Maintainer:  fmt.Sprintf("%s <%s>", *internal.UserName, *internal.UserEmail),
 		Homepage:    p.Homepage,
 		License:     p.License,
-		MTime:       time.Unix(0, 0),
+		MTime:       internal.SourceEpoch(),
 		Overridables: nfpm.Overridables{
 			Contents:   contents,
 			Depends:    p.Depends,

internal/mktarball/mktarball.go

···
 		return "", fmt.Errorf("can't open root FS %s: %w", dir, err)
 	}
 
-	if err := tw.AddFS(vfs.MtimeZeroFS{FS: root.FS()}); err != nil {
+	if err := tw.AddFS(vfs.ModTimeFS{FS: root.FS(), Time: internal.SourceEpoch()}); err != nil {
 		return "", fmt.Errorf("can't copy built files to tarball: %w", err)
 	}
 

internal/mktarball/mktarball_test.go

···
 package mktarball
 
 import (
+	"archive/tar"
+	"compress/gzip"
+	"io"
+	"os"
 	"testing"
 
+	"github.com/TecharoHQ/yeet/internal"
 	"github.com/TecharoHQ/yeet/internal/yeettest"
 )
 
···
 func TestBuildError(t *testing.T) {
 	yeettest.BuildHello(t, Build, ".0.0", false)
 }
+
+func TestTimestampsNotZero(t *testing.T) {
+	pkg := yeettest.BuildHello(t, Build, "1.0.0", true)
+
+	fin, err := os.Open(pkg)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer fin.Close()
+
+	gzr, err := gzip.NewReader(fin)
+	if err != nil {
+		t.Fatal(err)
+	}
+	defer gzr.Close()
+
+	tr := tar.NewReader(gzr)
+
+	for {
+		header, err := tr.Next()
+		switch {
+		case err == io.EOF:
+			return
+		case err != nil:
+			t.Fatal(err)
+		}
+
+		expect := internal.SourceEpoch()
+
+		t.Run(header.Name, func(t *testing.T) {
+			header := header
+			if !header.ModTime.Equal(expect) {
+				t.Errorf("file has wrong timestamp %s, wanted: %s", header.ModTime, expect)
+			}
+		})
+	}
+}

internal/vfs/modtimefs.go

···
+package vfs
+
+import (
+	"io/fs"
+	"time"
+)
+
+// ModTimeFS wraps an fs.FS and overrides all file mtimes with a fixed time.
+type ModTimeFS struct {
+	fs.FS
+	Time time.Time
+}
+
+// Open overrides the FS.Open method to wrap returned files.
+func (m ModTimeFS) Open(name string) (fs.File, error) {
+	f, err := m.FS.Open(name)
+	if err != nil {
+		return nil, err
+	}
+	return &modTimeFile{File: f, Time: m.Time}, nil
+}
+
+// ReadDir implements fs.ReadDirFS if the underlying FS supports it.
+func (m ModTimeFS) ReadDir(name string) ([]fs.DirEntry, error) {
+	readDirFS, ok := m.FS.(fs.ReadDirFS)
+	if !ok {
+		return nil, &fs.PathError{Op: "ReadDir", Path: name, Err: fs.ErrInvalid}
+	}
+
+	entries, err := readDirFS.ReadDir(name)
+	if err != nil {
+		return nil, err
+	}
+
+	wrapped := make([]fs.DirEntry, len(entries))
+	for i, entry := range entries {
+		wrapped[i] = modTimeDirEntry{DirEntry: entry, Time: m.Time}
+	}
+	return wrapped, nil
+}
+
+// modTimeFile wraps fs.File to override Stat().ModTime().
+type modTimeFile struct {
+	fs.File
+	Time time.Time
+}
+
+func (f *modTimeFile) Stat() (fs.FileInfo, error) {
+	info, err := f.File.Stat()
+	if err != nil {
+		return nil, err
+	}
+	return modTimeFileInfo{FileInfo: info, Time: f.Time}, nil
+}
+
+// modTimeFileInfo overrides ModTime to return a fixed time.
+type modTimeFileInfo struct {
+	fs.FileInfo
+	Time time.Time
+}
+
+func (fi modTimeFileInfo) ModTime() time.Time {
+	return fi.Time
+}
+
+// modTimeDirEntry wraps fs.DirEntry to override Info().ModTime().
+type modTimeDirEntry struct {
+	fs.DirEntry
+	Time time.Time
+}
+
+func (d modTimeDirEntry) Info() (fs.FileInfo, error) {
+	info, err := d.DirEntry.Info()
+	if err != nil {
+		return nil, err
+	}
+	return modTimeFileInfo{FileInfo: info, Time: d.Time}, nil
+}

internal/vfs/mtimezero.go

···
-package vfs
-
-import (
-	"io/fs"
-	"time"
-)
-
-// MtimeZeroFS wraps an fs.FS and overrides all file mtimes to time.Unix(0, 0).
-type MtimeZeroFS struct {
-	fs.FS
-}
-
-// Open overrides the FS.Open method to wrap returned files.
-func (m MtimeZeroFS) Open(name string) (fs.File, error) {
-	f, err := m.FS.Open(name)
-	if err != nil {
-		return nil, err
-	}
-	return &mtimeZeroFile{File: f}, nil
-}
-
-// ReadDir implements fs.ReadDirFS if the underlying FS supports it.
-func (m MtimeZeroFS) ReadDir(name string) ([]fs.DirEntry, error) {
-	readDirFS, ok := m.FS.(fs.ReadDirFS)
-	if !ok {
-		return nil, &fs.PathError{Op: "ReadDir", Path: name, Err: fs.ErrInvalid}
-	}
-
-	entries, err := readDirFS.ReadDir(name)
-	if err != nil {
-		return nil, err
-	}
-
-	wrapped := make([]fs.DirEntry, len(entries))
-	for i, entry := range entries {
-		wrapped[i] = mtimeZeroDirEntry{DirEntry: entry}
-	}
-	return wrapped, nil
-}
-
-// mtimeZeroFile wraps fs.File to override Stat().ModTime().
-type mtimeZeroFile struct {
-	fs.File
-}
-
-func (f *mtimeZeroFile) Stat() (fs.FileInfo, error) {
-	info, err := f.File.Stat()
-	if err != nil {
-		return nil, err
-	}
-	return mtimeZeroFileInfo{FileInfo: info}, nil
-}
-
-// mtimeZeroFileInfo overrides ModTime to return time.Unix(0, 0).
-type mtimeZeroFileInfo struct {
-	fs.FileInfo
-}
-
-func (fi mtimeZeroFileInfo) ModTime() time.Time {
-	return time.Unix(0, 0)
-}
-
-// mtimeZeroDirEntry wraps fs.DirEntry to override Info().ModTime().
-type mtimeZeroDirEntry struct {
-	fs.DirEntry
-}
-
-func (d mtimeZeroDirEntry) Info() (fs.FileInfo, error) {
-	info, err := d.DirEntry.Info()
-	if err != nil {
-		return nil, err
-	}
-	return mtimeZeroFileInfo{FileInfo: info}, nil
-}