Pull request: 2546 updater fix

Merge in DNS/adguard-home from 2546-updater-fix to master Closes #2546. Squashed commit of the following: commit af243c9fad710efe099506fda281e628c3e5ec30 Author: Ainar Garipov <A.Garipov@AdGuard.COM> Date: Wed Jan 13 14:33:37 2021 +0300 updater: fix go 1.14 compat commit 742fba24b300ce51c04acb586996c3c75e56ea20 Author: Ainar Garipov <A.Garipov@AdGuard.COM> Date: Wed Jan 13 13:58:27 2021 +0300 util: imp error check commit c2bdbce8af657a7f4b7e05c018cfacba86e06753 Author: Ainar Garipov <A.Garipov@AdGuard.COM> Date: Mon Jan 11 18:51:26 2021 +0300 all: fix and refactor update checking
2021-01-13 16:18:51 +03:00
parent bba74859e2
commit 0d67aa251d
18 changed files with 669 additions and 465 deletions
--- a/internal/updater/check.go
+++ b/internal/updater/check.go
@@ -0,0 +1,117 @@
+package updater
+
+import (
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"strings"
+	"time"
+
+	"github.com/AdguardTeam/AdGuardHome/internal/aghio"
+)
+
+// TODO(a.garipov): Make configurable.
+const versionCheckPeriod = 8 * time.Hour
+
+// VersionInfo contains information about a new version.
+type VersionInfo struct {
+	NewVersion           string
+	Announcement         string
+	AnnouncementURL      string
+	SelfUpdateMinVersion string
+	CanAutoUpdate        bool
+}
+
+// MaxResponseSize is responses on server's requests maximum length in bytes.
+const MaxResponseSize = 64 * 1024
+
+// VersionInfo downloads the latest version information.  If forceRecheck is
+// false and there are cached results, those results are returned.
+func (u *Updater) VersionInfo(forceRecheck bool) (VersionInfo, error) {
+	u.mu.Lock()
+	defer u.mu.Unlock()
+
+	now := time.Now()
+	recheckTime := u.prevCheckTime.Add(versionCheckPeriod)
+	if !forceRecheck && now.Before(recheckTime) {
+		return u.prevCheckResult, u.prevCheckError
+	}
+
+	vcu := u.versionCheckURL
+	resp, err := u.client.Get(vcu)
+	if err != nil {
+		return VersionInfo{}, fmt.Errorf("updater: HTTP GET %s: %w", vcu, err)
+	}
+	defer resp.Body.Close()
+
+	resp.Body, err = aghio.LimitReadCloser(resp.Body, MaxResponseSize)
+	if err != nil {
+		return VersionInfo{}, fmt.Errorf("updater: LimitReadCloser: %w", err)
+	}
+	defer resp.Body.Close()
+
+	// This use of ReadAll is safe, because we just limited the appropriate
+	// ReadCloser.
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return VersionInfo{}, fmt.Errorf("updater: HTTP GET %s: %w", vcu, err)
+	}
+
+	u.prevCheckTime = time.Now()
+	u.prevCheckResult, u.prevCheckError = u.parseVersionResponse(body)
+
+	return u.prevCheckResult, u.prevCheckError
+}
+
+func (u *Updater) parseVersionResponse(data []byte) (VersionInfo, error) {
+	info := VersionInfo{}
+	versionJSON := make(map[string]interface{})
+	err := json.Unmarshal(data, &versionJSON)
+	if err != nil {
+		return info, fmt.Errorf("version.json: %w", err)
+	}
+
+	var ok1, ok2, ok3, ok4 bool
+	info.NewVersion, ok1 = versionJSON["version"].(string)
+	info.Announcement, ok2 = versionJSON["announcement"].(string)
+	info.AnnouncementURL, ok3 = versionJSON["announcement_url"].(string)
+	info.SelfUpdateMinVersion, ok4 = versionJSON["selfupdate_min_version"].(string)
+	if !ok1 || !ok2 || !ok3 || !ok4 {
+		return info, fmt.Errorf("version.json: invalid data")
+	}
+
+	packageURL, ok := u.downloadURL(versionJSON)
+	if ok &&
+		info.NewVersion != u.version &&
+		strings.TrimPrefix(u.version, "v") >= strings.TrimPrefix(info.SelfUpdateMinVersion, "v") {
+		info.CanAutoUpdate = true
+	}
+
+	u.newVersion = info.NewVersion
+	u.packageURL = packageURL
+
+	return info, nil
+}
+
+// downloadURL returns the download URL for current build.
+func (u *Updater) downloadURL(json map[string]interface{}) (string, bool) {
+	var key string
+
+	if u.goarch == "arm" && u.goarm != "" {
+		key = fmt.Sprintf("download_%s_%sv%s", u.goos, u.goarch, u.goarm)
+	} else if u.goarch == "mips" && u.gomips != "" {
+		key = fmt.Sprintf("download_%s_%s_%s", u.goos, u.goarch, u.gomips)
+	}
+
+	val, ok := json[key]
+	if !ok {
+		key = fmt.Sprintf("download_%s_%s", u.goos, u.goarch)
+		val, ok = json[key]
+	}
+
+	if !ok {
+		return "", false
+	}
+
+	return val.(string), true
+}
--- a/internal/updater/testdata/AdGuardHome.tar.gz
+++ b/internal/updater/testdata/AdGuardHome.tar.gz
--- a/internal/updater/testdata/AdGuardHome.zip
+++ b/internal/updater/testdata/AdGuardHome.zip
--- a/internal/updater/updater.go
+++ b/internal/updater/updater.go
@@ -0,0 +1,490 @@
+// Package updater provides an updater for AdGuardHome.
+package updater
+
+import (
+	"archive/tar"
+	"archive/zip"
+	"compress/gzip"
+	"fmt"
+	"io"
+	"io/ioutil"
+	"net/http"
+	"net/url"
+	"os"
+	"os/exec"
+	"path"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/AdguardTeam/AdGuardHome/internal/aghio"
+	"github.com/AdguardTeam/AdGuardHome/internal/util"
+	"github.com/AdguardTeam/AdGuardHome/internal/version"
+	"github.com/AdguardTeam/golibs/log"
+)
+
+// Updater is the AdGuard Home updater.
+type Updater struct {
+	client *http.Client
+
+	version string
+	channel string
+	goarch  string
+	goos    string
+	goarm   string
+	gomips  string
+
+	workDir         string
+	confName        string
+	versionCheckURL string
+
+	// mu protects all fields below.
+	mu *sync.RWMutex
+
+	// TODO(a.garipov): See if all of these fields actually have to be in
+	// this struct.
+	currentExeName string // current binary executable
+	updateDir      string // "workDir/agh-update-v0.103.0"
+	packageName    string // "workDir/agh-update-v0.103.0/pkg_name.tar.gz"
+	backupDir      string // "workDir/agh-backup"
+	backupExeName  string // "workDir/agh-backup/AdGuardHome[.exe]"
+	updateExeName  string // "workDir/agh-update-v0.103.0/AdGuardHome[.exe]"
+	unpackedFiles  []string
+
+	newVersion string
+	packageURL string
+
+	// Cached fields to prevent too many API requests.
+	prevCheckError  error
+	prevCheckTime   time.Time
+	prevCheckResult VersionInfo
+}
+
+// Config is the AdGuard Home updater configuration.
+type Config struct {
+	Client *http.Client
+
+	Version string
+	Channel string
+	GOARCH  string
+	GOOS    string
+	GOARM   string
+	GOMIPS  string
+
+	// ConfName is the name of the current configuration file.  Typically,
+	// "AdGuardHome.yaml".
+	ConfName string
+	// WorkDir is the working directory that is used for temporary files.
+	WorkDir string
+}
+
+// NewUpdater creates a new Updater.
+func NewUpdater(conf *Config) *Updater {
+	u := &url.URL{
+		Scheme: "https",
+		Host:   "static.adguard.com",
+		Path:   path.Join("adguardhome", conf.Channel, "version.json"),
+	}
+	return &Updater{
+		client: conf.Client,
+
+		version: conf.Version,
+		channel: conf.Channel,
+		goarch:  conf.GOARCH,
+		goos:    conf.GOOS,
+		goarm:   conf.GOARM,
+		gomips:  conf.GOMIPS,
+
+		confName:        conf.ConfName,
+		workDir:         conf.WorkDir,
+		versionCheckURL: u.String(),
+
+		mu: &sync.RWMutex{},
+	}
+}
+
+// Update performs the auto-update.
+func (u *Updater) Update() error {
+	u.mu.Lock()
+	defer u.mu.Unlock()
+
+	err := u.prepare()
+	if err != nil {
+		return err
+	}
+
+	defer u.clean()
+
+	err = u.downloadPackageFile(u.packageURL, u.packageName)
+	if err != nil {
+		return err
+	}
+
+	err = u.unpack()
+	if err != nil {
+		return err
+	}
+
+	err = u.check()
+	if err != nil {
+		return err
+	}
+
+	err = u.backup()
+	if err != nil {
+		return err
+	}
+
+	err = u.replace()
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+// NewVersion returns the available new version.
+func (u *Updater) NewVersion() (nv string) {
+	u.mu.RLock()
+	defer u.mu.RUnlock()
+
+	return u.newVersion
+}
+
+// VersionCheckURL returns the version check URL.
+func (u *Updater) VersionCheckURL() (vcu string) {
+	u.mu.RLock()
+	defer u.mu.RUnlock()
+
+	return u.versionCheckURL
+}
+
+func (u *Updater) prepare() error {
+	u.updateDir = filepath.Join(u.workDir, fmt.Sprintf("agh-update-%s", u.newVersion))
+
+	_, pkgNameOnly := filepath.Split(u.packageURL)
+	if pkgNameOnly == "" {
+		return fmt.Errorf("invalid PackageURL")
+	}
+
+	u.packageName = filepath.Join(u.updateDir, pkgNameOnly)
+	u.backupDir = filepath.Join(u.workDir, "agh-backup")
+
+	exeName := "AdGuardHome"
+	if u.goos == "windows" {
+		exeName = "AdGuardHome.exe"
+	}
+
+	u.backupExeName = filepath.Join(u.backupDir, exeName)
+	u.updateExeName = filepath.Join(u.updateDir, exeName)
+
+	log.Info("Updating from %s to %s.  URL:%s", version.Version(), u.newVersion, u.packageURL)
+
+	// If the binary file isn't found in working directory, we won't be able
+	// to auto-update.  Getting the full path to the current binary file on
+	// Unix and checking write permissions is more difficult.
+	u.currentExeName = filepath.Join(u.workDir, exeName)
+	if !util.FileExists(u.currentExeName) {
+		return fmt.Errorf("executable file %s doesn't exist", u.currentExeName)
+	}
+
+	return nil
+}
+
+func (u *Updater) unpack() error {
+	var err error
+	_, pkgNameOnly := filepath.Split(u.packageURL)
+
+	log.Debug("updater: unpacking the package")
+	if strings.HasSuffix(pkgNameOnly, ".zip") {
+		u.unpackedFiles, err = zipFileUnpack(u.packageName, u.updateDir)
+		if err != nil {
+			return fmt.Errorf(".zip unpack failed: %w", err)
+		}
+
+	} else if strings.HasSuffix(pkgNameOnly, ".tar.gz") {
+		u.unpackedFiles, err = tarGzFileUnpack(u.packageName, u.updateDir)
+		if err != nil {
+			return fmt.Errorf(".tar.gz unpack failed: %w", err)
+		}
+
+	} else {
+		return fmt.Errorf("unknown package extension")
+	}
+
+	return nil
+}
+
+func (u *Updater) check() error {
+	log.Debug("updater: checking configuration")
+	err := copyFile(u.confName, filepath.Join(u.updateDir, "AdGuardHome.yaml"))
+	if err != nil {
+		return fmt.Errorf("copyFile() failed: %w", err)
+	}
+	cmd := exec.Command(u.updateExeName, "--check-config")
+	err = cmd.Run()
+	if err != nil || cmd.ProcessState.ExitCode() != 0 {
+		return fmt.Errorf("exec.Command(): %s %d", err, cmd.ProcessState.ExitCode())
+	}
+	return nil
+}
+
+func (u *Updater) backup() error {
+	log.Debug("updater: backing up the current configuration")
+	_ = os.Mkdir(u.backupDir, 0o755)
+	err := copyFile(u.confName, filepath.Join(u.backupDir, "AdGuardHome.yaml"))
+	if err != nil {
+		return fmt.Errorf("copyFile() failed: %w", err)
+	}
+
+	wd := u.workDir
+	err = copySupportingFiles(u.unpackedFiles, wd, u.backupDir)
+	if err != nil {
+		return fmt.Errorf("copySupportingFiles(%s, %s) failed: %s",
+			wd, u.backupDir, err)
+	}
+
+	return nil
+}
+
+func (u *Updater) replace() error {
+	err := copySupportingFiles(u.unpackedFiles, u.updateDir, u.workDir)
+	if err != nil {
+		return fmt.Errorf("copySupportingFiles(%s, %s) failed: %s", u.updateDir, u.workDir, err)
+	}
+
+	log.Debug("updater: renaming: %s -> %s", u.currentExeName, u.backupExeName)
+	err = os.Rename(u.currentExeName, u.backupExeName)
+	if err != nil {
+		return err
+	}
+
+	if u.goos == "windows" {
+		// rename fails with "File in use" error
+		err = copyFile(u.updateExeName, u.currentExeName)
+	} else {
+		err = os.Rename(u.updateExeName, u.currentExeName)
+	}
+	if err != nil {
+		return err
+	}
+
+	log.Debug("updater: renamed: %s -> %s", u.updateExeName, u.currentExeName)
+
+	return nil
+}
+
+func (u *Updater) clean() {
+	_ = os.RemoveAll(u.updateDir)
+}
+
+// MaxPackageFileSize is a maximum package file length in bytes. The largest
+// package whose size is limited by this constant currently has the size of
+// approximately 9 MiB.
+const MaxPackageFileSize = 32 * 1024 * 1024
+
+// Download package file and save it to disk
+func (u *Updater) downloadPackageFile(url, filename string) error {
+	resp, err := u.client.Get(url)
+	if err != nil {
+		return fmt.Errorf("http request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	resp.Body, err = aghio.LimitReadCloser(resp.Body, MaxPackageFileSize)
+	if err != nil {
+		return fmt.Errorf("http request failed: %w", err)
+	}
+	defer resp.Body.Close()
+
+	log.Debug("updater: reading HTTP body")
+	// This use of ReadAll is now safe, because we limited body's Reader.
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return fmt.Errorf("ioutil.ReadAll() failed: %w", err)
+	}
+
+	_ = os.Mkdir(u.updateDir, 0o755)
+
+	log.Debug("updater: saving package to file")
+	err = ioutil.WriteFile(filename, body, 0o644)
+	if err != nil {
+		return fmt.Errorf("ioutil.WriteFile() failed: %w", err)
+	}
+	return nil
+}
+
+// Unpack all files from .tar.gz file to the specified directory
+// Existing files are overwritten
+// All files are created inside 'outdir', subdirectories are not created
+// Return the list of files (not directories) written
+func tarGzFileUnpack(tarfile, outdir string) ([]string, error) {
+	f, err := os.Open(tarfile)
+	if err != nil {
+		return nil, fmt.Errorf("os.Open(): %w", err)
+	}
+	defer func() {
+		_ = f.Close()
+	}()
+
+	gzReader, err := gzip.NewReader(f)
+	if err != nil {
+		return nil, fmt.Errorf("gzip.NewReader(): %w", err)
+	}
+
+	var files []string
+	var err2 error
+	tarReader := tar.NewReader(gzReader)
+	for {
+		header, err := tarReader.Next()
+		if err == io.EOF {
+			err2 = nil
+			break
+		}
+		if err != nil {
+			err2 = fmt.Errorf("tarReader.Next(): %w", err)
+			break
+		}
+
+		_, inputNameOnly := filepath.Split(header.Name)
+		if inputNameOnly == "" {
+			continue
+		}
+
+		outputName := filepath.Join(outdir, inputNameOnly)
+
+		if header.Typeflag == tar.TypeDir {
+			err = os.Mkdir(outputName, os.FileMode(header.Mode&0o777))
+			if err != nil && !os.IsExist(err) {
+				err2 = fmt.Errorf("os.Mkdir(%s): %w", outputName, err)
+				break
+			}
+			log.Debug("updater: created directory %s", outputName)
+			continue
+		} else if header.Typeflag != tar.TypeReg {
+			log.Debug("updater: %s: unknown file type %d, skipping", inputNameOnly, header.Typeflag)
+			continue
+		}
+
+		f, err := os.OpenFile(outputName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, os.FileMode(header.Mode&0o777))
+		if err != nil {
+			err2 = fmt.Errorf("os.OpenFile(%s): %w", outputName, err)
+			break
+		}
+		_, err = io.Copy(f, tarReader)
+		if err != nil {
+			_ = f.Close()
+			err2 = fmt.Errorf("io.Copy(): %w", err)
+			break
+		}
+		err = f.Close()
+		if err != nil {
+			err2 = fmt.Errorf("f.Close(): %w", err)
+			break
+		}
+
+		log.Debug("updater: created file %s", outputName)
+		files = append(files, header.Name)
+	}
+
+	_ = gzReader.Close()
+	return files, err2
+}
+
+// Unpack all files from .zip file to the specified directory
+// Existing files are overwritten
+// All files are created inside 'outdir', subdirectories are not created
+// Return the list of files (not directories) written
+func zipFileUnpack(zipfile, outdir string) ([]string, error) {
+	r, err := zip.OpenReader(zipfile)
+	if err != nil {
+		return nil, fmt.Errorf("zip.OpenReader(): %w", err)
+	}
+	defer r.Close()
+
+	var files []string
+	var err2 error
+	var zr io.ReadCloser
+	for _, zf := range r.File {
+		zr, err = zf.Open()
+		if err != nil {
+			err2 = fmt.Errorf("zip file Open(): %w", err)
+			break
+		}
+
+		fi := zf.FileInfo()
+		inputNameOnly := fi.Name()
+		if inputNameOnly == "" {
+			continue
+		}
+
+		outputName := filepath.Join(outdir, inputNameOnly)
+
+		if fi.IsDir() {
+			err = os.Mkdir(outputName, fi.Mode())
+			if err != nil && !os.IsExist(err) {
+				err2 = fmt.Errorf("os.Mkdir(): %w", err)
+				break
+			}
+			log.Tracef("created directory %s", outputName)
+			continue
+		}
+
+		f, err := os.OpenFile(outputName, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, fi.Mode())
+		if err != nil {
+			err2 = fmt.Errorf("os.OpenFile(): %w", err)
+			break
+		}
+		_, err = io.Copy(f, zr)
+		if err != nil {
+			_ = f.Close()
+			err2 = fmt.Errorf("io.Copy(): %w", err)
+			break
+		}
+		err = f.Close()
+		if err != nil {
+			err2 = fmt.Errorf("f.Close(): %w", err)
+			break
+		}
+
+		log.Tracef("created file %s", outputName)
+		files = append(files, inputNameOnly)
+	}
+
+	_ = zr.Close()
+	return files, err2
+}
+
+// Copy file on disk
+func copyFile(src, dst string) error {
+	d, e := ioutil.ReadFile(src)
+	if e != nil {
+		return e
+	}
+	e = ioutil.WriteFile(dst, d, 0o644)
+	if e != nil {
+		return e
+	}
+	return nil
+}
+
+func copySupportingFiles(files []string, srcdir, dstdir string) error {
+	for _, f := range files {
+		_, name := filepath.Split(f)
+		if name == "AdGuardHome" || name == "AdGuardHome.exe" || name == "AdGuardHome.yaml" {
+			continue
+		}
+
+		src := filepath.Join(srcdir, name)
+		dst := filepath.Join(dstdir, name)
+
+		err := copyFile(src, dst)
+		if err != nil && !os.IsNotExist(err) {
+			return err
+		}
+
+		log.Debug("updater: copied: %s -> %s", src, dst)
+	}
+	return nil
+}
--- a/internal/updater/updater_test.go
+++ b/internal/updater/updater_test.go
@@ -0,0 +1,316 @@
+package updater
+
+import (
+	"io/ioutil"
+	"net"
+	"net/http"
+	"net/url"
+	"os"
+	"path"
+	"path/filepath"
+	"strconv"
+	"testing"
+
+	"github.com/AdguardTeam/AdGuardHome/internal/testutil"
+	"github.com/stretchr/testify/assert"
+)
+
+// TODO(a.garipov): Rewrite these tests.
+
+func TestMain(m *testing.M) {
+	testutil.DiscardLogOutput(m)
+}
+
+func startHTTPServer(data string) (l net.Listener, portStr string) {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", func(w http.ResponseWriter, _ *http.Request) {
+		_, _ = w.Write([]byte(data))
+	})
+
+	listener, err := net.Listen("tcp", ":0")
+	if err != nil {
+		panic(err)
+	}
+
+	go func() { _ = http.Serve(listener, mux) }()
+	return listener, strconv.FormatUint(uint64(listener.Addr().(*net.TCPAddr).Port), 10)
+}
+
+func TestUpdateGetVersion(t *testing.T) {
+	const jsonData = `{
+  "version": "v0.103.0-beta.2",
+  "announcement": "AdGuard Home v0.103.0-beta.2 is now available!",
+  "announcement_url": "https://github.com/AdguardTeam/AdGuardHome/internal/releases",
+  "selfupdate_min_version": "v0.0",
+  "download_windows_amd64": "https://static.adguard.com/adguardhome/beta/AdGuardHome_windows_amd64.zip",
+  "download_windows_386": "https://static.adguard.com/adguardhome/beta/AdGuardHome_windows_386.zip",
+  "download_darwin_amd64": "https://static.adguard.com/adguardhome/beta/AdGuardHome_darwin_amd64.zip",
+  "download_darwin_386": "https://static.adguard.com/adguardhome/beta/AdGuardHome_darwin_386.zip",
+  "download_linux_amd64": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_amd64.tar.gz",
+  "download_linux_386": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_386.tar.gz",
+  "download_linux_arm": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_armv6.tar.gz",
+  "download_linux_armv5": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_armv5.tar.gz",
+  "download_linux_armv6": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_armv6.tar.gz",
+  "download_linux_armv7": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_armv7.tar.gz",
+  "download_linux_arm64": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_arm64.tar.gz",
+  "download_linux_mips": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_mips_softfloat.tar.gz",
+  "download_linux_mipsle": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_mipsle_softfloat.tar.gz",
+  "download_linux_mips64": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_mips64_softfloat.tar.gz",
+  "download_linux_mips64le": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_mips64le_softfloat.tar.gz",
+  "download_freebsd_386": "https://static.adguard.com/adguardhome/beta/AdGuardHome_freebsd_386.tar.gz",
+  "download_freebsd_amd64": "https://static.adguard.com/adguardhome/beta/AdGuardHome_freebsd_amd64.tar.gz",
+  "download_freebsd_arm": "https://static.adguard.com/adguardhome/beta/AdGuardHome_freebsd_armv6.tar.gz",
+  "download_freebsd_armv5": "https://static.adguard.com/adguardhome/beta/AdGuardHome_freebsd_armv5.tar.gz",
+  "download_freebsd_armv6": "https://static.adguard.com/adguardhome/beta/AdGuardHome_freebsd_armv6.tar.gz",
+  "download_freebsd_armv7": "https://static.adguard.com/adguardhome/beta/AdGuardHome_freebsd_armv7.tar.gz",
+  "download_freebsd_arm64": "https://static.adguard.com/adguardhome/beta/AdGuardHome_freebsd_arm64.tar.gz"
+}`
+
+	l, lport := startHTTPServer(jsonData)
+	t.Cleanup(func() { assert.Nil(t, l.Close()) })
+
+	u := NewUpdater(&Config{
+		Client:  &http.Client{},
+		Version: "v0.103.0-beta.1",
+		Channel: "beta",
+		GOARCH:  "arm",
+		GOOS:    "linux",
+	})
+
+	fakeURL := &url.URL{
+		Scheme: "http",
+		Host:   net.JoinHostPort("127.0.0.1", lport),
+		Path:   path.Join("adguardhome", "beta", "version.json"),
+	}
+	u.versionCheckURL = fakeURL.String()
+
+	info, err := u.VersionInfo(false)
+	assert.Nil(t, err)
+	assert.Equal(t, "v0.103.0-beta.2", info.NewVersion)
+	assert.Equal(t, "AdGuard Home v0.103.0-beta.2 is now available!", info.Announcement)
+	assert.Equal(t, "https://github.com/AdguardTeam/AdGuardHome/internal/releases", info.AnnouncementURL)
+	assert.Equal(t, "v0.0", info.SelfUpdateMinVersion)
+	assert.True(t, info.CanAutoUpdate)
+
+	// check cached
+	_, err = u.VersionInfo(false)
+	assert.Nil(t, err)
+}
+
+func TestUpdate(t *testing.T) {
+	// TODO(a.garipov): Uncomment and remove the code below in Go 1.15.
+	//
+	//   wd := t.TempDir()
+	wd, err := ioutil.TempDir("", "aghtest")
+	assert.Nil(t, err)
+	t.Cleanup(func() { assert.Nil(t, os.RemoveAll(wd)) })
+
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "AdGuardHome"), []byte("AdGuardHome"), 0o755))
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "README.md"), []byte("README.md"), 0o644))
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "LICENSE.txt"), []byte("LICENSE.txt"), 0o644))
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "AdGuardHome.yaml"), []byte("AdGuardHome.yaml"), 0o644))
+
+	// start server for returning package file
+	pkgData, err := ioutil.ReadFile("testdata/AdGuardHome.tar.gz")
+	assert.Nil(t, err)
+	l, lport := startHTTPServer(string(pkgData))
+	t.Cleanup(func() { assert.Nil(t, l.Close()) })
+
+	u := NewUpdater(&Config{
+		Client:  &http.Client{},
+		Version: "v0.103.0",
+	})
+
+	fakeURL := &url.URL{
+		Scheme: "http",
+		Host:   net.JoinHostPort("127.0.0.1", lport),
+		Path:   "AdGuardHome.tar.gz",
+	}
+
+	u.workDir = wd
+	u.confName = filepath.Join(u.workDir, "AdGuardHome.yaml")
+	u.newVersion = "v0.103.1"
+	u.packageURL = fakeURL.String()
+
+	assert.Nil(t, u.prepare())
+	u.currentExeName = filepath.Join(wd, "AdGuardHome")
+	assert.Nil(t, u.downloadPackageFile(u.packageURL, u.packageName))
+	assert.Nil(t, u.unpack())
+	// assert.Nil(t, u.check())
+	assert.Nil(t, u.backup())
+	assert.Nil(t, u.replace())
+	u.clean()
+
+	// check backup files
+	d, err := ioutil.ReadFile(filepath.Join(wd, "agh-backup", "AdGuardHome.yaml"))
+	assert.Nil(t, err)
+	assert.Equal(t, "AdGuardHome.yaml", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "agh-backup", "AdGuardHome"))
+	assert.Nil(t, err)
+	assert.Equal(t, "AdGuardHome", string(d))
+
+	// check updated files
+	d, err = ioutil.ReadFile(filepath.Join(wd, "AdGuardHome"))
+	assert.Nil(t, err)
+	assert.Equal(t, "1", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "README.md"))
+	assert.Nil(t, err)
+	assert.Equal(t, "2", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "LICENSE.txt"))
+	assert.Nil(t, err)
+	assert.Equal(t, "3", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "AdGuardHome.yaml"))
+	assert.Nil(t, err)
+	assert.Equal(t, "AdGuardHome.yaml", string(d))
+}
+
+func TestUpdateWindows(t *testing.T) {
+	// TODO(a.garipov): Uncomment and remove the code below in Go 1.15.
+	//
+	//   wd := t.TempDir()
+	wd, err := ioutil.TempDir("", "aghtest")
+	assert.Nil(t, err)
+	t.Cleanup(func() { assert.Nil(t, os.RemoveAll(wd)) })
+
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "AdGuardHome.exe"), []byte("AdGuardHome.exe"), 0o755))
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "README.md"), []byte("README.md"), 0o644))
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "LICENSE.txt"), []byte("LICENSE.txt"), 0o644))
+	assert.Nil(t, ioutil.WriteFile(filepath.Join(wd, "AdGuardHome.yaml"), []byte("AdGuardHome.yaml"), 0o644))
+
+	// start server for returning package file
+	pkgData, err := ioutil.ReadFile("testdata/AdGuardHome.zip")
+	assert.Nil(t, err)
+
+	l, lport := startHTTPServer(string(pkgData))
+	t.Cleanup(func() { assert.Nil(t, l.Close()) })
+
+	u := NewUpdater(&Config{
+		Client:  &http.Client{},
+		GOOS:    "windows",
+		Version: "v0.103.0",
+	})
+
+	fakeURL := &url.URL{
+		Scheme: "http",
+		Host:   net.JoinHostPort("127.0.0.1", lport),
+		Path:   "AdGuardHome.zip",
+	}
+
+	u.workDir = wd
+	u.confName = filepath.Join(u.workDir, "AdGuardHome.yaml")
+	u.newVersion = "v0.103.1"
+	u.packageURL = fakeURL.String()
+
+	assert.Nil(t, u.prepare())
+	u.currentExeName = filepath.Join(wd, "AdGuardHome.exe")
+	assert.Nil(t, u.downloadPackageFile(u.packageURL, u.packageName))
+	assert.Nil(t, u.unpack())
+	// assert.Nil(t, u.check())
+	assert.Nil(t, u.backup())
+	assert.Nil(t, u.replace())
+	u.clean()
+
+	// check backup files
+	d, err := ioutil.ReadFile(filepath.Join(wd, "agh-backup", "AdGuardHome.yaml"))
+	assert.Nil(t, err)
+	assert.Equal(t, "AdGuardHome.yaml", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "agh-backup", "AdGuardHome.exe"))
+	assert.Nil(t, err)
+	assert.Equal(t, "AdGuardHome.exe", string(d))
+
+	// check updated files
+	d, err = ioutil.ReadFile(filepath.Join(wd, "AdGuardHome.exe"))
+	assert.Nil(t, err)
+	assert.Equal(t, "1", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "README.md"))
+	assert.Nil(t, err)
+	assert.Equal(t, "2", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "LICENSE.txt"))
+	assert.Nil(t, err)
+	assert.Equal(t, "3", string(d))
+
+	d, err = ioutil.ReadFile(filepath.Join(wd, "AdGuardHome.yaml"))
+	assert.Nil(t, err)
+	assert.Equal(t, "AdGuardHome.yaml", string(d))
+}
+
+func TestUpdater_VersionInto_ARM(t *testing.T) {
+	const jsonData = `{
+  "version": "v0.103.0-beta.2",
+  "announcement": "AdGuard Home v0.103.0-beta.2 is now available!",
+  "announcement_url": "https://github.com/AdguardTeam/AdGuardHome/internal/releases",
+  "selfupdate_min_version": "v0.0",
+  "download_linux_armv7": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_armv7.tar.gz"
+}`
+
+	l, lport := startHTTPServer(jsonData)
+	t.Cleanup(func() { assert.Nil(t, l.Close()) })
+
+	u := NewUpdater(&Config{
+		Client:  &http.Client{},
+		Version: "v0.103.0-beta.1",
+		Channel: "beta",
+		GOARCH:  "arm",
+		GOOS:    "linux",
+		GOARM:   "7",
+	})
+
+	fakeURL := &url.URL{
+		Scheme: "http",
+		Host:   net.JoinHostPort("127.0.0.1", lport),
+		Path:   path.Join("adguardhome", "beta", "version.json"),
+	}
+	u.versionCheckURL = fakeURL.String()
+
+	info, err := u.VersionInfo(false)
+	assert.Nil(t, err)
+	assert.Equal(t, "v0.103.0-beta.2", info.NewVersion)
+	assert.Equal(t, "AdGuard Home v0.103.0-beta.2 is now available!", info.Announcement)
+	assert.Equal(t, "https://github.com/AdguardTeam/AdGuardHome/internal/releases", info.AnnouncementURL)
+	assert.Equal(t, "v0.0", info.SelfUpdateMinVersion)
+	assert.True(t, info.CanAutoUpdate)
+}
+
+func TestUpdater_VersionInto_MIPS(t *testing.T) {
+	const jsonData = `{
+  "version": "v0.103.0-beta.2",
+  "announcement": "AdGuard Home v0.103.0-beta.2 is now available!",
+  "announcement_url": "https://github.com/AdguardTeam/AdGuardHome/internal/releases",
+  "selfupdate_min_version": "v0.0",
+  "download_linux_mips_softfloat": "https://static.adguard.com/adguardhome/beta/AdGuardHome_linux_mips_softfloat.tar.gz"
+}`
+
+	l, lport := startHTTPServer(jsonData)
+	t.Cleanup(func() { assert.Nil(t, l.Close()) })
+
+	u := NewUpdater(&Config{
+		Client:  &http.Client{},
+		Version: "v0.103.0-beta.1",
+		Channel: "beta",
+		GOARCH:  "mips",
+		GOOS:    "linux",
+		GOMIPS:  "softfloat",
+	})
+
+	fakeURL := &url.URL{
+		Scheme: "http",
+		Host:   net.JoinHostPort("127.0.0.1", lport),
+		Path:   path.Join("adguardhome", "beta", "version.json"),
+	}
+	u.versionCheckURL = fakeURL.String()
+
+	info, err := u.VersionInfo(false)
+	assert.Nil(t, err)
+	assert.Equal(t, "v0.103.0-beta.2", info.NewVersion)
+	assert.Equal(t, "AdGuard Home v0.103.0-beta.2 is now available!", info.Announcement)
+	assert.Equal(t, "https://github.com/AdguardTeam/AdGuardHome/internal/releases", info.AnnouncementURL)
+	assert.Equal(t, "v0.0", info.SelfUpdateMinVersion)
+	assert.True(t, info.CanAutoUpdate)
+}