2018-02-05 02:53:22 +01:00
|
|
|
// Package deb implements nfpm.Packager providing .deb bindings.
|
2018-01-04 13:31:22 +01:00
|
|
|
package deb
|
|
|
|
|
|
|
|
import (
|
2018-01-10 00:03:01 +01:00
|
|
|
"archive/tar"
|
2018-01-04 13:31:22 +01:00
|
|
|
"bytes"
|
2018-01-10 00:03:01 +01:00
|
|
|
"compress/gzip"
|
2018-06-02 20:22:21 +02:00
|
|
|
"crypto/md5" // nolint:gas
|
2018-01-10 00:03:01 +01:00
|
|
|
"fmt"
|
|
|
|
"io"
|
2018-06-02 20:22:21 +02:00
|
|
|
"io/ioutil"
|
2018-01-04 13:31:22 +01:00
|
|
|
"os"
|
2018-06-02 20:22:21 +02:00
|
|
|
"path/filepath"
|
2018-01-10 00:03:01 +01:00
|
|
|
"strings"
|
2018-01-04 13:31:22 +01:00
|
|
|
"text/template"
|
2018-01-10 00:03:01 +01:00
|
|
|
"time"
|
2018-01-04 13:31:22 +01:00
|
|
|
|
2018-01-10 00:03:01 +01:00
|
|
|
"github.com/blakesmith/ar"
|
2019-10-11 22:11:28 +02:00
|
|
|
"github.com/pkg/errors"
|
|
|
|
|
2020-07-13 17:10:03 +02:00
|
|
|
"github.com/goreleaser/chglog"
|
|
|
|
|
2018-02-05 02:53:22 +01:00
|
|
|
"github.com/goreleaser/nfpm"
|
2018-01-04 13:31:22 +01:00
|
|
|
)
|
|
|
|
|
2019-03-04 14:14:05 +01:00
|
|
|
// nolint: gochecknoinits
|
2018-02-12 16:50:25 +01:00
|
|
|
func init() {
|
|
|
|
nfpm.Register("deb", Default)
|
|
|
|
}
|
2018-01-10 14:16:07 +01:00
|
|
|
|
2019-03-04 14:14:05 +01:00
|
|
|
// nolint: gochecknoglobals
|
2019-03-20 01:34:06 +01:00
|
|
|
var archToDebian = map[string]string{
|
|
|
|
"386": "i386",
|
|
|
|
"arm": "armhf",
|
2019-12-16 13:53:37 +01:00
|
|
|
"arm5": "armel",
|
|
|
|
"arm6": "armhf",
|
2019-03-20 01:34:06 +01:00
|
|
|
"arm7": "armhf",
|
|
|
|
"mipsle": "mipsel",
|
|
|
|
"ppc64le": "ppc64el",
|
2018-03-21 22:07:35 +01:00
|
|
|
}
|
|
|
|
|
2018-01-10 14:16:07 +01:00
|
|
|
// Default deb packager
|
2019-03-04 14:14:05 +01:00
|
|
|
// nolint: gochecknoglobals
|
2018-01-10 14:16:07 +01:00
|
|
|
var Default = &Deb{}
|
|
|
|
|
2020-05-13 21:24:06 +02:00
|
|
|
// Deb is a deb packager implementation.
|
2018-01-10 14:16:07 +01:00
|
|
|
type Deb struct{}
|
|
|
|
|
2020-07-09 15:16:04 +02:00
|
|
|
// ConventionalFileName returns a file name according
|
|
|
|
// to the conventions for debian packages. See:
|
|
|
|
// https://manpages.debian.org/buster/dpkg-dev/dpkg-name.1.en.html
|
|
|
|
func (*Deb) ConventionalFileName(info *nfpm.Info) string {
|
|
|
|
arch, ok := archToDebian[info.Arch]
|
|
|
|
if !ok {
|
|
|
|
arch = info.Arch
|
|
|
|
}
|
|
|
|
|
2020-07-15 15:10:29 +02:00
|
|
|
version := info.Version
|
|
|
|
if info.Release != "" {
|
|
|
|
version += "-" + info.Release
|
|
|
|
}
|
|
|
|
if info.Prerelease != "" {
|
|
|
|
version += "~" + info.Prerelease
|
|
|
|
}
|
|
|
|
|
2020-07-09 15:16:04 +02:00
|
|
|
// package_version_architecture.package-type
|
2020-07-15 15:10:29 +02:00
|
|
|
return fmt.Sprintf("%s_%s_%s.deb", info.Name, version, arch)
|
2020-07-09 15:16:04 +02:00
|
|
|
}
|
|
|
|
|
2020-05-13 21:24:06 +02:00
|
|
|
// Package writes a new deb package to the given writer using the given info.
|
2019-10-11 22:11:28 +02:00
|
|
|
func (*Deb) Package(info *nfpm.Info, deb io.Writer) (err error) {
|
2019-03-20 01:34:06 +01:00
|
|
|
arch, ok := archToDebian[info.Arch]
|
2018-03-21 22:07:35 +01:00
|
|
|
if ok {
|
|
|
|
info.Arch = arch
|
|
|
|
}
|
2018-02-25 18:56:29 +01:00
|
|
|
dataTarGz, md5sums, instSize, err := createDataTarGz(info)
|
2018-01-04 13:31:22 +01:00
|
|
|
if err != nil {
|
2018-01-10 00:03:01 +01:00
|
|
|
return err
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
2018-02-25 18:56:29 +01:00
|
|
|
controlTarGz, err := createControl(instSize, md5sums, info)
|
2018-01-04 13:31:22 +01:00
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-01-10 14:05:54 +01:00
|
|
|
var w = ar.NewWriter(deb)
|
2018-01-10 00:03:01 +01:00
|
|
|
if err := w.WriteGlobalHeader(); err != nil {
|
2018-02-12 17:09:59 +01:00
|
|
|
return errors.Wrap(err, "cannot write ar header to deb file")
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
2018-02-25 18:56:29 +01:00
|
|
|
if err := addArFile(w, "debian-binary", []byte("2.0\n")); err != nil {
|
2018-02-12 17:09:59 +01:00
|
|
|
return errors.Wrap(err, "cannot pack debian-binary")
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
2018-02-25 18:56:29 +01:00
|
|
|
if err := addArFile(w, "control.tar.gz", controlTarGz); err != nil {
|
2018-02-12 17:09:59 +01:00
|
|
|
return errors.Wrap(err, "cannot add control.tar.gz to deb")
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2018-02-25 18:56:29 +01:00
|
|
|
if err := addArFile(w, "data.tar.gz", dataTarGz); err != nil {
|
2018-02-12 17:09:59 +01:00
|
|
|
return errors.Wrap(err, "cannot add data.tar.gz to deb")
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
|
|
|
return nil
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
|
|
|
|
2018-02-25 18:56:29 +01:00
|
|
|
func addArFile(w *ar.Writer, name string, body []byte) error {
|
2018-01-10 00:03:01 +01:00
|
|
|
var header = ar.Header{
|
2018-07-09 03:38:03 +02:00
|
|
|
Name: filepath.ToSlash(name),
|
2018-01-10 00:03:01 +01:00
|
|
|
Size: int64(len(body)),
|
|
|
|
Mode: 0644,
|
2018-02-25 18:56:29 +01:00
|
|
|
ModTime: time.Now(),
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
2018-01-10 00:03:01 +01:00
|
|
|
if err := w.WriteHeader(&header); err != nil {
|
2018-02-12 17:09:59 +01:00
|
|
|
return errors.Wrap(err, "cannot write file header")
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
|
|
|
_, err := w.Write(body)
|
2018-01-04 13:31:22 +01:00
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
2019-10-11 22:11:28 +02:00
|
|
|
func createDataTarGz(info *nfpm.Info) (dataTarGz, md5sums []byte, instSize int64, err error) {
|
2018-01-10 00:03:01 +01:00
|
|
|
var buf bytes.Buffer
|
|
|
|
var compress = gzip.NewWriter(&buf)
|
|
|
|
var out = tar.NewWriter(compress)
|
2018-02-16 02:58:37 +01:00
|
|
|
|
|
|
|
// the writers are properly closed later, this is just in case that we have
|
|
|
|
// an error in another part of the code.
|
|
|
|
defer out.Close() // nolint: errcheck
|
|
|
|
defer compress.Close() // nolint: errcheck
|
2018-01-10 00:03:01 +01:00
|
|
|
|
2018-02-25 19:17:55 +01:00
|
|
|
var created = map[string]bool{}
|
2018-05-17 02:27:03 +02:00
|
|
|
if err = createEmptyFoldersInsideTarGz(info, out, created); err != nil {
|
2018-05-17 02:14:35 +02:00
|
|
|
return nil, nil, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
md5buf, instSize, err := createFilesInsideTarGz(info, out, created)
|
|
|
|
if err != nil {
|
|
|
|
return nil, nil, 0, err
|
2018-05-17 01:59:24 +02:00
|
|
|
}
|
2018-02-25 19:17:55 +01:00
|
|
|
|
2020-07-30 04:20:50 +02:00
|
|
|
if err := createSymlinksInsideTarGz(info, out, created); err != nil {
|
|
|
|
return nil, nil, 0, err
|
|
|
|
}
|
|
|
|
|
2018-05-17 02:14:35 +02:00
|
|
|
if err := out.Close(); err != nil {
|
|
|
|
return nil, nil, 0, errors.Wrap(err, "closing data.tar.gz")
|
|
|
|
}
|
|
|
|
if err := compress.Close(); err != nil {
|
|
|
|
return nil, nil, 0, errors.Wrap(err, "closing data.tar.gz")
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf.Bytes(), md5buf.Bytes(), instSize, nil
|
|
|
|
}
|
|
|
|
|
2020-07-30 04:20:50 +02:00
|
|
|
func createSymlinksInsideTarGz(info *nfpm.Info, out *tar.Writer, created map[string]bool) error {
|
|
|
|
for src, dst := range info.Symlinks {
|
|
|
|
if err := createTree(out, src, created); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
|
|
|
|
err := newItemInsideTarGz(out, []byte{}, &tar.Header{
|
|
|
|
Name: src,
|
|
|
|
Linkname: dst,
|
|
|
|
Typeflag: tar.TypeSymlink,
|
|
|
|
ModTime: time.Now(),
|
|
|
|
Format: tar.FormatGNU,
|
|
|
|
})
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2019-10-11 22:11:28 +02:00
|
|
|
func createFilesInsideTarGz(info *nfpm.Info, out *tar.Writer, created map[string]bool) (bytes.Buffer, int64, error) {
|
2018-01-10 00:03:01 +01:00
|
|
|
var md5buf bytes.Buffer
|
2018-05-17 02:14:35 +02:00
|
|
|
var instSize int64
|
2020-05-14 14:46:46 +02:00
|
|
|
|
|
|
|
files, err := info.FilesToCopy()
|
|
|
|
if err != nil {
|
|
|
|
return md5buf, 0, err
|
|
|
|
}
|
|
|
|
for _, file := range files {
|
2020-07-13 17:10:03 +02:00
|
|
|
if err = createTree(out, file.Destination, created); err != nil {
|
2020-05-14 14:46:46 +02:00
|
|
|
return md5buf, 0, err
|
|
|
|
}
|
2020-07-13 17:10:03 +02:00
|
|
|
|
|
|
|
var size int64 // declare early to avoid shadowing err
|
|
|
|
size, err = copyToTarAndDigest(out, &md5buf, file.Source, file.Destination)
|
2020-05-14 14:46:46 +02:00
|
|
|
if err != nil {
|
|
|
|
return md5buf, 0, err
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2020-05-14 14:46:46 +02:00
|
|
|
instSize += size
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2020-07-13 17:10:03 +02:00
|
|
|
|
|
|
|
if info.Changelog != "" {
|
|
|
|
changelog, err := createChangelog(info)
|
|
|
|
if err != nil {
|
|
|
|
return md5buf, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
// https://www.debian.org/doc/manuals/developers-reference/pkgs.de.html#recording-changes-in-the-package
|
|
|
|
changelogName := fmt.Sprintf("/usr/share/doc/%s/changelog.gz", info.Name)
|
|
|
|
if err = createTree(out, changelogName, created); err != nil {
|
|
|
|
return md5buf, 0, err
|
|
|
|
}
|
|
|
|
|
|
|
|
var digest = md5.New() // nolint:gas
|
|
|
|
if _, err = fmt.Fprintf(&md5buf, "%x %s\n", digest.Sum(nil), changelog); err != nil {
|
|
|
|
return md5buf, instSize, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err = newFileInsideTarGz(out, changelogName, changelog); err != nil {
|
|
|
|
return md5buf, instSize, err
|
|
|
|
}
|
|
|
|
|
|
|
|
instSize += int64(len(changelog))
|
|
|
|
}
|
|
|
|
|
2018-05-17 02:14:35 +02:00
|
|
|
return md5buf, instSize, nil
|
|
|
|
}
|
2018-01-10 00:03:01 +01:00
|
|
|
|
2019-10-11 22:11:28 +02:00
|
|
|
func createEmptyFoldersInsideTarGz(info *nfpm.Info, out *tar.Writer, created map[string]bool) error {
|
2018-05-17 02:14:35 +02:00
|
|
|
for _, folder := range info.EmptyFolders {
|
|
|
|
// this .nope is actually not created, because createTree ignore the
|
|
|
|
// last part of the path, assuming it is a file.
|
|
|
|
// TODO: should probably refactor this
|
|
|
|
if err := createTree(out, filepath.Join(folder, ".nope"), created); err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2018-05-17 02:14:35 +02:00
|
|
|
return nil
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
|
|
|
|
2018-02-25 18:56:29 +01:00
|
|
|
func copyToTarAndDigest(tarw *tar.Writer, md5w io.Writer, src, dst string) (int64, error) {
|
2018-09-12 18:17:59 +02:00
|
|
|
file, err := os.OpenFile(src, os.O_RDONLY, 0600) //nolint:gosec
|
2018-02-16 03:12:54 +01:00
|
|
|
if err != nil {
|
|
|
|
return 0, errors.Wrap(err, "could not add file to the archive")
|
|
|
|
}
|
|
|
|
// don't care if it errs while closing...
|
2020-05-13 21:24:06 +02:00
|
|
|
defer file.Close() // nolint: errcheck,gosec
|
2018-02-16 03:12:54 +01:00
|
|
|
info, err := file.Stat()
|
|
|
|
if err != nil {
|
|
|
|
return 0, err
|
|
|
|
}
|
|
|
|
if info.IsDir() {
|
2018-02-25 19:17:55 +01:00
|
|
|
// TODO: this should probably return an error
|
2018-02-16 03:12:54 +01:00
|
|
|
return 0, nil
|
|
|
|
}
|
|
|
|
var header = tar.Header{
|
2018-07-09 03:38:03 +02:00
|
|
|
Name: filepath.ToSlash(dst[1:]),
|
2018-02-16 03:12:54 +01:00
|
|
|
Size: info.Size(),
|
|
|
|
Mode: int64(info.Mode()),
|
2018-02-25 18:56:29 +01:00
|
|
|
ModTime: time.Now(),
|
|
|
|
Format: tar.FormatGNU,
|
2018-02-16 03:12:54 +01:00
|
|
|
}
|
|
|
|
if err := tarw.WriteHeader(&header); err != nil {
|
2018-09-12 17:58:41 +02:00
|
|
|
return 0, errors.Wrapf(err, "cannot write header of %s to data.tar.gz", src)
|
2018-02-16 03:12:54 +01:00
|
|
|
}
|
2018-06-02 20:22:21 +02:00
|
|
|
var digest = md5.New() // nolint:gas
|
2018-02-16 03:12:54 +01:00
|
|
|
if _, err := io.Copy(tarw, io.TeeReader(file, digest)); err != nil {
|
|
|
|
return 0, errors.Wrap(err, "failed to copy")
|
|
|
|
}
|
2018-02-25 17:06:58 +01:00
|
|
|
if _, err := fmt.Fprintf(md5w, "%x %s\n", digest.Sum(nil), header.Name); err != nil {
|
2018-02-16 03:12:54 +01:00
|
|
|
return 0, errors.Wrap(err, "failed to write md5")
|
|
|
|
}
|
|
|
|
return info.Size(), nil
|
|
|
|
}
|
|
|
|
|
2020-07-13 17:10:03 +02:00
|
|
|
func createChangelog(info *nfpm.Info) (chglogTarGz []byte, err error) {
|
|
|
|
var buf bytes.Buffer
|
|
|
|
var out = gzip.NewWriter(&buf)
|
|
|
|
// the writers are properly closed later, this is just in case that we have
|
|
|
|
// an error in another part of the code.
|
|
|
|
defer out.Close() // nolint: errcheck
|
|
|
|
|
|
|
|
chglogData, err := formatChangelog(info)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if _, err = out.Write([]byte(chglogData)); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
if err := out.Close(); err != nil {
|
|
|
|
return nil, errors.Wrap(err, "closing changelog.gz")
|
|
|
|
}
|
|
|
|
|
|
|
|
return buf.Bytes(), nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func formatChangelog(info *nfpm.Info) (string, error) {
|
2020-07-15 14:21:52 +02:00
|
|
|
changelog, err := info.GetChangeLog()
|
2020-07-13 17:10:03 +02:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
|
|
|
tpl, err := chglog.DebTemplate()
|
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2020-07-15 14:21:52 +02:00
|
|
|
formattedChangelog, err := chglog.FormatChangelog(changelog, tpl)
|
2020-07-13 17:10:03 +02:00
|
|
|
if err != nil {
|
|
|
|
return "", err
|
|
|
|
}
|
|
|
|
|
2020-07-15 14:21:52 +02:00
|
|
|
return strings.TrimSpace(formattedChangelog) + "\n", nil
|
2020-07-13 17:10:03 +02:00
|
|
|
}
|
|
|
|
|
2020-07-27 18:22:06 +02:00
|
|
|
// nolint:funlen
|
2019-10-11 22:11:28 +02:00
|
|
|
func createControl(instSize int64, md5sums []byte, info *nfpm.Info) (controlTarGz []byte, err error) {
|
2018-01-10 00:03:01 +01:00
|
|
|
var buf bytes.Buffer
|
|
|
|
var compress = gzip.NewWriter(&buf)
|
|
|
|
var out = tar.NewWriter(compress)
|
2018-02-16 02:58:37 +01:00
|
|
|
// the writers are properly closed later, this is just in case that we have
|
|
|
|
// an error in another part of the code.
|
|
|
|
defer out.Close() // nolint: errcheck
|
|
|
|
defer compress.Close() // nolint: errcheck
|
2018-01-10 00:03:01 +01:00
|
|
|
|
|
|
|
var body bytes.Buffer
|
2020-07-13 17:10:03 +02:00
|
|
|
if err = writeControl(&body, controlData{
|
2018-01-10 00:03:01 +01:00
|
|
|
Info: info,
|
|
|
|
InstalledSize: instSize / 1024,
|
|
|
|
}); err != nil {
|
|
|
|
return nil, err
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
2018-02-17 21:49:09 +01:00
|
|
|
|
2020-07-13 17:10:03 +02:00
|
|
|
filesToCreate := map[string][]byte{
|
2018-02-17 21:49:09 +01:00
|
|
|
"control": body.Bytes(),
|
|
|
|
"md5sums": md5sums,
|
|
|
|
"conffiles": conffiles(info),
|
2020-07-13 17:10:03 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
if info.Changelog != "" {
|
|
|
|
changeLogData, err := formatChangelog(info)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
|
|
|
filesToCreate["changelog"] = []byte(changeLogData)
|
|
|
|
}
|
|
|
|
|
2020-07-27 18:22:06 +02:00
|
|
|
triggers := createTriggers(info)
|
|
|
|
if len(triggers) > 0 {
|
|
|
|
filesToCreate["triggers"] = triggers
|
|
|
|
}
|
|
|
|
|
2020-07-13 17:10:03 +02:00
|
|
|
for name, content := range filesToCreate {
|
2018-02-25 18:56:29 +01:00
|
|
|
if err := newFileInsideTarGz(out, name, content); err != nil {
|
2018-02-17 21:49:09 +01:00
|
|
|
return nil, err
|
|
|
|
}
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2018-02-17 21:49:09 +01:00
|
|
|
|
2018-04-08 20:43:09 +02:00
|
|
|
for script, dest := range map[string]string{
|
2019-08-31 15:21:28 +02:00
|
|
|
info.Scripts.PreInstall: "preinst",
|
|
|
|
info.Scripts.PostInstall: "postinst",
|
|
|
|
info.Scripts.PreRemove: "prerm",
|
|
|
|
info.Scripts.PostRemove: "postrm",
|
|
|
|
info.Overridables.Deb.Scripts.Rules: "rules",
|
2018-04-08 20:43:09 +02:00
|
|
|
} {
|
|
|
|
if script != "" {
|
|
|
|
if err := newScriptInsideTarGz(out, script, dest); err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2018-02-17 21:49:09 +01:00
|
|
|
if err := out.Close(); err != nil {
|
|
|
|
return nil, errors.Wrap(err, "closing control.tar.gz")
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2018-02-17 21:49:09 +01:00
|
|
|
if err := compress.Close(); err != nil {
|
|
|
|
return nil, errors.Wrap(err, "closing control.tar.gz")
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2018-02-17 21:49:09 +01:00
|
|
|
return buf.Bytes(), nil
|
|
|
|
}
|
2018-01-10 00:03:01 +01:00
|
|
|
|
2019-10-11 22:11:28 +02:00
|
|
|
func newItemInsideTarGz(out *tar.Writer, content []byte, header *tar.Header) error {
|
|
|
|
if err := out.WriteHeader(header); err != nil {
|
2018-04-08 20:43:09 +02:00
|
|
|
return errors.Wrapf(err, "cannot write header of %s file to control.tar.gz", header.Name)
|
|
|
|
}
|
|
|
|
if _, err := out.Write(content); err != nil {
|
|
|
|
return errors.Wrapf(err, "cannot write %s file to control.tar.gz", header.Name)
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
2018-02-25 18:56:29 +01:00
|
|
|
func newFileInsideTarGz(out *tar.Writer, name string, content []byte) error {
|
2019-10-11 22:11:28 +02:00
|
|
|
return newItemInsideTarGz(out, content, &tar.Header{
|
2018-07-09 03:38:03 +02:00
|
|
|
Name: filepath.ToSlash(name),
|
2018-02-17 21:49:09 +01:00
|
|
|
Size: int64(len(content)),
|
2018-01-10 00:03:01 +01:00
|
|
|
Mode: 0644,
|
2018-02-25 18:56:29 +01:00
|
|
|
ModTime: time.Now(),
|
2018-01-10 00:03:01 +01:00
|
|
|
Typeflag: tar.TypeReg,
|
2018-02-25 18:56:29 +01:00
|
|
|
Format: tar.FormatGNU,
|
2018-04-08 20:43:09 +02:00
|
|
|
})
|
|
|
|
}
|
|
|
|
|
2019-10-11 22:11:28 +02:00
|
|
|
func newScriptInsideTarGz(out *tar.Writer, path, dest string) error {
|
2018-09-12 18:17:59 +02:00
|
|
|
file, err := os.Open(path) //nolint:gosec
|
2018-04-08 20:43:09 +02:00
|
|
|
if err != nil {
|
|
|
|
return err
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2018-04-08 20:43:09 +02:00
|
|
|
content, err := ioutil.ReadAll(file)
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2018-01-10 00:03:01 +01:00
|
|
|
}
|
2019-10-11 22:11:28 +02:00
|
|
|
return newItemInsideTarGz(out, content, &tar.Header{
|
2018-07-09 03:38:03 +02:00
|
|
|
Name: filepath.ToSlash(dest),
|
2018-04-08 20:43:09 +02:00
|
|
|
Size: int64(len(content)),
|
2018-04-08 22:11:20 +02:00
|
|
|
Mode: 0755,
|
2018-04-08 20:43:09 +02:00
|
|
|
ModTime: time.Now(),
|
|
|
|
Typeflag: tar.TypeReg,
|
|
|
|
Format: tar.FormatGNU,
|
|
|
|
})
|
2018-02-17 21:49:09 +01:00
|
|
|
}
|
2018-01-10 00:03:01 +01:00
|
|
|
|
2018-02-25 21:29:24 +01:00
|
|
|
// this is needed because the data.tar.gz file should have the empty folders
|
|
|
|
// as well, so we walk through the dst and create all subfolders.
|
|
|
|
func createTree(tarw *tar.Writer, dst string, created map[string]bool) error {
|
|
|
|
for _, path := range pathsToCreate(dst) {
|
|
|
|
if created[path] {
|
|
|
|
// skipping dir that was previously created inside the archive
|
|
|
|
// (eg: usr/)
|
|
|
|
continue
|
|
|
|
}
|
|
|
|
if err := tarw.WriteHeader(&tar.Header{
|
2018-07-09 03:38:03 +02:00
|
|
|
Name: filepath.ToSlash(path + "/"),
|
2018-02-25 21:29:24 +01:00
|
|
|
Mode: 0755,
|
|
|
|
Typeflag: tar.TypeDir,
|
|
|
|
Format: tar.FormatGNU,
|
|
|
|
ModTime: time.Now(),
|
|
|
|
}); err != nil {
|
|
|
|
return errors.Wrap(err, "failed to create folder")
|
|
|
|
}
|
|
|
|
created[path] = true
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func pathsToCreate(dst string) []string {
|
|
|
|
var paths = []string{}
|
|
|
|
var base = dst[1:]
|
|
|
|
for {
|
|
|
|
base = filepath.Dir(base)
|
|
|
|
if base == "." {
|
|
|
|
break
|
|
|
|
}
|
|
|
|
paths = append(paths, base)
|
|
|
|
}
|
|
|
|
// we don't really need to create those things in order apparently, but,
|
2018-05-17 01:59:24 +02:00
|
|
|
// it looks really weird if we don't.
|
2018-02-25 21:29:24 +01:00
|
|
|
var result = []string{}
|
|
|
|
for i := len(paths) - 1; i >= 0; i-- {
|
|
|
|
result = append(result, paths[i])
|
|
|
|
}
|
|
|
|
return result
|
|
|
|
}
|
|
|
|
|
2019-10-11 22:11:28 +02:00
|
|
|
func conffiles(info *nfpm.Info) []byte {
|
2018-07-09 04:42:58 +02:00
|
|
|
// nolint: prealloc
|
2018-02-17 21:49:09 +01:00
|
|
|
var confs []string
|
|
|
|
for _, dst := range info.ConfigFiles {
|
|
|
|
confs = append(confs, dst)
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
2018-02-17 21:49:09 +01:00
|
|
|
return []byte(strings.Join(confs, "\n") + "\n")
|
2018-01-04 13:31:22 +01:00
|
|
|
}
|
2018-02-25 21:29:24 +01:00
|
|
|
|
2020-07-27 18:22:06 +02:00
|
|
|
func createTriggers(info *nfpm.Info) []byte {
|
|
|
|
var buffer bytes.Buffer
|
|
|
|
|
|
|
|
// https://man7.org/linux/man-pages/man5/deb-triggers.5.html
|
|
|
|
triggerEntries := []struct {
|
|
|
|
Directive string
|
|
|
|
TriggerNames *[]string
|
|
|
|
}{
|
|
|
|
{"interest", &info.Deb.Triggers.Interest},
|
|
|
|
{"interest-await", &info.Deb.Triggers.InterestAwait},
|
|
|
|
{"interest-noawait", &info.Deb.Triggers.InterestNoAwait},
|
|
|
|
{"activate", &info.Deb.Triggers.Activate},
|
|
|
|
{"activate-await", &info.Deb.Triggers.ActivateAwait},
|
|
|
|
{"activate-noawait", &info.Deb.Triggers.ActivateNoAwait},
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, triggerEntry := range triggerEntries {
|
|
|
|
for _, triggerName := range *triggerEntry.TriggerNames {
|
|
|
|
fmt.Fprintf(&buffer, "%s %s\n", triggerEntry.Directive, triggerName)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
return buffer.Bytes()
|
|
|
|
}
|
|
|
|
|
2019-03-04 14:14:05 +01:00
|
|
|
const controlTemplate = `
|
2019-03-03 23:40:31 +01:00
|
|
|
{{- /* Mandatory fields */ -}}
|
|
|
|
Package: {{.Info.Name}}
|
2019-10-10 03:11:58 +02:00
|
|
|
Version: {{ if .Info.Epoch}}{{ .Info.Epoch }}:{{ end }}{{.Info.Version}}
|
2020-02-18 14:49:10 +01:00
|
|
|
{{- if .Info.Release}}-{{ .Info.Release }}{{- end }}
|
|
|
|
{{- if .Info.Prerelease}}~{{ .Info.Prerelease }}{{- end }}
|
2019-10-10 03:11:58 +02:00
|
|
|
{{- if .Info.Deb.VersionMetadata}}+{{ .Info.Deb.VersionMetadata }}{{- end }}
|
2018-02-25 21:29:24 +01:00
|
|
|
Section: {{.Info.Section}}
|
|
|
|
Priority: {{.Info.Priority}}
|
|
|
|
Architecture: {{.Info.Arch}}
|
2019-03-03 23:40:31 +01:00
|
|
|
{{- /* Optional fields */ -}}
|
|
|
|
{{- if .Info.Maintainer}}
|
2018-02-25 21:29:24 +01:00
|
|
|
Maintainer: {{.Info.Maintainer}}
|
2019-03-03 23:40:31 +01:00
|
|
|
{{- end }}
|
|
|
|
{{- if .Info.Vendor}}
|
2018-02-25 21:29:24 +01:00
|
|
|
Vendor: {{.Info.Vendor}}
|
2019-03-03 23:40:31 +01:00
|
|
|
{{- end }}
|
2019-08-31 15:21:28 +02:00
|
|
|
Installed-Size: {{.InstalledSize}}
|
2018-03-10 18:41:41 +01:00
|
|
|
{{- with .Info.Replaces}}
|
|
|
|
Replaces: {{join .}}
|
|
|
|
{{- end }}
|
|
|
|
{{- with .Info.Provides}}
|
|
|
|
Provides: {{join .}}
|
|
|
|
{{- end }}
|
|
|
|
{{- with .Info.Depends}}
|
|
|
|
Depends: {{join .}}
|
|
|
|
{{- end }}
|
|
|
|
{{- with .Info.Recommends}}
|
|
|
|
Recommends: {{join .}}
|
|
|
|
{{- end }}
|
|
|
|
{{- with .Info.Suggests}}
|
|
|
|
Suggests: {{join .}}
|
|
|
|
{{- end }}
|
|
|
|
{{- with .Info.Conflicts}}
|
|
|
|
Conflicts: {{join .}}
|
|
|
|
{{- end }}
|
2019-03-03 23:40:31 +01:00
|
|
|
{{- if .Info.Homepage}}
|
2018-02-25 21:29:24 +01:00
|
|
|
Homepage: {{.Info.Homepage}}
|
2019-03-03 23:40:31 +01:00
|
|
|
{{- end }}
|
|
|
|
{{- /* Mandatory fields */}}
|
2020-02-18 14:15:42 +01:00
|
|
|
Description: {{multiline .Info.Description}}
|
2018-02-25 21:29:24 +01:00
|
|
|
`
|
|
|
|
|
|
|
|
type controlData struct {
|
2019-10-11 22:11:28 +02:00
|
|
|
Info *nfpm.Info
|
2018-02-25 21:29:24 +01:00
|
|
|
InstalledSize int64
|
|
|
|
}
|
|
|
|
|
|
|
|
func writeControl(w io.Writer, data controlData) error {
|
|
|
|
var tmpl = template.New("control")
|
|
|
|
tmpl.Funcs(template.FuncMap{
|
|
|
|
"join": func(strs []string) string {
|
|
|
|
return strings.Trim(strings.Join(strs, ", "), " ")
|
|
|
|
},
|
2020-02-18 14:15:42 +01:00
|
|
|
"multiline": func(strs string) string {
|
|
|
|
ret := strings.ReplaceAll(strs, "\n", "\n ")
|
|
|
|
return strings.Trim(ret, " \n")
|
|
|
|
},
|
2018-02-25 21:29:24 +01:00
|
|
|
})
|
|
|
|
return template.Must(tmpl.Parse(controlTemplate)).Execute(w, data)
|
|
|
|
}
|