func Example_genBinaryPackage() {
ctrl := deb.NewControlDefault("testpkg", "me", "<*****@*****.**>", "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)
}
}
// Output:
//
}
func Example_genDevPackage() {
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:
//
}
func Example_genSourcePackage() {
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:
//
}
//Adds an entry to the changelog
func changelogAddEntryTask(args []string) error {
build := debgen.NewBuildParams()
fs := InitBuildFlags(cmdName+" "+TaskChangelogAdd, build)
var version string
fs.StringVar(&version, "version", "", "Package Version")
var architecture string
fs.StringVar(&architecture, "arch", "all", "Architectures [any,386,armhf,amd64,all]")
var distribution string
fs.StringVar(&distribution, "distribution", "unstable", "Distribution (unstable is recommended until Debian accept the package into testing/stable)")
var entry string
fs.StringVar(&entry, "entry", "", "Changelog entry data")
err := fs.Parse(os.Args[2:])
if err != nil {
return fmt.Errorf("Error parsing %v", err)
}
if version == "" {
return fmt.Errorf("Error: --version is a required flag")
}
if entry == "" {
return fmt.Errorf("Error: --entry is a required flag")
}
ctrl, err := changelogPrepareCtrl(version, distribution, architecture, build)
if err != nil {
return err
}
return changelogAddEntry(ctrl, build, entry)
}
func sourceGen(input []string) error {
build := debgen.NewBuildParams()
fs := InitBuildFlags(cmdName+" "+TaskGenSource, build)
var sourceDir string
fs.StringVar(&sourceDir, "sources", ".", "source dir")
var isDiscoverGoPath bool
fs.BoolVar(&isDiscoverGoPath, "discover-gopath", true, "Use Go-style path (try to discover base relative to GOPATH element)")
var sourcesGlob string
fs.StringVar(&sourcesGlob, "sources-glob", debgen.GlobGoSources, "Glob for inclusion of sources")
var destinationDir string
fs.StringVar(&destinationDir, "destination-dir", debgen.DevGoPathDefault, "Directory name to store sources in archive")
var sourcesRelativeTo string
fs.StringVar(&sourcesRelativeTo, "sources-relative-to", ".", "Sources relative to (this is ignored when -discover-gopath is selected)")
fs.StringVar(&build.Version, "version", "", "Package version")
// parse and validate flags
err := fs.Parse(os.Args[2:])
if err != nil {
return fmt.Errorf("%v", err)
}
if build.Version == "" {
return fmt.Errorf("Error: --version is a required flag")
}
if isDiscoverGoPath {
sourcesRelativeTo = debgen.GetGoPathElement(sourceDir)
}
mappedSources, err := debgen.GlobForSources(sourcesRelativeTo, sourceDir, sourcesGlob, destinationDir, []string{build.TmpDir, build.DebianDir})
if err != nil {
return fmt.Errorf("%v", err)
}
fi, err := os.Open(filepath.Join(build.DebianDir, "control"))
if err != nil {
return fmt.Errorf("%v", err)
}
cfr := deb.NewControlFileReader(fi)
ctrl, err := cfr.Parse()
if err != nil {
return fmt.Errorf("%v", err)
}
spgen, err := debgen.PrepareSourceDebGenerator(ctrl, build)
for k, v := range mappedSources {
spgen.OrigFiles[k] = v
}
if err != nil {
return fmt.Errorf("%v", err)
}
err = spgen.GenerateAllDefault()
if err != nil {
return fmt.Errorf("%v", err)
}
return err
}
func debGen(input []string) error {
build := debgen.NewBuildParams()
fs := InitBuildFlags(cmdName+" "+TaskGenDeb, build)
/*
fs.StringVar(&build.SourcesGlob, "sources-glob", "**.go", "Glob pattern for sources.")
fs.StringVar(&build.SourceDir, "sources-dir", ".", "source dir")
fs.StringVar(&build.SourcesRelativeTo, "sources-relative-to", "", "Sources relative to (it will assume relevant gopath element, unless you specify this)")
fs.StringVar(&build.Bin386Glob, "bin-386", "*386/*", "Glob pattern for binaries for the 386 platform.")
fs.StringVar(&build.BinArmhfGlob, "bin-armhf", "*armhf/*", "Glob pattern for binaries for the armhf platform.")
fs.StringVar(&build.BinAmd64Glob, "bin-amd64", "*amd64/*", "Glob pattern for binaries for the amd64 platform.")
fs.StringVar(&build.BinAnyGlob, "bin-any", "*any/*", "Glob pattern for binaries for *any* platform.")
*/
//fs.StringVar(&build.sourcesDest, "sources-dest", debgen.DevGoPathDefault+"/src", "directory containing sources.")
arches := ""
fs.StringVar(&arches, "arch-filter", "", "Filter by Architecture. Comma-separated [386,armhf,amd64,all]")
// fs.StringVar(&build.ResourcesGlob, "resources", "", "directory containing resources for this platform")
fs.StringVar(&build.Version, "version", "", "Package version")
err := fs.Parse(os.Args[2:])
if err != nil {
return fmt.Errorf("Error parsing flags: %v", err)
}
build.Arches, err = deb.ResolveArches(arches)
if err != nil {
return fmt.Errorf("Error resolving architecture: %v", err)
}
//Read control data
fi, err := os.Open(filepath.Join(build.DebianDir, "control"))
if err != nil {
return fmt.Errorf("Error reading control data: %v", err)
}
cfr := deb.NewControlFileReader(fi)
ctrl, err := cfr.Parse()
if err != nil {
return fmt.Errorf("Error reading control file: %v", err)
}
dgens, err := debgen.PrepareBasicDebGen(ctrl, build)
if err != nil {
return fmt.Errorf("Error preparing 'deb generators': %v", err)
}
for _, dgen := range dgens {
err = dgen.GenerateAllDefault()
if err != nil {
return fmt.Errorf("Error building deb: %v", err)
}
}
return nil
}
/*
func checksums(path, name string) (*Checksum, *Checksum, *Checksum, error) {
//checksums
f, err := os.Open(path)
if err != nil {
return nil, nil, nil, err
}
hashMd5 := md5.New()
size, err := io.Copy(hashMd5, f)
if err != nil {
return nil, nil, nil, err
}
checksumMd5 := Checksum{hex.EncodeToString(hashMd5.Sum(nil)), size, name}
f.Seek(int64(0), 0)
hash256 := sha256.New()
size, err = io.Copy(hash256, f)
if err != nil {
return nil, nil, nil, err
}
checksumSha256 := Checksum{hex.EncodeToString(hash256.Sum(nil)), size, name}
f.Seek(int64(0), 0)
hash1 := sha1.New()
size, err = io.Copy(hash1, f)
if err != nil {
return nil, nil, nil, err
}
checksumSha1 := Checksum{hex.EncodeToString(hash1.Sum(nil)), size, name}
err = f.Close()
if err != nil {
return nil, nil, nil, err
}
return &checksumMd5, &checksumSha1, &checksumSha256, nil
}
*/
func debSourceBuild(tp TaskParams) (err error) {
metadata := tp.Settings.GetTaskSettingMap(TASK_DEB_SOURCE, "metadata")
//armArchName := getArmArchName(tp.Settings)
metadataDebX := tp.Settings.GetTaskSettingMap(TASK_DEB_SOURCE, "metadata-deb")
otherMappedFilesFromSetting := tp.Settings.GetTaskSettingMap(TASK_DEB_GEN, "other-mapped-files")
otherMappedFiles, err := calcOtherMappedFiles(otherMappedFilesFromSetting)
if err != nil {
return err
}
metadataDeb := map[string]string{}
for k, v := range metadataDebX {
val, ok := v.(string)
if ok {
metadataDeb[k] = val
}
}
rmtemp := tp.Settings.GetTaskSettingBool(TASK_DEB_SOURCE, "rmtemp")
debDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName()) //v0.8.1 dont use platform dir
tmpDir := filepath.Join(debDir, ".goxc-temp")
shortDescription := "?"
if desc, keyExists := metadata["description"]; keyExists {
var err error
shortDescription, err = typeutils.ToString(desc, "description")
if err != nil {
return err
}
}
longDescription := " "
if ldesc, keyExists := metadata["long-description"]; keyExists {
var err error
longDescription, err = typeutils.ToString(ldesc, "long-description")
if err != nil {
return err
}
}
maintainerName := "?"
if maint, keyExists := metadata["maintainer"]; keyExists {
var err error
maintainerName, err = typeutils.ToString(maint, "maintainer")
if err != nil {
return err
}
}
maintainerEmail := "*****@*****.**"
if maintEmail, keyExists := metadata["maintainer-email"]; keyExists {
var err error
maintainerEmail, err = typeutils.ToString(maintEmail, "maintainer-email")
if err != nil {
return err
}
}
build := debgen.NewBuildParams()
build.DestDir = debDir
build.TmpDir = tmpDir
build.Init()
build.IsRmtemp = rmtemp
var ctrl *deb.Control
//Read control data. If control file doesnt exist, use parameters ...
fi, err := os.Open(filepath.Join(build.DebianDir, "control"))
if os.IsNotExist(err) {
log.Printf("WARNING - no debian 'control' file found. Use `debber` to generate proper debian metadata")
ctrl = deb.NewControlDefault(tp.AppName, maintainerName, maintainerEmail, shortDescription, longDescription, false)
} else if err != nil {
return fmt.Errorf("%v", err)
} else {
cfr := deb.NewControlFileReader(fi)
ctrl, err = cfr.Parse()
if err != nil {
return fmt.Errorf("%v", err)
}
}
goSourcesDir := tp.Settings.GetTaskSettingString(TASK_DEB_SOURCE, "go-sources-dir")
mappedSources, err := debgen.GlobForGoSources(goSourcesDir, []string{build.DestDir, build.TmpDir})
if err != nil {
return fmt.Errorf("%v", err)
}
for k, v := range mappedSources {
otherMappedFiles[k] = v
}
build.Version = tp.Settings.GetFullVersionName()
spgen, err := debgen.PrepareSourceDebGenerator(ctrl, build)
if spgen.OrigFiles == nil {
spgen.OrigFiles = map[string]string{}
}
for k, v := range otherMappedFiles {
spgen.OrigFiles[k] = v
}
if err != nil {
return fmt.Errorf("%v", err)
}
err = spgen.GenerateAllDefault()
if err != nil {
return fmt.Errorf("%v", err)
}
if tp.Settings.IsVerbose() {
log.Printf("Wrote dsc file to %s", filepath.Join(build.DestDir, spgen.SourcePackage.DscFileName))
log.Printf("Wrote orig file to %s", filepath.Join(build.DestDir, spgen.SourcePackage.OrigFileName))
log.Printf("Wrote debian file to %s", filepath.Join(build.DestDir, spgen.SourcePackage.DebianFileName))
}
return nil
}
func debBuild(dest platforms.Platform, tp TaskParams) error {
metadata := tp.Settings.GetTaskSettingMap(TASK_DEB_GEN, "metadata")
armArchName := getArmArchName(tp.Settings)
//maintain support for old configs ...
metadataDebX := tp.Settings.GetTaskSettingMap(TASK_DEB_GEN, "metadata-deb")
otherMappedFilesFromSetting := tp.Settings.GetTaskSettingMap(TASK_DEB_GEN, "other-mapped-files")
otherMappedFiles, err := calcOtherMappedFiles(otherMappedFilesFromSetting)
if err != nil {
return err
}
if tp.Settings.IsVerbose() {
log.Printf("other mapped files: %+v", otherMappedFiles)
}
metadataDeb := map[string]string{}
for k, v := range metadataDebX {
val, ok := v.(string)
if ok {
metadataDeb[k] = val
}
}
rmtemp := tp.Settings.GetTaskSettingBool(TASK_DEB_GEN, "rmtemp")
debDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName()) //v0.8.1 dont use platform dir
tmpDir := filepath.Join(debDir, ".goxc-temp")
shortDescription := "?"
if desc, keyExists := metadata["description"]; keyExists {
var err error
shortDescription, err = typeutils.ToString(desc, "description")
if err != nil {
return err
}
}
longDescription := " "
if ldesc, keyExists := metadata["long-description"]; keyExists {
var err error
longDescription, err = typeutils.ToString(ldesc, "long-description")
if err != nil {
return err
}
}
maintainerName := "?"
if maint, keyExists := metadata["maintainer"]; keyExists {
var err error
maintainerName, err = typeutils.ToString(maint, "maintainer")
if err != nil {
return err
}
}
maintainerEmail := "*****@*****.**"
if maintEmail, keyExists := metadata["maintainer-email"]; keyExists {
var err error
maintainerEmail, err = typeutils.ToString(maintEmail, "maintainer-email")
if err != nil {
return err
}
}
//'dev' Package should be a separate task
addDevPackage := false
/*
pkg := deb.NewPackage(tp.AppName, tp.Settings.GetFullVersionName(), maintainer, description)
pkg.AdditionalControlData = metadataDeb*/
build := debgen.NewBuildParams()
build.DestDir = debDir
build.TmpDir = tmpDir
build.Init()
build.IsRmtemp = rmtemp
var ctrl *deb.Control
//Read control data. If control file doesnt exist, use parameters ...
fi, err := os.Open(filepath.Join(build.DebianDir, "control"))
if os.IsNotExist(err) {
log.Printf("WARNING - no debian 'control' file found. Use `debber` to generate proper debian metadata")
ctrl = deb.NewControlDefault(tp.AppName, maintainerName, maintainerEmail, shortDescription, longDescription, addDevPackage)
} else if err != nil {
return fmt.Errorf("%v", err)
} else {
cfr := deb.NewControlFileReader(fi)
ctrl, err = cfr.Parse()
if err != nil {
return fmt.Errorf("%v", err)
}
}
debArch := getDebArch(dest.Arch, armArchName)
build.Arches = []deb.Architecture{debArch}
build.Version = tp.Settings.GetFullVersionName()
dgens, err := debgen.PrepareBasicDebGen(ctrl, build)
if err != nil {
return fmt.Errorf("Error preparing deb generator: %v", err)
}
//there should only be one for this platform.
// Anyway this part maps all binaries.
for _, dgen := range dgens {
// -dev paragraphs handled by 'deb-dev' task.
if !strings.HasSuffix(dgen.DebWriter.Control.Get(deb.PackageFName), "-dev") {
for _, mainDir := range tp.MainDirs {
var exeName string
if len(tp.MainDirs) == 1 {
exeName = tp.Settings.AppName
} else {
exeName = filepath.Base(mainDir)
}
binPath, err := core.GetAbsoluteBin(dest.Os, dest.Arch, tp.Settings.AppName, exeName, tp.WorkingDirectory, tp.Settings.GetFullVersionName(), tp.Settings.OutPath, tp.Settings.ArtifactsDest)
if err != nil {
return err
}
if dgen.DataFiles == nil {
dgen.DataFiles = map[string]string{}
}
dgen.DataFiles["./usr/bin/"+exeName] = binPath
}
for k, v := range otherMappedFiles {
dgen.DataFiles[k] = v
}
err = dgen.GenerateAllDefault()
if err != nil {
return fmt.Errorf("Error generating deb: %v", err)
}
if !tp.Settings.IsQuiet() {
log.Printf("Wrote deb to %s", filepath.Join(build.DestDir, dgen.DebWriter.Filename))
}
}
}
return err
}
func debDevBuild(tp TaskParams) error {
metadata := tp.Settings.GetTaskSettingMap(TASK_DEB_GEN, "metadata")
//maintain support for old configs ...
metadataDebX := tp.Settings.GetTaskSettingMap(TASK_DEB_GEN, "metadata-deb")
otherMappedFilesFromSetting := tp.Settings.GetTaskSettingMap(TASK_DEB_GEN, "other-mapped-files")
otherMappedFiles, err := calcOtherMappedFiles(otherMappedFilesFromSetting)
if err != nil {
return err
}
metadataDeb := map[string]string{}
for k, v := range metadataDebX {
val, ok := v.(string)
if ok {
metadataDeb[k] = val
}
}
rmtemp := tp.Settings.GetTaskSettingBool(TASK_DEB_GEN, "rmtemp")
debDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName()) //v0.8.1 dont use platform dir
tmpDir := filepath.Join(debDir, ".goxc-temp")
shortDescription := "?"
if desc, keyExists := metadata["description"]; keyExists {
var err error
shortDescription, err = typeutils.ToString(desc, "description")
if err != nil {
return err
}
}
longDescription := " "
if ldesc, keyExists := metadata["long-description"]; keyExists {
var err error
longDescription, err = typeutils.ToString(ldesc, "long-description")
if err != nil {
return err
}
}
maintainerName := "?"
if maint, keyExists := metadata["maintainer"]; keyExists {
var err error
maintainerName, err = typeutils.ToString(maint, "maintainer")
if err != nil {
return err
}
}
maintainerEmail := "*****@*****.**"
if maintEmail, keyExists := metadata["maintainer-email"]; keyExists {
var err error
maintainerEmail, err = typeutils.ToString(maintEmail, "maintainer-email")
if err != nil {
return err
}
}
//'dev' Package should be a separate task
addDevPackage := false
/*
pkg := deb.NewPackage(tp.AppName, tp.Settings.GetFullVersionName(), maintainer, description)
pkg.AdditionalControlData = metadataDeb*/
build := debgen.NewBuildParams()
build.DestDir = debDir
build.TmpDir = tmpDir
build.Init()
build.IsRmtemp = rmtemp
var ctrl *deb.Control
//Read control data. If control file doesnt exist, use parameters ...
fi, err := os.Open(filepath.Join(build.DebianDir, "control"))
if os.IsNotExist(err) {
log.Printf("WARNING - no debian 'control' file found. Use `debber` to generate proper debian metadata")
ctrl = deb.NewControlDefault(tp.AppName, maintainerName, maintainerEmail, shortDescription, longDescription, addDevPackage)
} else if err != nil {
return fmt.Errorf("%v", err)
} else {
cfr := deb.NewControlFileReader(fi)
ctrl, err = cfr.Parse()
if err != nil {
return fmt.Errorf("%v", err)
}
}
goSourcesDir := tp.Settings.GetTaskSettingString(TASK_DEB_GEN, "go-sources-dir")
mappedSources, err := debgen.GlobForGoSources(goSourcesDir, []string{build.DestDir, build.TmpDir})
if err != nil {
return fmt.Errorf("%v", err)
}
for k, v := range mappedSources {
otherMappedFiles[k] = v
}
debArch := deb.ArchAll
build.Arches = []deb.Architecture{debArch}
build.Version = tp.Settings.GetFullVersionName()
dgens, err := debgen.PrepareBasicDebGen(ctrl, build)
if err != nil {
return fmt.Errorf("Error preparing deb generator: %v", err)
}
//there should only be one for this platform.
// Anyway this part maps all binaries.
for _, dgen := range dgens {
if strings.HasSuffix(dgen.DebWriter.Control.Get(deb.PackageFName), "-dev") {
for k, v := range otherMappedFiles {
dgen.DataFiles[k] = v
}
err = dgen.GenerateAllDefault()
if err != nil {
return fmt.Errorf("Error generating deb: %v", err)
}
if !tp.Settings.IsQuiet() {
log.Printf("Wrote -dev deb to %s", filepath.Join(build.DestDir, dgen.DebWriter.Filename))
}
}
}
return err
}
func initDebber(input []string) error {
//set to nothing
ctrl := deb.NewControlEmpty()
build := debgen.NewBuildParams()
build.DestDir = "debian"
fs := InitBuildFlags(cmdName+" init", build)
var entry string
var overwrite bool
var flavour string
var pkgName, maintainerName, maintainerEmail, shortDescription, longDescription, architecture string
var license string
fs.StringVar(&pkgName, "name", "", "Package name [required]")
fs.StringVar(&maintainerName, "maintainer", "", "Maintainer name [required]")
fs.StringVar(&maintainerEmail, "maintainer-email", "", "Maintainer's email address [required]")
fs.StringVar(&shortDescription, "desc", "", "Package description [required]")
fs.StringVar(&longDescription, "long-desc", "", "Package Long description")
fs.StringVar(&entry, "entry", "Initial project import", "Changelog entry data")
fs.BoolVar(&overwrite, "overwrite", false, "Overwrite existing files")
fs.StringVar(&architecture, "architecture", "any", "Package Architecture (any)")
fs.StringVar(&license, "license", "BSD-3-clause", "License")
fs.StringVar(&flavour, "flav", "go:exe", "'flavour' implies a set of defaults - currently, one of 'go:exe', 'go:pkg', 'dev' or ''")
//TODO flavour
err := fs.Parse(os.Args[2:])
if err != nil {
return fmt.Errorf("%v", err)
}
if pkgName == "" || maintainerName == "" || maintainerEmail == "" || shortDescription == "" || longDescription == "" {
return fmt.Errorf("Required fields: --name, --maintainer, --maintainer-email, --desc, --long-desc")
}
//handle spaces in longDescription. TODO: utility function
longDescriptions := strings.Split(longDescription, "\n")
longDescription = ""
for _, ldl := range longDescriptions {
if longDescription != "" {
longDescription += "\n"
}
longDescription += " " + strings.TrimSpace(ldl)
}
(*ctrl)[0].Set(deb.SourceFName, pkgName)
(*ctrl)[0].Set(deb.MaintainerFName, fmt.Sprintf("%s <%s>", maintainerName, maintainerEmail))
(*ctrl)[0].Set(deb.DescriptionFName, fmt.Sprintf("%s\n%s", shortDescription, longDescription))
(*ctrl)[0].Set(deb.ArchitectureFName, architecture)
if len(*ctrl) < 2 {
*ctrl = append(*ctrl, deb.NewPackage())
}
(*ctrl)[1].Set(deb.PackageFName, pkgName)
(*ctrl)[1].Set(deb.DescriptionFName, fmt.Sprintf("%s\n%s", shortDescription, longDescription))
(*ctrl)[1].Set(deb.ArchitectureFName, architecture)
//-dev package. Optional somehow?
if len(*ctrl) < 3 {
*ctrl = append(*ctrl, deb.NewPackage())
}
(*ctrl)[2].Set(deb.PackageFName, pkgName+"-dev")
(*ctrl)[2].Set(deb.ArchitectureFName, "all")
(*ctrl)[2].Set(deb.DescriptionFName, fmt.Sprintf("%s - development package\n%s", shortDescription, longDescription))
deb.SetDefaults(ctrl)
if strings.HasPrefix(flavour, "go:") {
debgen.ApplyGoDefaults(ctrl)
} else {
debgen.ApplyBasicDefaults(ctrl)
}
if err == nil {
//validation ...
err = deb.ValidateControl(ctrl)
if err != nil {
println("")
fmt.Fprintf(os.Stderr, "Usage:\n")
fs.PrintDefaults()
println("")
}
}
if err != nil {
return fmt.Errorf("%v", err)
}
err = build.Init()
if err != nil {
return fmt.Errorf("Error initialising build: %v", err)
}
spkg := deb.NewSourcePackage(ctrl)
spgen := debgen.NewSourcePackageGenerator(spkg, build)
if flavour == "go:exe" {
spgen.ApplyDefaultsPureGo()
}
//create control file
filename := filepath.Join(build.DebianDir, "control")
_, err = os.Stat(filename)
if os.IsNotExist(err) || overwrite {
err = spgen.GenSourceControlFile()
if err != nil {
return fmt.Errorf("Error generating control file: %v", err)
}
} else if err != nil {
return fmt.Errorf("Error generating control file: %v", err)
} else {
log.Printf("%s already exists", filename)
}
//changelog file
filename = filepath.Join(build.DebianDir, "changelog")
_, err = os.Stat(filename)
if os.IsNotExist(err) || overwrite {
changelogAddEntry(ctrl, build, entry)
} else if err != nil {
return fmt.Errorf("Error reading existing changelog: %v", err)
} else {
log.Printf("%s already exists", filename)
}
//copyright file
filename = filepath.Join(build.DebianDir, "copyright")
_, err = os.Stat(filename)
if os.IsNotExist(err) || overwrite {
err = copyrightInit(ctrl, build, license)
if err != nil {
return err
}
} else if err != nil {
return fmt.Errorf("Error reading existing copyright file: %v", err)
} else {
log.Printf("%s already exists", filename)
}
//rules file ...
filename = filepath.Join(build.DebianDir, "rules")
_, err = os.Stat(filename)
if os.IsNotExist(err) || overwrite {
templateVars := debgen.NewTemplateData(ctrl)
tpl, err := template.New("template").Parse(spgen.TemplateStrings["rules"])
if err != nil {
return fmt.Errorf("Error parsing template: %v", err)
}
//create ..
f, err := os.Create(filename)
if err != nil {
return fmt.Errorf("Error creating file: %v", err)
}
defer f.Close()
err = tpl.Execute(f, templateVars)
if err != nil {
return fmt.Errorf("Error executing template: %v", err)
}
err = f.Close()
if err != nil {
return fmt.Errorf("Error closing written file: %v", err)
}
} else if err != nil {
return fmt.Errorf("Error reading existing rules file: %v", err)
} else {
log.Printf("%s already exists", filename)
}
return nil
}