func (s *Settings) GetTaskSettingString(taskName, settingName string) string {
retUntyped := s.GetTaskSetting(taskName, settingName)
if retUntyped == nil {
return ""
}
str, err := typeutils.ToString(retUntyped, taskName+"."+settingName)
if err != nil {
//already logged
}
return str
}
func loadJsonFileAsMap(jsonFile string, verbose bool) (map[string]interface{}, error) {
var f map[string]interface{}
rawJson, err := loadFile(jsonFile, verbose)
if err != nil {
return f, err
}
errs := validateRawJson(rawJson, jsonFile)
if errs != nil && len(errs) > 0 {
return f, errs[0]
}
//TODO: super-verbose option for logging file content? log.Printf("%s\n", string(file))
err = json.Unmarshal(rawJson, &f)
if err != nil {
log.Printf("ERROR (%s): invalid json!", jsonFile)
printErrorDetails(rawJson, err)
} else {
//it was known as FormatVersion until v0.9
if fv, keyExists := f["FormatVersion"]; keyExists {
f["ConfigVersion"] = fv
}
//fill all the way down.
if fv, keyExists := f["ConfigVersion"]; keyExists {
if s, keyExists := f["Settings"]; keyExists {
//Support for old versions, up until version 0.5.
settingsSection, err := typeutils.ToMap(s, "Settings")
if err != nil {
return f, err
} else {
if _, keyExists = settingsSection["ConfigVersion"]; !keyExists {
//set from jsonSettings
//it was previously known as FormatVersion ...
formatVersion, err := typeutils.ToString(fv, "FormatVersion")
if err != nil {
return f, err
}
settingsSection["ConfigVersion"] = formatVersion
}
return settingsSection, err
}
//settings, err := loadSettingsSection(settingsSection)
//return settings, err
}
} else {
return f, errors.New("File format version not specified!")
}
}
return f, err
}
func buildSettingsFromMap(m map[string]interface{}) (*BuildSettings, error) {
var err error
bs := BuildSettings{}
FillBuildSettingsDefaults(&bs)
for k, v := range m {
switch k {
//case "GoRoot":
// bs.GoRoot, err = typeutils.ToString(v, k)
case "Processors":
var fp float64
fp, err = typeutils.ToFloat64(v, k)
if err == nil {
processors := int(fp)
bs.Processors = &processors
}
case "Race":
var race bool
race, err = typeutils.ToBool(v, k)
if err == nil {
bs.Race = &race
}
case "Verbose":
var verbose bool
verbose, err = typeutils.ToBool(v, k)
if err == nil {
bs.Verbose = &verbose
}
case "PrintCommands":
var printCommands bool
printCommands, err = typeutils.ToBool(v, k)
if err == nil {
bs.PrintCommands = &printCommands
}
case "CcFlags":
var ccFlags string
ccFlags, err = typeutils.ToString(v, k)
if err == nil {
bs.CcFlags = &ccFlags
}
case "Compiler":
var s string
s, err = typeutils.ToString(v, k)
if err == nil {
bs.Compiler = &s
}
case "GccGoFlags":
var s string
s, err = typeutils.ToString(v, k)
if err == nil {
bs.GccGoFlags = &s
}
case "GcFlags":
var s string
s, err = typeutils.ToString(v, k)
if err == nil {
bs.GcFlags = &s
}
case "InstallSuffix":
var s string
s, err = typeutils.ToString(v, k)
if err == nil {
bs.InstallSuffix = &s
}
case "LdFlags":
var s string
s, err = typeutils.ToString(v, k)
if err == nil {
bs.LdFlags = &s
}
case "Tags":
var s string
s, err = typeutils.ToString(v, k)
if err == nil {
bs.Tags = &s
}
case "LdFlagsXVars":
var xVars map[string]interface{}
xVars, err = typeutils.ToMap(v, k)
if err == nil {
bs.LdFlagsXVars = &xVars
}
case "ExtraArgs":
bs.ExtraArgs, err = typeutils.ToStringSlice(v, k)
default:
log.Printf("Warning!! Unrecognised Setting '%s' (value %v)", k, v)
}
if err != nil {
return &bs, err
}
}
return &bs, err
}
func debBuild(dest platforms.Platform, tp TaskParams) (err error) {
metadata := tp.Settings.GetTaskSettingMap(TASK_PKG_BUILD, "metadata")
armArchName := getArmArchName(tp.Settings)
metadataDeb := tp.Settings.GetTaskSettingMap(TASK_PKG_BUILD, "metadata-deb")
rmtemp := tp.Settings.GetTaskSettingBool(TASK_PKG_BUILD, "rmtemp")
debDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName()) //v0.8.1 dont use platform dir
tmpDir := filepath.Join(debDir, ".goxc-temp")
if rmtemp {
defer os.RemoveAll(tmpDir)
}
os.MkdirAll(tmpDir, 0755)
err = ioutil.WriteFile(filepath.Join(tmpDir, "debian-binary"), []byte("2.0\n"), 0644)
if err != nil {
return err
}
description := "?"
if desc, keyExists := metadata["description"]; keyExists {
description, err = typeutils.ToString(desc, "description")
if err != nil {
return err
}
}
maintainer := "?"
if maint, keyExists := metadata["maintainer"]; keyExists {
maintainer, err = typeutils.ToString(maint, "maintainer")
if err != nil {
return err
}
}
controlContent := getDebControlFileContent(tp.AppName, maintainer, tp.Settings.GetFullVersionName(), dest.Arch, armArchName, description, metadataDeb)
if tp.Settings.IsVerbose() {
log.Printf("Control file:\n%s", string(controlContent))
}
err = ioutil.WriteFile(filepath.Join(tmpDir, "control"), controlContent, 0644)
if err != nil {
return err
}
err = archive.TarGz(filepath.Join(tmpDir, "control.tar.gz"), []archive.ArchiveItem{archive.ArchiveItem{FileSystemPath: filepath.Join(tmpDir, "control"), ArchivePath: "control"}})
if err != nil {
return err
}
//build
items := []archive.ArchiveItem{}
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
}
items = append(items, archive.ArchiveItem{FileSystemPath: binPath, ArchivePath: "/usr/bin/" + exeName})
}
//TODO add resources to /usr/share/appName/
err = archive.TarGz(filepath.Join(tmpDir, "data.tar.gz"), items)
if err != nil {
return err
}
targetFile := filepath.Join(debDir, fmt.Sprintf("%s_%s_%s.deb", tp.AppName, tp.Settings.GetFullVersionName(), getDebArch(dest.Arch, armArchName))) //goxc_0.5.2_i386.deb")
inputs := [][]string{
[]string{filepath.Join(tmpDir, "debian-binary"), "debian-binary"},
[]string{filepath.Join(tmpDir, "control.tar.gz"), "control.tar.gz"},
[]string{filepath.Join(tmpDir, "data.tar.gz"), "data.tar.gz"}}
err = ar.ArForDeb(targetFile, inputs)
return
}
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 loadSettingsSection(settingsSection map[string]interface{}) (settings Settings, err error) {
settings = Settings{}
for k, v := range settingsSection {
//try to match key
switch k {
case "Tasks":
settings.Tasks, err = typeutils.ToStringSlice(v, k)
case "TasksExclude":
settings.TasksExclude, err = typeutils.ToStringSlice(v, k)
case "TasksAppend":
settings.TasksAppend, err = typeutils.ToStringSlice(v, k)
case "TasksPrepend":
settings.TasksPrepend, err = typeutils.ToStringSlice(v, k)
case "AppName":
settings.AppName, err = typeutils.ToString(v, k)
case "ArtifactsDest":
settings.ArtifactsDest, err = typeutils.ToString(v, k)
case "OutPath":
settings.OutPath, err = typeutils.ToString(v, k)
case "Arch":
settings.Arch, err = typeutils.ToString(v, k)
case "Os":
settings.Os, err = typeutils.ToString(v, k)
case "BuildConstraints":
settings.BuildConstraints, err = typeutils.ToString(v, k)
case "ResourcesInclude":
settings.ResourcesInclude, err = typeutils.ToString(v, k)
case "ResourcesExclude":
settings.ResourcesExclude, err = typeutils.ToString(v, k)
case "MainDirsExclude":
settings.MainDirsExclude, err = typeutils.ToString(v, k)
//deprecated
case "Resources":
for k2, v2 := range v.(map[string]interface{}) {
switch k2 {
case "Include":
settings.ResourcesInclude, err = typeutils.ToString(v2, k+":"+k2)
case "Exclude":
settings.ResourcesExclude, err = typeutils.ToString(v2, k+":"+k2)
}
}
case "PackageVersion":
settings.PackageVersion, err = typeutils.ToString(v, k)
case "BranchName":
settings.BranchName, err = typeutils.ToString(v, k)
case "PrereleaseInfo":
settings.PrereleaseInfo, err = typeutils.ToString(v, k)
case "BuildName":
settings.BuildName, err = typeutils.ToString(v, k)
case "Verbosity":
settings.Verbosity, err = typeutils.ToString(v, k)
case "TaskSettings":
settings.TaskSettings, err = typeutils.ToMapStringMapStringInterface(v, k)
case "FormatVersion":
settings.GoxcConfigVersion, err = typeutils.ToString(v, k)
case "ConfigVersion":
settings.GoxcConfigVersion, err = typeutils.ToString(v, k)
case "BuildSettings":
m, err := typeutils.ToMap(v, k)
if err == nil {
settings.BuildSettings, err = buildSettingsFromMap(m)
if err == nil {
//log.Printf("Parsed build settings OK (%+v)", settings.BuildSettings)
}
}
case "Env":
settings.Env, err = typeutils.ToStringSlice(v, k)
default:
log.Printf("Warning!! Unrecognised Setting '%s' (value %v)", k, v)
}
if err != nil {
return settings, err
}
}
return settings, err
}
func debSourceBuild(tp TaskParams) (err error) {
metadata := tp.Settings.GetTaskSettingMap(TASK_PKG_SOURCE, "metadata")
metadataDeb := tp.Settings.GetTaskSettingMap(TASK_PKG_SOURCE, "metadata-deb")
//default to just package <packagename>
description := "package " + tp.AppName
if desc, keyExists := metadata["description"]; keyExists {
description, err = typeutils.ToString(desc, "description")
if err != nil {
return err
}
}
maintainer := "?"
if maint, keyExists := metadata["maintainer"]; keyExists {
maintainer, err = typeutils.ToString(maint, "maintainer")
if err != nil {
return err
}
}
maintainerEmail := "?"
if maint, keyExists := metadata["maintainerEmail"]; keyExists {
maintainerEmail, err = typeutils.ToString(maint, "maintainerEmail")
if err != nil {
return err
}
}
version := tp.Settings.GetFullVersionName()
arches := "all"
items, err := sdeb.SdebGetSourcesAsArchiveItems(tp.WorkingDirectory, tp.AppName+"-"+tp.Settings.GetFullVersionName())
if err != nil {
return err
}
if err != nil {
return err
}
//build
//1. generate orig.tar.gz
destDir := filepath.Join(tp.OutDestRoot, tp.Settings.GetFullVersionName(), "source-deb")
err = os.MkdirAll(destDir, 0777)
if err != nil {
return err
}
//set up template
templateDir := tp.Settings.GetTaskSettingString(TASK_PKG_SOURCE, "templateDir")
templateVars := getTemplateVars(tp.AppName, tp.Settings.GetFullVersionName(), maintainer, maintainerEmail, tp.Settings.GetFullVersionName(), arches, description, metadataDeb)
//TODO add/exclude resources to /usr/share
origTgzName := tp.AppName + "_" + version + ".orig.tar.gz"
origTgzPath := filepath.Join(destDir, origTgzName)
err = archive.TarGz(origTgzPath, items)
if err != nil {
return err
}
log.Printf("Created %s", origTgzPath)
checksumMd5, checksumSha1, checksumSha256, err := checksums(origTgzPath, origTgzName)
if err != nil {
return err
}
templateVars.Files = append(templateVars.Files, *checksumMd5)
templateVars.ChecksumsSha1 = append(templateVars.ChecksumsSha1, *checksumSha1)
templateVars.ChecksumsSha256 = append(templateVars.ChecksumsSha256, *checksumSha256)
//2. generate .debian.tar.gz (just containing debian/ directory)
//debian/control
controlData, err := getDebMetadataFileContent(filepath.Join(templateDir, "control.tpl"), sdeb.TEMPLATE_SOURCEDEB_CONTROL, templateVars)
if err != nil {
return err
}
//compat
compatData, err := getDebMetadataFileContent(filepath.Join(templateDir, "compat.tpl"), sdeb.TEMPLATE_DEBIAN_COMPAT, templateVars)
if err != nil {
return err
}
//debian/rules
rulesData, err := getDebMetadataFileContent(filepath.Join(templateDir, "rules.tpl"), sdeb.TEMPLATE_DEBIAN_RULES, templateVars)
if err != nil {
return err
}
//debian/source/format
sourceFormatData, err := getDebMetadataFileContent(filepath.Join(templateDir, "source_format.tpl"), sdeb.TEMPLATE_DEBIAN_SOURCE_FORMAT, templateVars)
if err != nil {
return err
}
//debian/source/options
sourceOptionsData, err := getDebMetadataFileContent(filepath.Join(templateDir, "source_options.tpl"), sdeb.TEMPLATE_DEBIAN_SOURCE_OPTIONS, templateVars)
if err != nil {
return err
}
//debian/rules
copyrightData, err := getDebMetadataFileContent(filepath.Join(templateDir, "copyright.tpl"), sdeb.TEMPLATE_DEBIAN_COPYRIGHT, templateVars)
if err != nil {
return err
}
//debian/changelog (slightly different)
changelogFilename := tp.Settings.GetTaskSettingString(TASK_PKG_SOURCE, "changelogFile")
var changelogData []byte
_, err = os.Stat(changelogFilename)
if os.IsNotExist(err) {
initialChangelogTemplate := sdeb.TEMPLATE_CHANGELOG_HEADER + "\n\n" + sdeb.TEMPLATE_CHANGELOG_INITIAL_ENTRY + "\n\n" + sdeb.TEMPLATE_CHANGELOG_FOOTER
changelogData, err = getDebMetadataFileContent(filepath.Join(templateDir, "initial-changelog.tpl"), initialChangelogTemplate, templateVars)
if err != nil {
return err
}
} else if err != nil {
return err
} else {
changelogData, err = ioutil.ReadFile(changelogFilename)
if err != nil {
return err
}
}
//generate debian/README.Debian
//TODO: try pulling in README.md etc
//debian/README.Debian
readmeData, err := getDebMetadataFileContent(filepath.Join(templateDir, "readme.tpl"), sdeb.TEMPLATE_DEBIAN_README, templateVars)
if err != nil {
return err
}
debTgzName := tp.AppName + "_" + version + ".debian.tar.gz"
debTgzPath := filepath.Join(destDir, debTgzName)
err = archive.TarGz(debTgzPath,
[]archive.ArchiveItem{
archive.ArchiveItemFromBytes(changelogData, "debian/changelog"),
archive.ArchiveItemFromBytes(copyrightData, "debian/copyright"),
archive.ArchiveItemFromBytes(compatData, "debian/compat"),
archive.ArchiveItemFromBytes(controlData, "debian/control"),
archive.ArchiveItemFromBytes(readmeData, "debian/README.Debian"),
archive.ArchiveItemFromBytes(rulesData, "debian/rules"),
archive.ArchiveItemFromBytes(sourceFormatData, "debian/source/format"),
archive.ArchiveItemFromBytes(sourceOptionsData, "debian/source/options")})
if err != nil {
return err
}
log.Printf("Created %s", debTgzPath)
checksumMd5, checksumSha1, checksumSha256, err = checksums(debTgzPath, debTgzName)
if err != nil {
return err
}
templateVars.Files = append(templateVars.Files, *checksumMd5)
templateVars.ChecksumsSha1 = append(templateVars.ChecksumsSha1, *checksumSha1)
templateVars.ChecksumsSha256 = append(templateVars.ChecksumsSha256, *checksumSha256)
dscData, err := getDebMetadataFileContent(filepath.Join(templateDir, "dsc.tpl"), sdeb.TEMPLATE_DEBIAN_DSC, templateVars)
if err != nil {
return err
}
//3. generate .dsc file
dscPath := filepath.Join(destDir, tp.AppName+"_"+version+".dsc")
err = ioutil.WriteFile(dscPath, dscData, 0644)
if err == nil {
log.Printf("Wrote %s", dscPath)
}
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 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
}