debgen

package
v0.0.0-...-e53137b Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 1, 2020 License: BSD-3-Clause Imports: 16 Imported by: 13

Documentation

Overview

Package debgen offers a simpler means of generating .deb artifacts.

debgen uses templates to generate control files and such.

**Warning: v0.3 is currently in a state of flux. Please use `go get github.com/laher/debgo-v0.2/deb` for the time-being. Ta**

Example (GenBinaryPackage) 
package main

import (
	"github.com/debber/debber-v0.3/deb"
	"github.com/debber/debber-v0.3/debgen"
	"log"
	"os"
	"path/filepath"
)

func main() {

	ctrl := deb.NewControlDefault("testpkg", "me", "<a@me.org>", "Dummy package for doing nothing", "testpkg is a dummy package", true)
	for _, pkg := range ctrl.BinaryParas() {
		pkg.Set(deb.VersionFName, "0.0.2")
	}
	build := debgen.NewBuildParams()
	build.Init()
	build.IsRmtemp = false
	artifacts, err := deb.NewWriters(ctrl)
	if err != nil {
		log.Fatalf("Error building binary: %v", err)
	}
	artifacts[deb.ArchAmd64].MappedFiles = map[string]string{"/usr/bin/a": "_out/a.amd64"}
	artifacts[deb.ArchI386].MappedFiles = map[string]string{"/usr/bin/a": "_out/a.i386"}
	artifacts[deb.ArchArmhf].MappedFiles = map[string]string{"/usr/bin/a": "_out/a.armhf"}

	prep() //prepare files for packaging using some other means.

	for arch, artifact := range artifacts {
		log.Printf("generating artifact '%s'/%v", arch, artifact)
		dgen := debgen.NewDebGenerator(artifact, build)
		err = dgen.GenerateAllDefault()
		if err != nil {
			log.Fatalf("Error building for '%s': %v", arch, err)
		}
	}

}

func prep() error {
	exesMap := map[string][]string{
		"amd64": []string{"_out/a.amd64"},
		"i386":  []string{"_out/a.i386"},
		"armhf": []string{"_out/a.armhf"}}
	err := createExes(exesMap)
	if err != nil {
		log.Fatalf("%v", err)
	}
	return err
}

func createExes(exesMap map[string][]string) error {
	for _, exes := range exesMap {
		for _, exe := range exes {
			err := os.MkdirAll(filepath.Dir(exe), 0777)
			if err != nil {
				return err
			}
			fi, err := os.Create(exe)
			if err != nil {
				return err
			}
			_, err = fi.Write([]byte("echo 1"))
			if err != nil {
				return err
			}
			err = fi.Close()
			if err != nil {
				return err
			}
		}
	}
	return nil
}

Output:
Example (GenDevPackage) 
package main

import (
	"github.com/debber/debber-v0.3/deb"
	"github.com/debber/debber-v0.3/debgen"
	"log"
)

func main() {
	ctrl := deb.NewControlDefault("testpkg", "me", "me@a", "Dummy package for doing nothing", "testpkg is package ", true)

	spara := ctrl.GetParasByField(deb.SourceFName, "testpkg")
	bpara := ctrl.GetParasByField(deb.PackageFName, "testpkg-dev")
	nctrl := &deb.Control{spara[0], bpara[0]}

	build := debgen.NewBuildParams()
	build.IsRmtemp = false
	build.Init()
	var err error
	mappedFiles, err := debgen.GlobForGoSources(".", []string{build.TmpDir, build.DestDir})
	if err != nil {
		log.Fatalf("Error building -dev: %v", err)
	}

	artifacts, err := deb.NewWriters(nctrl)
	if err != nil {
		log.Fatalf("Error building -dev: %v", err)
	}
	for _, artifact := range artifacts {
		dgen := debgen.NewDebGenerator(artifact, build)
		dgen.DataFiles = mappedFiles
		err = dgen.GenerateAllDefault()
		if err != nil {
			log.Fatalf("Error building -dev: %v", err)
		}
	}

}

Output:
Example (GenSourcePackage) 
package main

import (
	"github.com/debber/debber-v0.3/deb"
	"github.com/debber/debber-v0.3/debgen"
	"log"
)

func main() {
	ctrl := deb.NewControlDefault("testpkg", "me", "me@a", "Dummy package for doing nothing", "testpkg is package ", true)

	build := debgen.NewBuildParams()
	build.IsRmtemp = false
	debgen.ApplyGoDefaults(ctrl)
	spkg := deb.NewSourcePackage(ctrl)
	err := build.Init()
	if err != nil {
		log.Fatalf("Error initializing dirs: %v", err)
	}
	spgen := debgen.NewSourcePackageGenerator(spkg, build)
	spgen.ApplyDefaultsPureGo()
	sourcesDestinationDir := ctrl.Get(deb.SourceFName) + "_" + ctrl.Get(deb.VersionFName)
	sourceDir := ".."
	sourcesRelativeTo := debgen.GetGoPathElement(sourceDir)
	spgen.OrigFiles, err = debgen.GlobForSources(sourcesRelativeTo, sourceDir, debgen.GlobGoSources, sourcesDestinationDir, []string{build.TmpDir, build.DestDir})
	if err != nil {
		log.Fatalf("Error resolving sources: %v", err)
	}
	err = spgen.GenerateAllDefault()

	if err != nil {
		log.Fatalf("Error building source: %v", err)
	}

}

Output:

Index

Examples

Constants

View Source 
const (
	GlobGoSources               = "*.go"
	TemplateDebianSourceFormat  = deb.FormatDefault // Debian source formaat
	TemplateDebianSourceOptions = `tar-ignore = .hg
tar-ignore = .git
tar-ignore = .bzr`  //specifies files to ignore while building.

	// The debian rules file describes how to build a 'source deb' into a binary deb. The default template here invokes debhelper scripts to automate this process for simple cases.
	TemplateDebianRulesDefault = `#!/usr/bin/make -f
# -*- makefile -*-

# Uncomment this to turn on verbose mode.
#export DH_VERBOSE=1

%:
	dh $@`

	// The debian rules file describes how to build a 'source deb' into a binary deb. This version contains a special script for building go packages.
	TemplateDebianRulesForGo = `` /* 840-byte string literal not displayed */

	// The debian control file (binary debs) defines package metadata
	TemplateBinarydebControl = `` /* 473-byte string literal not displayed */

	// The debian control file (source debs) defines general package metadata (but not version information)
	TemplateSnippetControlSourcePackage = `` /* 205-byte string literal not displayed */

	TemplateSnippetControlBinPackage = `` /* 157-byte string literal not displayed */

	TemplateSourcedebControl = `{{range .Package}}{{if .Get "Source"}}` + TemplateSnippetControlSourcePackage + `{{end}}{{if .Get "Package"}}` + TemplateSnippetControlBinPackage + `{{end}}

{{end}}`

	TemplateSnippetSourcedebControlDevPackage = `` /* 244-byte string literal not displayed */

	/*
		TemplateSourcedebControl = TemplateSnippetSourcedebControl + "\n\n" + TemplateSnippetSourcedebControlPackage
		TemplateSourcedebWithDevControl = TemplateSnippetSourcedebControl + "\n\n" + TemplateSnippetSourcedebControlPackage + "\n\n" + TemplateSnippetSourcedebControlDevPackage
	*/
	// The dsc file defines package metadata AND checksums
	TemplateDebianDsc = `` /* 777-byte string literal not displayed */

	TemplateChangelogHeader          = `{{.Package.Get "Package"}} ({{.Package.Get "Version"}}) {{.Package.Get "Status"}}; urgency=low`
	TemplateChangelogInitialEntry    = `  * Initial import`
	TemplateChangelogFooter          = ` -- {{.Package.Get "Maintainer"}}  {{.EntryDate}}`
	TemplateChangelogInitial         = TemplateChangelogHeader + "\n\n" + TemplateChangelogInitialEntry + "\n\n" + TemplateChangelogFooter
	TemplateChangelogAdditionalEntry = "\n\n" + TemplateChangelogHeader + "\n\n{{.ChangelogEntry}}\n\n" + TemplateChangelogFooter
	TemplateDebianCopyright          = `Copyright 2014 {{.Package.Get "Package"}}`
	TemplateDebianReadme             = `{{.Package.Get "Package"}}
==========

`
	TemplateCopyrightBasic = `Files: *
Copyright: {{.ExtraData.Year}} {{.Package.Get "Maintainer"}}
License: {{.ExtraData.License}}
`
	DevGoPathDefault   = "/usr/share/gocode" // This is used by existing -dev.deb packages e.g. golang-doozer-dev and golang-protobuf-dev
	GoPathExtraDefault = ":" + DevGoPathDefault

	DebianDir    = "debian"
	TplExtension = ".tpl"

	ChangelogDateLayout = "Mon, 02 Jan 2006 15:04:05 -0700"
)

Variables

View Source 
var (
	TemplateStringsSourceDefault = map[string]string{
		"control":        TemplateSourcedebControl,
		"compat":         deb.DebianCompatDefault,
		"rules":          TemplateDebianRulesDefault,
		"source/format":  TemplateDebianSourceFormat,
		"source/options": TemplateDebianSourceOptions,
		"copyright":      TemplateDebianCopyright,
		"changelog":      TemplateChangelogInitial,
		"README.debian":  TemplateDebianReadme}
)

Functions

func ApplyBasicDefaults 

func ApplyBasicDefaults(ctrl *deb.Control)

Applies non-go-specific information to packages. i.e. dependencies

func ApplyGoDefaults 

func ApplyGoDefaults(ctrl *deb.Control)

Applies go-specific information to packages. i.e. dependencies

func GetGoPathElement 

func GetGoPathElement(workingDirectory string) string

Tries to find the most relevant GOPATH element. First, tries to find an element which is a parent of the current directory. If not, it uses the first element from the GOPATH

func GlobForGoSources 

func GlobForGoSources(sourcesDir string, ignore []string) (map[string]string, error)

GlobForGoSources - Go-specific defaults for finding sources in a given dir

func GlobForSources 

func GlobForSources(sourcesRelativeDir, codeDir, glob, destinationPrefix string, ignoreFiles []string) (map[string]string, error)

GlobForSources looks for source files, and prepares their paths for inclusion on a unix-like filesystem

func TarHeader 

func TarHeader(path string, datalen int64, mode int64) *tar.Header

TarHeader is a factory for a tar header. Fixes slashes, populates ModTime

func TemplateFile 

func TemplateFile(templateFile string, vars interface{}) ([]byte, error)

func TemplateFileOrString 

func TemplateFileOrString(templateFile string, templateDefault string, vars interface{}) ([]byte, error)

func TemplateString 

func TemplateString(tplText string, vars interface{}) ([]byte, error)

Types

type BuildParams 

type BuildParams struct {
	IsVerbose  bool   // Whether to log debug information
	TmpDir     string // Directory in-which to generate intermediate files & archives
	IsRmtemp   bool   // Delete tmp dir after execution?
	DestDir    string // Where to generate .deb files and source debs (.dsc files etc)
	WorkingDir string // This is the root from which to find .go files, templates, resources, etc
	DebianDir  string // This is the debian dir which stores 'control', 'changelog' and 'rules' files

	TemplateDir  string // Optional. Only required if you're using templates
	ResourcesDir string // Optional. Only if debgo packages your resources automatically.

	/*
		SourceIncludeDir  string //In this case it's used as
		SourcesGlob       string
		SourcesRelativeTo string //special variable to ensure that e.g. GOPATH is properly set up.

		ResourceFinders []FileFinder
		SourceFinders   []FileFinder
	*/
	Version string
	Arches  []deb.Architecture
}

BuildParams provides information about a particular build

func NewBuildParams 

func NewBuildParams() *BuildParams

Factory for BuildParams. Populates defaults.

func (*BuildParams) Init 

func (bp *BuildParams) Init() error

Initialise build directories (make Temp and Dest directories)

type DebGenerator 

type DebGenerator struct {
	DebWriter              *deb.Writer
	BuildParams            *BuildParams
	DefaultTemplateStrings map[string]string
	DataFiles              map[string]string
}

DebGenerator generates source packages using templates and some overrideable behaviours

func NewDebGenerator 

func NewDebGenerator(debWriter *deb.Writer, buildParams *BuildParams) *DebGenerator

NewDebGenerator is a factory for SourcePackageGenerator.

func PrepareBasicDebGen 

func PrepareBasicDebGen(ctrl *deb.Control, build *BuildParams) ([]*DebGenerator, error)

Default flow for generating a deb

func (*DebGenerator) GenControlArchive 

func (dgen *DebGenerator) GenControlArchive() error

GenControlArchive generates control archive, using a system of templates or files.

First it attempts to find the file inside BuildParams.Resources. If that doesn't exist, it attempts to find a template in templateDir Finally, it attempts to use a string-based template.

func (*DebGenerator) GenControlFile 

func (dgen *DebGenerator) GenControlFile(cwh *TarWriterHelper, templateVars *TemplateData) error

Generates the control file based on a template

func (*DebGenerator) GenDataArchive 

func (dgen *DebGenerator) GenDataArchive() error

GenDataArchive generates the archive from files on the file system.

func (*DebGenerator) GenerateAllDefault 

func (dgen *DebGenerator) GenerateAllDefault() error

GenerateAllDefault applies the default build process. First it writes each file, then adds them to the .deb as a separate io operation.

type FileFinder 

type FileFinder struct {
	BaseDir    string //Usually set this, except for Go sources, where debber will find the base for you based on the IncludeDir
	IncludeDir string //Usually leave blank, except for Go sources.
	Glob       string //'Glob' pattern for finding files.
	Target     string //Target dir in eventual Deb file
}

type SourcePackageGenerator 

type SourcePackageGenerator struct {
	SourcePackage   *deb.SourcePackage
	BuildParams     *BuildParams
	TemplateStrings map[string]string
	//DebianFiles map[string]string
	OrigFiles map[string]string
}

SourcePackageGenerator generates source packages using templates and some overrideable behaviours

func NewSourcePackageGenerator 

func NewSourcePackageGenerator(sourcePackage *deb.SourcePackage, buildParams *BuildParams) *SourcePackageGenerator

NewSourcePackageGenerator is a factory for SourcePackageGenerator.

func PrepareSourceDebGenerator 

func PrepareSourceDebGenerator(ctrl *deb.Control, build *BuildParams) (*SourcePackageGenerator, error)

func (*SourcePackageGenerator) ApplyDefaultsPureGo 

func (spgen *SourcePackageGenerator) ApplyDefaultsPureGo()

ApplyDefaultsPureGo overrides some template variables for pure-Go packages

func (*SourcePackageGenerator) CalcChecksums 

func (spgen *SourcePackageGenerator) CalcChecksums() (*deb.Checksums, error)

func (*SourcePackageGenerator) GenDebianArchive 

func (spgen *SourcePackageGenerator) GenDebianArchive() error

GenDebianArchive builds <package>.debian.tar.gz This contains all the control data, changelog, rules, etc

func (*SourcePackageGenerator) GenDscFile 

func (spgen *SourcePackageGenerator) GenDscFile(checksums *deb.Checksums) error

func (*SourcePackageGenerator) GenOrigArchive 

func (spgen *SourcePackageGenerator) GenOrigArchive() error

GenOrigArchive builds <package>.orig.tar.gz This contains the original upstream source code and data.

func (*SourcePackageGenerator) GenSourceControlFile 

func (spgen *SourcePackageGenerator) GenSourceControlFile() error

func (*SourcePackageGenerator) GenerateAllDefault 

func (spgen *SourcePackageGenerator) GenerateAllDefault() error

GenerateAll builds all the artifacts using the default behaviour. Note that we could implement alternative methods in future (e.g. using a GenDiffArchive)

type TarWriterHelper 

type TarWriterHelper struct {
	Tw       *tar.Writer
	DirsMade []string
}

TarWriterHelper makes directories for you, and has some simple functions for adding files & folders. This can be used in conjunction with gzip compression (or others)

func NewTarWriterHelper 

func NewTarWriterHelper(tw *tar.Writer) *TarWriterHelper

func (*TarWriterHelper) AddBytes 

func (twh *TarWriterHelper) AddBytes(bytes []byte, destName string, mode int64) error

AddBytes adds a file by bytes with a given path

func (*TarWriterHelper) AddFile 

func (twh *TarWriterHelper) AddFile(sourceFile, destName string) error

TarAddFile adds a file from the file system This is just a helper function TODO: directories

func (*TarWriterHelper) AddFileOrDir 

func (twh *TarWriterHelper) AddFileOrDir(sourceFile, destName string) error

func (*TarWriterHelper) AddFiles 

func (twh *TarWriterHelper) AddFiles(resources map[string]string) error

AddFiles adds resources from file system. The key should be the destination filename. Value is the local filesystem path

func (*TarWriterHelper) AddFilesOrDirs 

func (twh *TarWriterHelper) AddFilesOrDirs(resources map[string]string) error

AddFiles adds resources from file system. The key should be the destination filename/dirname. Value is the local filesystem path

func (*TarWriterHelper) AddParentDirs 

func (twh *TarWriterHelper) AddParentDirs(filename string) error

AddParentDirs adds the necessary dirs for debian-friendly tar archives

type TemplateData 

type TemplateData struct {
	Package        *deb.Control
	Deb            *deb.Writer
	EntryDate      string
	ChangelogEntry string
	Checksums      *deb.Checksums
	ExtraData      map[string]interface{}
}

Data for templates

func NewTemplateData 

func NewTemplateData(pkg *deb.Control) *TemplateData

initialize "template data" object

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.