name string

debname string

debdeps []string

debpre string

description string

buildPkgs []string

binaryName string

archiveFiles []archiveFile

systemdService string

installationFiles []archiveFile

tags []string

src string

dst string

perm os.FileMode

all := targets["all"]

pkgs, _ := filepath.Glob("cmd/*")

for _, pkg := range pkgs {

if files, err := filepath.Glob(pkg + "/*.go"); err != nil || len(files) == 0 {

// No go files in the directory

continue

}

all.buildPkgs = append(all.buildPkgs, fmt.Sprintf("github.com/syncthing/syncthing/%s", pkg))

}

targets["all"] = all

// The "syncthing" target includes a few more files found in the "etc"

// and "extra" dirs.

syncthingPkg := targets["syncthing"]

for _, file := range listFiles("etc") {

syncthingPkg.archiveFiles = append(syncthingPkg.archiveFiles, archiveFile{src: file, dst: file, perm: 0o644})

}

for _, file := range listFiles("extra") {

syncthingPkg.archiveFiles = append(syncthingPkg.archiveFiles, archiveFile{src: file, dst: file, perm: 0o644})

}

for _, file := range listFiles("extra") {

syncthingPkg.installationFiles = append(syncthingPkg.installationFiles, archiveFile{src: file, dst: "deb/usr/share/doc/syncthing/" + filepath.Base(file), perm: 0o644})

}

targets["syncthing"] = syncthingPkg

log.SetFlags(0)

parseFlags()

if debug {

t0 := time.Now()

defer func() {

log.Println("... build completed in", time.Since(t0))

}()

}

initTargets()

// Invoking build.go with no parameters at all builds everything (incrementally),

// which is what you want for maximum error checking during development.

if flag.NArg() == 0 {

runCommand("install", targets["all"])

} else {

// with any command given but not a target, the target is

// "syncthing". So "go run build.go install" is "go run build.go install

// syncthing" etc.

targetName := "syncthing"

if flag.NArg() > 1 {

targetName = flag.Arg(1)

}

target, ok := targets[targetName]

if !ok {

log.Fatalln("Unknown target", target)

}

runCommand(flag.Arg(0), target)

}

var tags []string

if noupgrade {

tags = []string{"noupgrade"}

}

tags = append(tags, strings.Fields(extraTags)...)

switch cmd {

case "install":

install(target, tags)

metalintShort()

case "build":

build(target, tags)

case "test":

test(strings.Fields(extraTags), "github.com/syncthing/syncthing/lib/...", "github.com/syncthing/syncthing/cmd/...")

case "bench":

bench(strings.Fields(extraTags), "github.com/syncthing/syncthing/lib/...", "github.com/syncthing/syncthing/cmd/...")

case "integration":

integration(false)

case "integrationbench":

integration(true)

case "assets":

rebuildAssets()

case "update-deps":

updateDependencies()

case "proto":

proto()

case "testmocks":

testmocks()

case "translate":

translate()

case "transifex":

transifex()

case "weblate":

weblate()

case "tar":

buildTar(target, tags)

writeCompatJSON()

case "zip":

buildZip(target, tags)

writeCompatJSON()

case "deb":

buildDeb(target)

case "vet":

metalintShort()

case "lint":

metalintShort()

case "metalint":

metalint()

case "version":

fmt.Println(getVersion())

case "changelog":

vers, err := currentAndLatestVersions(numVersions)

if err != nil {

log.Fatal(err)

}

for _, ver := range vers {

underline := strings.Repeat("=", len(ver))

msg, err := tagMessage(ver)

if err != nil {

log.Fatal(err)

}

fmt.Printf("%s\n%s\n\n%s\n\n", ver, underline, msg)

}

default:

log.Fatalf("Unknown command %q", cmd)

}

flag.StringVar(&goarch, "goarch", runtime.GOARCH, "GOARCH")

flag.StringVar(&goos, "goos", runtime.GOOS, "GOOS")

flag.StringVar(&goCmd, "gocmd", "go", "Specify `go` command")

flag.BoolVar(&noupgrade, "no-upgrade", noupgrade, "Disable upgrade functionality")

flag.StringVar(&version, "version", getVersion(), "Set compiled in version string")

flag.BoolVar(&race, "race", race, "Use race detector")

flag.StringVar(&extraTags, "tags", extraTags, "Extra tags, space separated")

flag.StringVar(&installSuffix, "installsuffix", installSuffix, "Install suffix, optional")

flag.StringVar(&pkgdir, "pkgdir", "", "Set -pkgdir parameter for `go build`")

flag.StringVar(&cc, "cc", os.Getenv("CC"), "Set CC environment variable for `go build`")

flag.BoolVar(&debugBinary, "debug-binary", debugBinary, "Create unoptimized binary to use with delve, set -gcflags='-N -l' and omit -ldflags")

flag.BoolVar(&coverage, "coverage", coverage, "Write coverage profile of tests to coverage.txt")

flag.BoolVar(&long, "long", long, "Run tests without the -short flag")

flag.IntVar(&numVersions, "num-versions", numVersions, "Number of versions for changelog command")

flag.StringVar(&run, "run", "", "Specify which tests to run")

flag.StringVar(&benchRun, "bench", "", "Specify which benchmarks to run")

flag.BoolVar(&withNextGenGUI, "with-next-gen-gui", withNextGenGUI, "Also build 'newgui'")

flag.StringVar(&buildOut, "build-out", "", "Set the '-o' value for 'go build'")

flag.Parse()

lazyRebuildAssets()

args := []string{"test", "-tags", strings.Join(tags, " ")}

if long {

timeout = longTimeout

} else {

args = append(args, "-short")

}

args = append(args, "-timeout", timeout)

if runtime.GOARCH == "amd64" {

switch runtime.GOOS {

case buildpkg.Darwin, buildpkg.Linux, buildpkg.FreeBSD: // , "windows": # See https://github.com/golang/go/issues/27089

args = append(args, "-race")

}

}

if coverage {

args = append(args, "-covermode", "atomic", "-coverprofile", "coverage.txt", "-coverpkg", strings.Join(pkgs, ","))

}

args = append(args, runArgs()...)

runPrint(goCmd, append(args, pkgs...)...)

lazyRebuildAssets()

args := append([]string{"test", "-run", "NONE", "-tags", strings.Join(tags, " ")}, benchArgs()...)

runPrint(goCmd, append(args, pkgs...)...)

lazyRebuildAssets()

args := []string{"test", "-v", "-timeout", "60m", "-tags"}

tags := "integration"

if bench {

tags += ",benchmark"

}

args = append(args, tags)

args = append(args, runArgs()...)

if bench {

if run == "" {

args = append(args, "-run", "Benchmark")

}

args = append(args, benchArgs()...)

}

args = append(args, "./test")

fmt.Println(args)

runPrint(goCmd, args...)

if run == "" {

return nil

}

return []string{"-run", run}

if benchRun == "" {

return []string{"-bench", "."}

}

return []string{"-bench", benchRun}

if (target.name == "syncthing" || target.name == "") && !withNextGenGUI {

log.Println("Notice: Next generation GUI will not be built; see --with-next-gen-gui.")

}

lazyRebuildAssets()

tags = append(target.tags, tags...)

cwd, err := os.Getwd()

if err != nil {

log.Fatal(err)

}

os.Setenv("GOBIN", filepath.Join(cwd, "bin"))

setBuildEnvVars()

// On Windows generate a special file which the Go compiler will

// automatically use when generating Windows binaries to set things like

// the file icon, version, etc.

if goos == "windows" {

sysoPath, err := shouldBuildSyso(cwd)

if err != nil {

log.Printf("Warning: Windows binaries will not have file information encoded: %v", err)

}

defer shouldCleanupSyso(sysoPath)

}

args := []string{"install", "-v"}

args = appendParameters(args, tags, target.buildPkgs...)

runPrint(goCmd, args...)

if (target.name == "syncthing" || target.name == "") && !withNextGenGUI {

log.Println("Notice: Next generation GUI will not be built; see --with-next-gen-gui.")

}

lazyRebuildAssets()

tags = append(target.tags, tags...)

rmr(target.BinaryName())

setBuildEnvVars()

// On Windows generate a special file which the Go compiler will

// automatically use when generating Windows binaries to set things like

// the file icon, version, etc.

if goos == "windows" {

cwd, err := os.Getwd()

if err != nil {

log.Fatal(err)

}

sysoPath, err := shouldBuildSyso(cwd)

if err != nil {

log.Printf("Warning: Windows binaries will not have file information encoded: %v", err)

}

defer shouldCleanupSyso(sysoPath)

}

args := []string{"build", "-v"}

if buildOut != "" {

args = append(args, "-o", buildOut)

}

args = appendParameters(args, tags, target.buildPkgs...)

runPrint(goCmd, args...)

os.Setenv("GOOS", goos)

os.Setenv("GOARCH", goarch)

os.Setenv("CC", cc)

if os.Getenv("CGO_ENABLED") == "" {

switch goos {

case "darwin", "solaris":

default:

os.Setenv("CGO_ENABLED", "0")

}

}

if pkgdir != "" {

args = append(args, "-pkgdir", pkgdir)

}

if len(tags) > 0 {

args = append(args, "-tags", strings.Join(tags, " "))

}

if installSuffix != "" {

args = append(args, "-installsuffix", installSuffix)

}

if race {

args = append(args, "-race")

}

if !debugBinary {

// Regular binaries get version tagged and skip some debug symbols

args = append(args, "-trimpath", "-ldflags", ldflags(tags))

} else {

// -gcflags to disable optimizations and inlining. Skip -ldflags

// because `Could not launch program: decoding dwarf section info at

// offset 0x0: too short` on 'dlv exec ...' see

// https://github.com/go-delve/delve/issues/79

args = append(args, "-gcflags", "all=-N -l")

}

return append(args, pkgs...)

name := archiveName(target)

filename := name + ".tar.gz"

for _, tag := range tags {

if tag == "noupgrade" {

name += "-noupgrade"

break

}

}

build(target, tags)

codesign(target)

for i := range target.archiveFiles {

target.archiveFiles[i].src = strings.Replace(target.archiveFiles[i].src, "{{binary}}", target.BinaryName(), 1)

target.archiveFiles[i].dst = strings.Replace(target.archiveFiles[i].dst, "{{binary}}", target.BinaryName(), 1)

target.archiveFiles[i].dst = name + "/" + target.archiveFiles[i].dst

}

tarGz(filename, target.archiveFiles)

fmt.Println(filename)

name := archiveName(target)

filename := name + ".zip"

for _, tag := range tags {

if tag == "noupgrade" {

name += "-noupgrade"

break

}

}

build(target, tags)

codesign(target)

for i := range target.archiveFiles {

target.archiveFiles[i].src = strings.Replace(target.archiveFiles[i].src, "{{binary}}", target.BinaryName(), 1)

target.archiveFiles[i].dst = strings.Replace(target.archiveFiles[i].dst, "{{binary}}", target.BinaryName(), 1)

target.archiveFiles[i].dst = name + "/" + target.archiveFiles[i].dst

}

zipFile(filename, target.archiveFiles)

fmt.Println(filename)

os.RemoveAll("deb")

// "goarch" here is set to whatever the Debian packages expect. We correct

// it to what we actually know how to build and keep the Debian variant

// name in "debarch".

debarch := goarch

switch goarch {

case "i386":

goarch = "386"

case "armel", "armhf":

goarch = "arm"

}

build(target, []string{"noupgrade"})

for i := range target.installationFiles {

target.installationFiles[i].src = strings.Replace(target.installationFiles[i].src, "{{binary}}", target.BinaryName(), 1)

target.installationFiles[i].dst = strings.Replace(target.installationFiles[i].dst, "{{binary}}", target.BinaryName(), 1)

}

for _, af := range target.installationFiles {

if err := copyFile(af.src, af.dst, af.perm); err != nil {

log.Fatal(err)

}

}

maintainer := "Syncthing Release Management <release@syncthing.net>"

debver := version

if strings.HasPrefix(debver, "v") {

debver = debver[1:]

// Debian interprets dashes as separator between main version and

// Debian package version, and thus thinks 0.14.26-rc.1 is better

// than just 0.14.26. This rectifies that.

debver = strings.Replace(debver, "-", "~", -1)

}

args := []string{

"-t", "deb",

"-s", "dir",

"-C", "deb",

"-n", target.debname,

"-v", debver,

"-a", debarch,

"-m", maintainer,

"--vendor", maintainer,

"--description", target.description,

"--url", "https://syncthing.net/",

"--license", "MPL-2",

}

for _, dep := range target.debdeps {

args = append(args, "-d", dep)

}

if target.systemdService != "" {

debpost, err := createPostInstScript(target)

defer os.Remove(debpost)

if err != nil {

log.Fatal(err)

}

args = append(args, "--after-upgrade", debpost)

}

if target.debpre != "" {

args = append(args, "--before-install", target.debpre)

}

runPrint("fpm", args...)

scriptname := filepath.Join("script", "deb-post-inst.template")

t, err := template.ParseFiles(scriptname)

if err != nil {

return "", err

}

scriptname = strings.TrimSuffix(scriptname, ".template")

w, err := os.Create(scriptname)

if err != nil {

return "", err

}

defer w.Close()

if err = t.Execute(w, struct {

Service, Command string

}{

target.systemdService, target.binaryName,

}); err != nil {

return "", err

}

return scriptname, nil

type M map[string]interface{}

version := getVersion()

version = strings.TrimPrefix(version, "v")

major, minor, patch := semanticVersion()

bs, err := json.Marshal(M{

"FixedFileInfo": M{

"FileVersion": M{

"Major": major,

"Minor": minor,

"Patch": patch,

},

"ProductVersion": M{

"Major": major,

"Minor": minor,

"Patch": patch,

},

},

"StringFileInfo": M{

"CompanyName": "The Syncthing Authors",

"FileDescription": "Syncthing - Open Source Continuous File Synchronization",

"FileVersion": version,

"InternalName": "syncthing",

"LegalCopyright": "The Syncthing Authors",

"OriginalFilename": "syncthing",

"ProductName": "Syncthing",

"ProductVersion": version,

},

"IconPath": "assets/logo.ico",

})

if err != nil {

return "", err

}

jsonPath := filepath.Join(dir, "versioninfo.json")

err = os.WriteFile(jsonPath, bs, 0o644)

if err != nil {

return "", errors.New("failed to create " + jsonPath + ": " + err.Error())

}

defer func() {

if err := os.Remove(jsonPath); err != nil {

log.Printf("Warning: unable to remove generated %s: %v. Please remove it manually.", jsonPath, err)

}

}()

sysoPath := filepath.Join(dir, "cmd", "syncthing", "resource.syso")

// See https://github.com/josephspurrier/goversioninfo#command-line-flags

armOption := ""

if strings.Contains(goarch, "arm") {

armOption = "-arm=true"

}

if _, err := runError("goversioninfo", "-o", sysoPath, armOption); err != nil {

return "", errors.New("failed to create " + sysoPath + ": " + err.Error())

}

return sysoPath, nil

if sysoFilePath == "" {

return

}

if err := os.Remove(sysoFilePath); err != nil {

log.Printf("Warning: unable to remove generated %s: %v. Please remove it manually.", sysoFilePath, err)

}

in, err := os.ReadFile(src)

if err != nil {

return err

}

out, err := os.ReadFile(dst)

if err != nil {

// The destination probably doesn't exist, we should create

// it.

goto copy

}

if bytes.Equal(in, out) {

// The permission bits may have changed without the contents

// changing so we always mirror them.

os.Chmod(dst, perm)

return nil

}

copy:

os.MkdirAll(filepath.Dir(dst), 0o777)

if err := os.WriteFile(dst, in, perm); err != nil {

return err

}

return nil

var res []string

filepath.Walk(dir, func(path string, fi os.FileInfo, err error) error {

if err != nil {

return err

}

if fi.Mode().IsRegular() {

res = append(res, path)

}

return nil

})

return res

shouldRebuild := shouldRebuildAssets("lib/api/auto/gui.files.go", "gui") ||

shouldRebuildAssets("cmd/infra/strelaypoolsrv/auto/gui.files.go", "cmd/infra/strelaypoolsrv/gui")

if withNextGenGUI {

shouldRebuild = buildNextGenGUI() || shouldRebuild

}

if shouldRebuild {

rebuildAssets()

}

// Check if we need to run the npm process, and if so also set the flag

// to rebuild Go assets afterwards. The index.html is regenerated every

// time by the build process. This assumes the new GUI ends up in

// next-gen-gui/dist/next-gen-gui.

if !shouldRebuildAssets("gui/next-gen-gui/index.html", "next-gen-gui") {

// The GUI is up to date.

return false

}

runPrintInDir("next-gen-gui", "npm", "install")

runPrintInDir("next-gen-gui", "npm", "run", "build", "--", "--prod", "--subresource-integrity")

rmr("gui/tech-ui")

for _, src := range listFiles("next-gen-gui/dist") {

rel, _ := filepath.Rel("next-gen-gui/dist", src)

dst := filepath.Join("gui", rel)

if err := copyFile(src, dst, 0o644); err != nil {

fmt.Println("copy:", err)

os.Exit(1)

}

}

return true

info, err := os.Stat(target)

if err != nil {

// If the file doesn't exist, we must rebuild it

return true

}

// Check if any of the files in gui/ are newer than the asset file. If

// so we should rebuild it.

currentBuild := info.ModTime()

assetsAreNewer := false

stop := errors.New("no need to iterate further")

filepath.Walk(srcdir, func(path string, info os.FileInfo, err error) error {

if err != nil {

return err

}

if info.ModTime().After(currentBuild) {

assetsAreNewer = true

return stop

}

return nil

})

return assetsAreNewer

// Figure out desired Go version

bs, err := os.ReadFile("go.mod")

if err != nil {

log.Fatal(err)

}

re := regexp.MustCompile(`(?m)^go\s+([0-9.]+)`)

matches := re.FindSubmatch(bs)

if len(matches) != 2 {

log.Fatal("failed to parse go.mod")

}

goVersion := string(matches[1])

runPrint(goCmd, "get", "-u", "./...")

runPrint(goCmd, "mod", "tidy", "-go="+goVersion, "-compat="+goVersion)

// We might have updated the protobuf package and should regenerate to match.

proto()

// buf needs to be installed

// https://buf.build/docs/installation/

runPrint("buf", "generate")

args := []string{

"generate",

"github.com/syncthing/syncthing/lib/config",

"github.com/syncthing/syncthing/lib/connections",

"github.com/syncthing/syncthing/lib/discover",

"github.com/syncthing/syncthing/lib/events",

"github.com/syncthing/syncthing/lib/logger",

"github.com/syncthing/syncthing/lib/model",

"github.com/syncthing/syncthing/lib/protocol",

}

runPrint(goCmd, args...)

os.Chdir("gui/default/assets/lang")

runPipe("lang-en-new.json", goCmd, "run", "../../../../script/translate.go", "lang-en.json", "../../../")

os.Remove("lang-en.json")

err := os.Rename("lang-en-new.json", "lang-en.json")

if err != nil {

log.Fatal(err)

}

os.Chdir("../../../..")

b := new(strings.Builder)

b.WriteString("-w")

fmt.Fprintf(b, " -X github.com/syncthing/syncthing/lib/build.Version=%s", version)

fmt.Fprintf(b, " -X github.com/syncthing/syncthing/lib/build.Stamp=%d", buildStamp())

fmt.Fprintf(b, " -X github.com/syncthing/syncthing/lib/build.User=%s", buildUser())

fmt.Fprintf(b, " -X github.com/syncthing/syncthing/lib/build.Host=%s", buildHost())

fmt.Fprintf(b, " -X github.com/syncthing/syncthing/lib/build.Tags=%s", strings.Join(tags, ","))

if v := os.Getenv("EXTRA_LDFLAGS"); v != "" {

fmt.Fprintf(b, " %s", v)

}

return b.String()

for _, path := range paths {

if debug {

log.Println("rm -r", path)

}

os.RemoveAll(path)

}

bs, err := os.ReadFile("RELEASE")

if err != nil {

return "", err

}

return string(bytes.TrimSpace(bs)), nil

// The current version as Git sees it

bs, err := runError("git", "describe", "--always", "--dirty", "--abbrev=8")

if err != nil {

return "", err

}

vcur := string(bs)

// The closest current tag name

bs, err = runError("git", "describe", "--always", "--abbrev=0")

if err != nil {

return "", err

}

v0 := string(bs)

// To be more semantic-versionish and ensure proper ordering in our

// upgrade process, we make sure there's only one hyphen in the version.

versionRe := regexp.MustCompile(`-([0-9]{1,3}-g[0-9a-f]{5,10}(-dirty)?)`)